vfs: check userland buffers before reading them.

[haiku.git] / src / system / libroot / os / driver_settings.cpp

/*
 * Copyright 2002-2007, Axel Dörfler, axeld@pinc-software.de.
 * This file may be used under the terms of the MIT License.
 */

/*!     \brief Implements the driver settings API
        This file is used by three different components with different needs:
          1) the boot loader
                Buffers a list of settings files to move over to the kernel - the
                actual buffering is located in the boot loader directly, though.
                Creates driver_settings structures out of those on demand only.
          2) the kernel
                Maintains a list of settings so that no disk access is required
                for known settings (such as those passed over from the boot
                loader).
          3) libroot.so
                Exports the parser to userland applications, so that they can
                easily make use of driver_settings styled files.

        The file has to be recompiled for every component separately, so that
        it properly exports the required functionality (which is specified by
        _BOOT_MODE for the boot loader, and _KERNEL_MODE for the kernel).
*/

// The boot loader is compiled with kernel rules, but we want to explicitely
// differentiate between the two here.
#ifdef _BOOT_MODE
#       undef _KERNEL_MODE
#endif

#include <directories.h>
#include <driver_settings.h>
#include <FindDirectory.h>
#include <OS.h>

#ifdef _KERNEL_MODE
#       include <KernelExport.h>
#       include <util/list.h>
#       include <lock.h>
#       include <kdriver_settings.h>
#       include <kernel.h>
#       include <boot/kernel_args.h>
#       include <boot_device.h>
#endif
#ifdef _BOOT_MODE
#       include <boot/kernel_args.h>
#       include <boot/stage2.h>
#else
#       include <find_directory_private.h>
#endif

#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <ctype.h>

#ifndef B_BUFFER_OVERFLOW
#       define B_BUFFER_OVERFLOW B_ERROR
#endif

#define SETTINGS_DIRECTORY "/kernel/drivers/"
#define SETTINGS_MAGIC          'DrvS'

// Those maximum values are independent from the implementation - they
// have been chosen to make the code more robust against bad files
#define MAX_SETTINGS_SIZE       32768
#define MAX_SETTINGS_LEVEL      8

#define CONTINUE_PARAMETER      1
#define NO_PARAMETER 2


typedef struct settings_handle {
#ifdef _KERNEL_MODE
        list_link       link;
        char            name[B_OS_NAME_LENGTH];
        int32           ref_count;
                // A negative ref_count means the node is not reference counted and not
                // stored in the list.
#endif
        int32           magic;
        struct          driver_settings settings;
        char            *text;
} settings_handle;


enum assignment_mode {
        NO_ASSIGNMENT,
        ALLOW_ASSIGNMENT,
        IGNORE_ASSIGNMENT
};


#ifdef _KERNEL_MODE
static struct list sHandles;
static mutex sLock = MUTEX_INITIALIZER("driver settings");
#endif


//      #pragma mark - private functions


/*!
        \brief Returns true for any characters that separate parameters

        Those characters are ignored in the input stream and won't be added
        to any words.
*/
static inline bool
is_parameter_separator(char c)
{
        return c == '\n' || c == ';';
}


/*! Indicates if "c" begins a new word or not.
*/
static inline bool
is_word_break(char c)
{
        return isspace(c) || is_parameter_separator(c);
}


static inline bool
check_handle(settings_handle *handle)
{
        if (handle == NULL
                || handle->magic != SETTINGS_MAGIC)
                return false;

        return true;
}


static driver_parameter *
get_parameter(settings_handle *handle, const char *name)
{
        int32 i;
        for (i = handle->settings.parameter_count; i-- > 0;) {
                if (!strcmp(handle->settings.parameters[i].name, name))
                        return &handle->settings.parameters[i];
        }
        return NULL;
}


