539 lines
14 KiB
C
539 lines
14 KiB
C
/*
|
|
* Copyright (C) 2014 Glyptodon LLC
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "conf-parse.h"
|
|
|
|
#include <guacamole/client.h>
|
|
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
|
|
/*
|
|
* Simple recursive descent parser for an INI-like conf file grammar. The
|
|
* grammar is, roughly:
|
|
*
|
|
* <line> ::= <opt-whitespace> <declaration> <line-end>
|
|
* <line-end> ::= <opt-whitespace> <opt-comment> <EOL>
|
|
* <declaration> ::= <section-name> | <parameter-value> | ""
|
|
* <section-name> ::= "[" <name> "]"
|
|
* <parameter-value> ::= <name> <opt-whitespace> "=" <opt-whitespace> <value>
|
|
*
|
|
* Where:
|
|
* <opt-whitespace> is any number of tabs or spaces.
|
|
* <opt-comment> is a # character followed by any length of text without an EOL.
|
|
* <name> is an alpha-numeric string consisting of: [A-Za-z0-9_-].
|
|
* <value> is any length of text without an EOL or # character, or a double-quoted string (backslash escapes legal).
|
|
* <EOL> is a carriage return or line feed character.
|
|
*/
|
|
|
|
/**
|
|
* The current section. Note that this means the parser is NOT threadsafe.
|
|
*/
|
|
char __guacd_current_section[GUACD_CONF_MAX_NAME_LENGTH + 1] = "";
|
|
|
|
char* guacd_conf_parse_error = NULL;
|
|
|
|
char* guacd_conf_parse_error_location = NULL;
|
|
|
|
/**
|
|
* Reads through all whitespace at the beginning of the buffer, returning the
|
|
* number of characters read. This is <opt-whitespace> in the grammar above. As
|
|
* the whitespace is zero or more whitespace characters, this function cannot
|
|
* fail, but it may read zero chars overall.
|
|
*/
|
|
static int guacd_parse_whitespace(char* buffer, int length) {
|
|
|
|
int chars_read = 0;
|
|
|
|
/* Read through all whitespace */
|
|
while (chars_read < length) {
|
|
|
|
/* Read character */
|
|
char c = *buffer;
|
|
|
|
/* Stop at non-whitespace */
|
|
if (c != ' ' && c != '\t')
|
|
break;
|
|
|
|
chars_read++;
|
|
buffer++;
|
|
|
|
}
|
|
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parses the name of a parameter, section, etc. A section/parameter name can
|
|
* consist only of alphanumeric characters and underscores. The resulting name
|
|
* will be stored in the name string, which must have at least 256 bytes
|
|
* available.
|
|
*/
|
|
static int guacd_parse_name(char* buffer, int length, char* name) {
|
|
|
|
char* name_start = buffer;
|
|
int chars_read = 0;
|
|
|
|
/* Read through all valid name chars */
|
|
while (chars_read < length) {
|
|
|
|
/* Read character */
|
|
char c = *buffer;
|
|
|
|
/* Stop at non-name characters */
|
|
if (!isalnum(c) && c != '_')
|
|
break;
|
|
|
|
chars_read++;
|
|
buffer++;
|
|
|
|
/* Ensure name does not exceed maximum length */
|
|
if (chars_read > GUACD_CONF_MAX_NAME_LENGTH) {
|
|
guacd_conf_parse_error = "Names can be no more than 255 characters long";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
}
|
|
|
|
/* Names must contain at least one character */
|
|
if (chars_read == 0)
|
|
return 0;
|
|
|
|
/* Copy name from buffer */
|
|
memcpy(name, name_start, chars_read);
|
|
name[chars_read] = '\0';
|
|
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parses the value of a parameter. A value can consist of any character except
|
|
* '#', whitespace, or EOL. The resulting value will be stored in the value
|
|
* string, which must have at least 256 bytes available.
|
|
*/
|
|
static int guacd_parse_value(char* buffer, int length, char* value) {
|
|
|
|
char* value_start = buffer;
|
|
int chars_read = 0;
|
|
|
|
/* Read through all valid value chars */
|
|
while (chars_read < length) {
|
|
|
|
/* Read character */
|
|
char c = *buffer;
|
|
|
|
/* Stop at invalid character */
|
|
if (c == '#' || c == '"' || c == '\r' || c == '\n' || c == ' ' || c == '\t')
|
|
break;
|
|
|
|
chars_read++;
|
|
buffer++;
|
|
|
|
/* Ensure value does not exceed maximum length */
|
|
if (chars_read > GUACD_CONF_MAX_VALUE_LENGTH) {
|
|
guacd_conf_parse_error = "Values can be no more than 8191 characters long";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
}
|
|
|
|
/* Values must contain at least one character */
|
|
if (chars_read == 0) {
|
|
guacd_conf_parse_error = "Unquoted values must contain at least one character";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
/* Copy value from buffer */
|
|
memcpy(value, value_start, chars_read);
|
|
value[chars_read] = '\0';
|
|
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parses the quoted value of a parameter. Quoted values may contain any
|
|
* character except double quotes or backslashes, which must be
|
|
* backslash-escaped.
|
|
*/
|
|
static int guacd_parse_quoted_value(char* buffer, int length, char* value) {
|
|
|
|
int escaped = 0;
|
|
|
|
/* Assert first character is '"' */
|
|
if (length == 0 || *buffer != '"')
|
|
return 0;
|
|
|
|
int chars_read = 1;
|
|
buffer++;
|
|
length--;
|
|
|
|
/* Read until end of quoted value */
|
|
while (chars_read < length) {
|
|
|
|
/* Read character */
|
|
char c = *buffer;
|
|
|
|
/* Handle special characters if not escaped */
|
|
if (!escaped) {
|
|
|
|
/* Stop at quote or invalid character */
|
|
if (c == '"' || c == '\r' || c == '\n')
|
|
break;
|
|
|
|
/* Backslash escaping */
|
|
else if (c == '\\')
|
|
escaped = 1;
|
|
|
|
else
|
|
*(value++) = c;
|
|
|
|
}
|
|
|
|
/* Reset escape flag */
|
|
else {
|
|
escaped = 0;
|
|
*(value++) = c;
|
|
}
|
|
|
|
chars_read++;
|
|
buffer++;
|
|
|
|
/* Ensure value does not exceed maximum length */
|
|
if (chars_read > GUACD_CONF_MAX_VALUE_LENGTH) {
|
|
guacd_conf_parse_error = "Values can be no more than 8191 characters long";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
}
|
|
|
|
/* Assert value ends with '"' */
|
|
if (length == 0 || *buffer != '"') {
|
|
guacd_conf_parse_error = "'\"' expected";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
chars_read++;
|
|
|
|
/* Terminate read value */
|
|
*value = '\0';
|
|
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
/**
|
|
* Reads a parameter/value pair, separated by an '=' character. If the
|
|
* parameter/value pair is invalid for any reason, a negative value is
|
|
* returned.
|
|
*/
|
|
static int guacd_parse_parameter(guacd_param_callback* callback, char* buffer, int length, void* data) {
|
|
|
|
char param_name[GUACD_CONF_MAX_NAME_LENGTH + 1];
|
|
char param_value[GUACD_CONF_MAX_VALUE_LENGTH + 1];
|
|
|
|
int retval;
|
|
int chars_read = 0;
|
|
|
|
char* param_start = buffer;
|
|
|
|
retval = guacd_parse_name(buffer, length, param_name);
|
|
if (retval < 0)
|
|
return -1;
|
|
|
|
/* If no name found, no parameter/value pair */
|
|
if (retval == 0)
|
|
return 0;
|
|
|
|
/* Validate presence of section header */
|
|
if (__guacd_current_section[0] == '\0') {
|
|
guacd_conf_parse_error = "Parameters must have a corresponding section";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* Optional whitespace before '=' */
|
|
retval = guacd_parse_whitespace(buffer, length);
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* Required '=' */
|
|
if (length == 0 || *buffer != '=') {
|
|
guacd_conf_parse_error = "'=' expected";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
chars_read++;
|
|
buffer++;
|
|
length--;
|
|
|
|
/* Optional whitespace before value */
|
|
retval = guacd_parse_whitespace(buffer, length);
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* Quoted parameter value */
|
|
retval = guacd_parse_quoted_value(buffer, length, param_value);
|
|
if (retval < 0)
|
|
return -1;
|
|
|
|
/* Non-quoted parameter value (required if no quoted value given) */
|
|
if (retval == 0) retval = guacd_parse_value(buffer, length, param_value);
|
|
if (retval < 0)
|
|
return -1;
|
|
|
|
chars_read += retval;
|
|
|
|
/* Call callback, handling error code */
|
|
if (callback(__guacd_current_section, param_name, param_value, data)) {
|
|
guacd_conf_parse_error_location = param_start;
|
|
return -1;
|
|
}
|
|
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
/**
|
|
* Reads a section name from the beginning of the given buffer. This section
|
|
* name must conform to the grammar definition. If the section name does not
|
|
* match, a negative value is returned.
|
|
*/
|
|
static int guacd_parse_section(char* buffer, int length) {
|
|
|
|
int retval;
|
|
|
|
/* Assert first character is '[' */
|
|
if (length == 0 || *buffer != '[')
|
|
return 0;
|
|
|
|
int chars_read = 1;
|
|
buffer++;
|
|
length--;
|
|
|
|
retval = guacd_parse_name(buffer, length, __guacd_current_section);
|
|
if (retval < 0)
|
|
return -1;
|
|
|
|
/* If no name found, invalid section */
|
|
if (retval == 0) {
|
|
guacd_conf_parse_error = "Section names must contain at least one character";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* Name must end with ']' */
|
|
if (length == 0 || *buffer != ']') {
|
|
guacd_conf_parse_error = "']' expected";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
chars_read++;
|
|
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parses a declaration, which may be either a section name or a
|
|
* parameter/value pair. The empty string is acceptable, as well, as a
|
|
* "null declaration".
|
|
*/
|
|
static int guacd_parse_declaration(guacd_param_callback* callback, char* buffer, int length, void* data) {
|
|
|
|
int retval;
|
|
|
|
/* Look for section name */
|
|
retval = guacd_parse_section(buffer, length);
|
|
if (retval != 0)
|
|
return retval;
|
|
|
|
/* Lacking a section name, read parameter/value pair */
|
|
retval = guacd_parse_parameter(callback, buffer, length, data);
|
|
if (retval != 0)
|
|
return retval;
|
|
|
|
/* Null declaration (default) */
|
|
return 0;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parses a comment, which must start with a '#' character, and terminate with
|
|
* an end-of-line character. If no EOL is found, or the first character is not
|
|
* a '#', a negative value is returned. Otherwise, the number of characters
|
|
* parsed is returned. If no comment is present, zero is returned.
|
|
*/
|
|
static int guacd_parse_comment(char* buffer, int length) {
|
|
|
|
/* Need at least one character */
|
|
if (length == 0)
|
|
return 0;
|
|
|
|
/* Assert first character is '#' */
|
|
if (*(buffer++) != '#')
|
|
return 0;
|
|
|
|
int chars_read = 1;
|
|
|
|
/* Advance to first non-space character */
|
|
while (chars_read < length) {
|
|
|
|
/* Read character */
|
|
char c = *buffer;
|
|
|
|
/* End of comment found at end of line */
|
|
if (c == '\n' || c == '\r')
|
|
return chars_read;
|
|
|
|
chars_read++;
|
|
buffer++;
|
|
|
|
}
|
|
|
|
/* No end of line in comment */
|
|
guacd_conf_parse_error = "expected end-of-line";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parses the end of a line, which may contain a comment. If a parse error
|
|
* occurs, a negative value is returned. Otherwise, the number of characters
|
|
* parsed is returned.
|
|
*/
|
|
static int guacd_parse_line_end(char* buffer, int length) {
|
|
|
|
int chars_read = 0;
|
|
int retval;
|
|
|
|
/* Initial optional whitespace */
|
|
retval = guacd_parse_whitespace(buffer, length);
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* Optional comment */
|
|
retval = guacd_parse_comment(buffer, length);
|
|
if (retval < 0)
|
|
return -1;
|
|
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* Assert EOL */
|
|
if (length == 0 || (*buffer != '\r' && *buffer != '\n')) {
|
|
guacd_conf_parse_error = "expected end-of-line";
|
|
guacd_conf_parse_error_location = buffer;
|
|
return -1;
|
|
}
|
|
|
|
chars_read++;
|
|
|
|
/* Line is valid */
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parses an entire line - declaration, comment, and all. If a parse error
|
|
* occurs, a negative value is returned. Otherwise, the number of characters
|
|
* parsed is returned.
|
|
*/
|
|
static int guacd_parse_line(guacd_param_callback* callback, char* buffer, int length, void* data) {
|
|
|
|
int chars_read = 0;
|
|
int retval;
|
|
|
|
/* Initial optional whitespace */
|
|
retval = guacd_parse_whitespace(buffer, length);
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* Declaration (which may be the empty string) */
|
|
retval = guacd_parse_declaration(callback, buffer, length, data);
|
|
if (retval < 0)
|
|
return retval;
|
|
|
|
chars_read += retval;
|
|
buffer += retval;
|
|
length -= retval;
|
|
|
|
/* End of line */
|
|
retval = guacd_parse_line_end(buffer, length);
|
|
if (retval < 0)
|
|
return retval;
|
|
|
|
chars_read += retval;
|
|
|
|
return chars_read;
|
|
|
|
}
|
|
|
|
int guacd_parse_conf(guacd_param_callback* callback, char* buffer, int length, void* data) {
|
|
|
|
/* Empty buffers are valid */
|
|
if (length == 0)
|
|
return 0;
|
|
|
|
return guacd_parse_line(callback, buffer, length, data);
|
|
|
|
}
|
|
|
|
int guacd_parse_log_level(const char* name) {
|
|
|
|
/* Translate log level name */
|
|
if (strcmp(name, "info") == 0) return GUAC_LOG_INFO;
|
|
if (strcmp(name, "error") == 0) return GUAC_LOG_ERROR;
|
|
if (strcmp(name, "warning") == 0) return GUAC_LOG_WARNING;
|
|
if (strcmp(name, "debug") == 0) return GUAC_LOG_DEBUG;
|
|
|
|
/* No such log level */
|
|
return -1;
|
|
|
|
}
|
|
|