/*!
        Returns the next word in the input buffer passed in via "_pos" - if
        this function returns, it will bump the input position after the word.
        It automatically cares about quoted strings and escaped characters.
        If "allowNewLine" is true, it reads over comments to get to the next
        word.
        Depending on the "assignmentMode" parameter, the '=' sign is either
        used as a work break, or not.
        The input buffer will be changed to contain the word without quotes
        or escaped characters and adds a terminating NULL byte. The "_word"
        parameter will be set to the beginning of the word.
        If the word is followed by a newline it will return B_OK, if white
        spaces follows, it will return CONTINUE_PARAMETER.
*/
static status_t
get_word(char **_pos, char **_word, int32 assignmentMode, bool allowNewLine)
{
        char *pos = *_pos;
        char quoted = 0;
        bool newLine = false, end = false;
        int escaped = 0;
        bool charEscaped = false;

        // Skip any white space and comments
        while (pos[0]
                && ((allowNewLine && (isspace(pos[0]) || is_parameter_separator(pos[0])
                                || pos[0] == '#'))
                        || (!allowNewLine && (pos[0] == '\t' || pos[0] == ' '))
                        || (assignmentMode == ALLOW_ASSIGNMENT && pos[0] == '='))) {
                // skip any comment lines
                if (pos[0] == '#') {
                        while (pos[0] && pos[0] != '\n')
                                pos++;
                }
                pos++;
        }

        if (pos[0] == '}' || pos[0] == '\0') {
                // if we just read some white space before an end of a
                // parameter, this is just no parameter at all
                *_pos = pos;
                return NO_PARAMETER;
        }

        // Read in a word - might contain escaped (\) spaces, or it
        // might also be quoted (" or ').

        if (pos[0] == '"' || pos[0] == '\'') {
                quoted = pos[0];
                pos++;
        }
        *_word = pos;

        while (pos[0]) {
                if (charEscaped)
                        charEscaped = false;
                else if (pos[0] == '\\') {
                        charEscaped = true;
                        escaped++;
                } else if ((!quoted && (is_word_break(pos[0])
                                || (assignmentMode != IGNORE_ASSIGNMENT && pos[0] == '=')))
                        || (quoted && pos[0] == quoted))
                        break;

                pos++;
        }

        // "String exceeds line" - missing end quote
        if (quoted && pos[0] != quoted)
                return B_BAD_DATA;

        // last character is a backslash
        if (charEscaped)
                return B_BAD_DATA;

        end = pos[0] == '\0';
        newLine = is_parameter_separator(pos[0]) || end;
        pos[0] = '\0';

        // Correct name if there were any escaped characters
        if (escaped) {
                char *word = *_word;
                int offset = 0;
                while (word <= pos) {
                        if (word[0] == '\\') {
                                offset--;
                                word++;
                        }
                        word[offset] = word[0];
                        word++;
                }
        }

        if (end) {
                *_pos = pos;
                return B_OK;
        }

        // Scan for next beginning word, open brackets, or comment start

        pos++;
        while (true) {
                *_pos = pos;
                if (!pos[0])
                        return B_NO_ERROR;

                if (is_parameter_separator(pos[0])) {
                        // an open bracket '{' could follow after the first
                        // newline, but not later
                        if (newLine)
                                return B_NO_ERROR;

                        newLine = true;
                } else if (pos[0] == '{' || pos[0] == '}' || pos[0] == '#')
                        return B_NO_ERROR;
                else if (!isspace(pos[0]))
                        return newLine ? B_NO_ERROR : CONTINUE_PARAMETER;

                pos++;
        }
}


static status_t
parse_parameter(struct driver_parameter *parameter, char **_pos, int32 level)
{
        char *pos = *_pos;
        status_t status;

        // initialize parameter first
        memset(parameter, 0, sizeof(struct driver_parameter));

        status = get_word(&pos, &parameter->name, NO_ASSIGNMENT, true);
        if (status == CONTINUE_PARAMETER) {
                while (status == CONTINUE_PARAMETER) {
                        char **newArray, *value = NULL;
                        status = get_word(&pos, &value, parameter->value_count == 0
                                ? ALLOW_ASSIGNMENT : IGNORE_ASSIGNMENT, false);
                        if (status < B_OK)
                                break;

                        // enlarge value array and save the value

                        newArray = (char**)realloc(parameter->values,
                                (parameter->value_count + 1) * sizeof(char *));
                        if (newArray == NULL)
                                return B_NO_MEMORY;

                        parameter->values = newArray;
                        parameter->values[parameter->value_count++] = value;
                }
        }

        *_pos = pos;
        return status;
}


static status_t
parse_parameters(struct driver_parameter **_parameters, int *_count,
        char **_pos, int32 level)
{
        if (level > MAX_SETTINGS_LEVEL)
                return B_LINK_LIMIT;

        while (true) {
                struct driver_parameter parameter;
                struct driver_parameter *newArray;
                status_t status;

                status = parse_parameter(&parameter, _pos, level);
                if (status < B_OK)
                        return status;

                if (status != NO_PARAMETER) {
                        driver_parameter *newParameter;

                        newArray = (driver_parameter*)realloc(*_parameters, (*_count + 1)
                                * sizeof(struct driver_parameter));
                        if (newArray == NULL)
                                return B_NO_MEMORY;

                        memcpy(&newArray[*_count], &parameter, sizeof(struct driver_parameter));
                        newParameter = &newArray[*_count];

                        *_parameters = newArray;
                        (*_count)++;

                        // check for level beginning and end
                        if (**_pos == '{') {
                                // if we go a level deeper, just start all over again...
                                (*_pos)++;
                                status = parse_parameters(&newParameter->parameters,
                                                        &newParameter->parameter_count, _pos, level + 1);
                                if (status < B_OK)
                                        return status;
                        }
                }

                if ((**_pos == '}' && level > 0)
                        || (**_pos == '\0' && level == 0)) {
                        // take the closing bracket from the stack
                        (*_pos)++;
                        return B_OK;
                }

                // obviously, something has gone wrong
                if (**_pos == '}' || **_pos == '\0')
                        return B_ERROR;
        }
}


static status_t
parse_settings(settings_handle *handle)
{
        char *text = handle->text;

        memset(&handle->settings, 0, sizeof(struct driver_settings));

        // empty settings are allowed
        if (text == NULL)
                return B_OK;

        return parse_parameters(&handle->settings.parameters,
                &handle->settings.parameter_count, &text, 0);
}


static void
free_parameter(struct driver_parameter *parameter)
{
        int32 i;
        for (i = parameter->parameter_count; i-- > 0;)
                free_parameter(&parameter->parameters[i]);

        free(parameter->parameters);
        free(parameter->values);
}


static void
free_settings(settings_handle *handle)
{
        int32 i;
        for (i = handle->settings.parameter_count; i-- > 0;)
                free_parameter(&handle->settings.parameters[i]);

        free(handle->settings.parameters);
        free(handle->text);
        free(handle);
}


static settings_handle *
new_settings(char *buffer, const char *driverName)
{
        settings_handle *handle = (settings_handle*)malloc(sizeof(settings_handle));
        if (handle == NULL)
                return NULL;

        handle->magic = SETTINGS_MAGIC;
        handle->text = buffer;

#ifdef _KERNEL_MODE
        if (driverName != NULL) {
                handle->ref_count = 1;
                strlcpy(handle->name, driverName, sizeof(handle->name));
        } else {
                handle->ref_count = -1;
                handle->name[0] = 0;
        }
#endif

        if (parse_settings(handle) == B_OK)
                return handle;

        free(handle);
        return NULL;
}


static settings_handle *
load_driver_settings_from_file(int file, const char *driverName)
{
        struct stat stat;

        // Allocate a buffer and read the whole file into it.
        // We will keep this buffer in memory, until the settings
        // are unloaded.
        // The driver_parameter::name field will point directly
        // to this buffer.

        if (fstat(file, &stat) < B_OK)
                return NULL;

        if (stat.st_size > B_OK && stat.st_size < MAX_SETTINGS_SIZE) {
                char *text = (char *)malloc(stat.st_size + 1);
                if (text != NULL && read(file, text, stat.st_size) == stat.st_size) {
                        settings_handle *handle;

                        text[stat.st_size] = '\0';
                                // make sure the string is null terminated
                                // to avoid misbehaviour

                        handle = new_settings(text, driverName);
                        if (handle != NULL) {
                                // everything went fine!
                                return handle;
                        }

                        free(handle);
                }
                // "text" might be NULL here, but that's allowed
                free(text);
        }

        return NULL;
}


static bool
put_string(char **_buffer, ssize_t *_bufferSize, char *string)
{
        size_t length, reserved, quotes;
        char *buffer = *_buffer, c;
        bool quoted;

        if (string == NULL)
                return true;

        for (length = reserved = quotes = 0; (c = string[length]) != '\0'; length++) {
                if (c == '"')
                        quotes++;
                else if (is_word_break(c))
                        reserved++;
        }
        quoted = reserved || quotes;

        // update _bufferSize in any way, so that we can chain several
        // of these calls without having to check the return value
        // everytime
        *_bufferSize -= length + (quoted ? 2 + quotes : 0);

        if (*_bufferSize <= 0)
                return false;

        if (quoted)
                *(buffer++) = '"';

        for (;(c = string[0]) != '\0'; string++) {
                if (c == '"')
                        *(buffer++) = '\\';

                *(buffer++) = c;
        }

        if (quoted)
                *(buffer++) = '"';

        buffer[0] = '\0';

        // update the buffer position
        *_buffer = buffer;

        return true;
}


static bool
put_chars(char **_buffer, ssize_t *_bufferSize, const char *chars)
{
        char *buffer = *_buffer;
        size_t length;

        if (chars == NULL)
                return true;

        length = strlen(chars);
        *_bufferSize -= length;

        if (*_bufferSize <= 0)
                return false;

        memcpy(buffer, chars, length);
        buffer += length;
        buffer[0] = '\0';

        // update the buffer position
        *_buffer = buffer;

        return true;
}


static bool
put_char(char **_buffer, ssize_t *_bufferSize, char c)
{
        char *buffer = *_buffer;

        *_bufferSize -= 1;

        if (*_bufferSize <= 0)
                return false;

        buffer[0] = c;
        buffer[1] = '\0';

        // update the buffer position
        *_buffer = buffer + 1;

        return true;
}


static void
put_level_space(char **_buffer, ssize_t *_bufferSize, int32 level)
{
        while (level-- > 0)
                put_char(_buffer, _bufferSize, '\t');
}


static void
put_parameter(char **_buffer, ssize_t *_bufferSize,
        struct driver_parameter *parameter, int32 level, bool flat)
{
        int32 i;

        if (!flat)
                put_level_space(_buffer, _bufferSize, level);

        put_string(_buffer, _bufferSize, parameter->name);
        if (flat && parameter->value_count > 0)
                put_chars(_buffer, _bufferSize, " =");

        for (i = 0; i < parameter->value_count; i++) {
                put_char(_buffer, _bufferSize, ' ');
                put_string(_buffer, _bufferSize, parameter->values[i]);
        }

        if (parameter->parameter_count > 0) {
                put_chars(_buffer, _bufferSize, " {");
                if (!flat)
                        put_char(_buffer, _bufferSize, '\n');

                for (i = 0; i < parameter->parameter_count; i++) {
                        put_parameter(_buffer, _bufferSize, &parameter->parameters[i],
                                level + 1, flat);

                        if (parameter->parameters[i].parameter_count == 0)
                                put_chars(_buffer, _bufferSize, flat ? "; " : "\n");
                }

                if (!flat)
                        put_level_space(_buffer, _bufferSize, level);
                put_chars(_buffer, _bufferSize, flat ? "}" : "}\n");
        }
}


//      #pragma mark - Kernel only functions


#ifdef _KERNEL_MODE
static settings_handle *
find_driver_settings(const char *name)
{
        settings_handle *handle = NULL;

        ASSERT_LOCKED_MUTEX(&sLock);

        while ((handle = (settings_handle*)list_get_next_item(&sHandles, handle))
                        != NULL) {
                if (!strcmp(handle->name, name))
                        return handle;
        }

        return NULL;
}


status_t
driver_settings_init(kernel_args *args)
{
        struct driver_settings_file *settings = args->driver_settings;

        // Move the preloaded driver settings over to the kernel

        list_init(&sHandles);

        while (settings != NULL) {
                settings_handle *handle
                        = (settings_handle*)malloc(sizeof(settings_handle));
                if (handle == NULL)
                        return B_NO_MEMORY;

                if (settings->size != 0) {
                        handle->text = (char*)malloc(settings->size + 1);
                        if (handle->text == NULL) {
                                free(handle);
                                return B_NO_MEMORY;
                        }

                        memcpy(handle->text, settings->buffer, settings->size);
                        handle->text[settings->size] = '\0';
                                // null terminate the buffer
                } else
                        handle->text = NULL;

                strlcpy(handle->name, settings->name, sizeof(handle->name));
                handle->settings.parameters = NULL;
                handle->settings.parameter_count = 0;
                handle->magic = 0;
                        // this triggers parsing the settings when they are actually used

                if (!strcmp(handle->name, B_SAFEMODE_DRIVER_SETTINGS)) {
                        // These settings cannot be reloaded, so we better don't throw
                        // them away.
                        handle->ref_count = 1;
                } else
                        handle->ref_count = 0;

                list_add_item(&sHandles, handle);

                settings = settings->next;
        }

        return B_OK;
}
#endif


//      #pragma mark - public API


status_t
unload_driver_settings(void *_handle)
{
        settings_handle *handle = (settings_handle *)_handle;
        if (!check_handle(handle))
                return B_BAD_VALUE;

#ifdef _KERNEL_MODE
        mutex_lock(&sLock);

        if (handle->ref_count > 0) {
                if (--handle->ref_count == 0 && gBootDevice > 0) {
                        // don't unload an handle when /boot is not available
                        list_remove_link(&handle->link);
                } else
                        handle = NULL;
        }
        mutex_unlock(&sLock);
#endif

        if (handle != NULL)
                free_settings(handle);

        return B_OK;
}


void *
load_driver_settings(const char *driverName)
{
        settings_handle *handle;
        int file = -1;

        if (driverName == NULL)
                return NULL;

#ifdef _KERNEL_MODE
        // see if we already have these settings loaded
        mutex_lock(&sLock);
        handle = find_driver_settings(driverName);
        if (handle != NULL && handle->ref_count == 0 && gBootDevice > 0) {
                // A handle with a zero ref_count should be unloaded if /boot is
                // available.
                list_remove_link(&handle->link);
                free_settings(handle);
        } else if (handle != NULL) {
                handle->ref_count++;

                // we got it, now let's see if it already has been parsed
                if (handle->magic != SETTINGS_MAGIC) {
                        handle->magic = SETTINGS_MAGIC;

                        if (parse_settings(handle) != B_OK) {
                                // no valid settings, let's cut down its memory requirements
                                free(handle->text);
                                handle->text = NULL;
                                handle = NULL;
                        }
                }
                mutex_unlock(&sLock);
                return handle;
        }

        // we are allowed to call the driver settings pretty early in the boot process
        if (gKernelStartup) {
                mutex_unlock(&sLock);
                return NULL;
        }
#endif  // _KERNEL_MODE
#ifdef _BOOT_MODE
        // see if we already have these settings loaded
        {
                struct driver_settings_file *settings = gKernelArgs.driver_settings;
                while (settings != NULL) {
                        if (!strcmp(settings->name, driverName)) {
                                // we have it - since the buffer is clobbered, we have to
                                // copy its contents, though
                                char *text = (char*)malloc(settings->size + 1);
                                if (text == NULL)
                                        return NULL;

                                memcpy(text, settings->buffer, settings->size + 1);
                                return new_settings(text, driverName);
                        }
                        settings = settings->next;
                }
        }
#endif  // _BOOT_MODE

        // open the settings from the standardized location
        if (driverName[0] != '/') {
                char path[B_FILE_NAME_LENGTH + 64];

#ifdef _BOOT_MODE
                strcpy(path, kUserSettingsDirectory);
#else
                // TODO: use B_SYSTEM_SETTINGS_DIRECTORY instead!
                if (__find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, path,
                                sizeof(path)) == B_OK)
#endif
                {
                        strlcat(path, SETTINGS_DIRECTORY, sizeof(path));
                        strlcat(path, driverName, sizeof(path));
                }

                file = open(path, O_RDONLY);
        } else
                file = open(driverName, O_RDONLY);

        if (file < B_OK) {
#ifdef _KERNEL_MODE
                mutex_unlock(&sLock);
#endif
                return NULL;
        }

        handle = load_driver_settings_from_file(file, driverName);

#ifdef _KERNEL_MODE
        if (handle != NULL)
                list_add_item(&sHandles, handle);
        mutex_unlock(&sLock);
#endif

        close(file);
        return (void *)handle;
}


void*
load_driver_settings_file(int fd)
{
        return load_driver_settings_from_file(fd, NULL);
}


/*!
        Returns a new driver_settings handle that has the parsed contents
        of the passed string.
        You can get an empty driver_settings object when you pass NULL as
        the "settingsString" parameter.
*/
void *
parse_driver_settings_string(const char *settingsString)
{
        char *text = NULL;
        if (settingsString != NULL) {
                // we simply copy the whole string to use it as our internal buffer
                text = strdup(settingsString);
                if (text == NULL)
                        return NULL;
        }

        settings_handle *handle = new_settings(text, NULL);
        if (handle == NULL)
                free(text);
        return handle;
}


/*!
        This function prints out a driver settings structure to a human
        readable string.
        It's either in standard style or the single line style speficied
        by the "flat" parameter.
        If the buffer is too small to hold the string, B_BUFFER_OVERFLOW
        is returned, and the needed amount of bytes if placed in the
        "_bufferSize" parameter.
        If the "handle" parameter is not a valid driver settings handle, or
        the "buffer" parameter is NULL, B_BAD_VALUE is returned.
*/
status_t
get_driver_settings_string(void *_handle, char *buffer, ssize_t *_bufferSize,
        bool flat)
{
        settings_handle *handle = (settings_handle *)_handle;
        ssize_t bufferSize = *_bufferSize;
        int32 i;

        if (!check_handle(handle) || !buffer || *_bufferSize == 0)
                return B_BAD_VALUE;

        for (i = 0; i < handle->settings.parameter_count; i++) {
                put_parameter(&buffer, &bufferSize, &handle->settings.parameters[i],
                        0, flat);
        }

        *_bufferSize -= bufferSize;
        return bufferSize >= 0 ? B_OK : B_BUFFER_OVERFLOW;
}


/*!
        Matches the first value of the parameter matching "keyName" with a set
        of boolean values like 1/true/yes/on/enabled/...
        Returns "unknownValue" if the parameter could not be found or doesn't
        have any valid boolean setting, and "noArgValue" if the parameter
        doesn't have any values.
        Also returns "unknownValue" if the handle passed in was not valid.
*/
bool
get_driver_boolean_parameter(void *_handle, const char *keyName,
        bool unknownValue, bool noArgValue)
{
        settings_handle *handle = (settings_handle*)_handle;
        driver_parameter *parameter;
        char *boolean;

        if (!check_handle(handle))
                return unknownValue;

        // check for the parameter
        if ((parameter = get_parameter(handle, keyName)) == NULL)
                return unknownValue;

        // check for the argument
        if (parameter->value_count <= 0)
                return noArgValue;

        boolean = parameter->values[0];
        if (!strcmp(boolean, "1")
                || !strcasecmp(boolean, "true")
                || !strcasecmp(boolean, "yes")
                || !strcasecmp(boolean, "on")
                || !strcasecmp(boolean, "enable")
                || !strcasecmp(boolean, "enabled"))
                return true;

        if (!strcmp(boolean, "0")
                || !strcasecmp(boolean, "false")
                || !strcasecmp(boolean, "no")
                || !strcasecmp(boolean, "off")
                || !strcasecmp(boolean, "disable")
                || !strcasecmp(boolean, "disabled"))
                return false;

        // if no known keyword is found, "unknownValue" is returned
        return unknownValue;
}


const char *
get_driver_parameter(void *_handle, const char *keyName,
        const char *unknownValue, const char *noArgValue)
{
        settings_handle* handle = (settings_handle*)_handle;
        struct driver_parameter *parameter;

        if (!check_handle(handle))
                return unknownValue;

        // check for the parameter
        if ((parameter = get_parameter(handle, keyName)) == NULL)
                return unknownValue;

        // check for the argument
        if (parameter->value_count <= 0)
                return noArgValue;

        return parameter->values[0];
}


const driver_settings *
get_driver_settings(void *handle)
{
        if (!check_handle((settings_handle*)handle))
                return NULL;

        return &((settings_handle *)handle)->settings;
}


status_t
delete_driver_settings(void *_handle)
{
        return unload_driver_settings(_handle);
}