VitaShell/config.c

/*
	VitaShell
	Copyright (C) 2015-2017, TheFloW

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "main.h"
#include "file.h"
#include "config.h"

static void trim(char *str) {
	int len = strlen(str);
	int i;

	for (i = len-1; i >= 0; i--) {
		if (str[i] == 0x20 || str[i] == '\t') {
			str[i] = 0;
		} else {
			break;
		}
	}
}

static int GetLine(char *buf, int size, char *str) {
	uint8_t ch = 0;
	int n = 0;
	int i = 0;
	uint8_t *s = (uint8_t *)str;

	while (1) {
		if (i >= size)
			break;

		ch = ((uint8_t *)buf)[i];

		if (ch < 0x20 && ch != '\t') {
			if (n != 0) {
				i++;
				break;
			}
		} else {
			*str++ = ch;
			n++;
		}

		i++;
	}

	trim((char *)s);

	return i;
}

static int getDecimal(const char *str) {
	return strtol(str, NULL, 0);
}

static int getHexdecimal(const char *str) {
	return strtoul(str, NULL, 16);
}

static int getBoolean(const char *str) {
	if (strcasecmp(str, "false") == 0 || strcasecmp(str, "off") == 0 || strcasecmp(str, "no") == 0)
		return 0;

	if (strcasecmp(str, "true") == 0 || strcasecmp(str, "on") == 0 || strcasecmp(str, "yes") == 0)
		return 1;

	return -1;
}

static char *getString(const char *str) {
	if (str[0] != '"')
		return NULL;

	char *p = strchr(str+1, '"');
	if (!p)
		return NULL;

	int len = p - (str+1);

	char *out = malloc(len+1);
	strncpy(out, str+1, len);
	out[len] = '\0';

	int i;
	for (i = 0; i < len; i++) {
		if (out[i] == '\\')
			out[i] = '\n';
	}

	return out;
}

static int readEntry(const char *line, ConfigEntry *entries, int n_entries) {
	// Trim at beginning
	while (*line == ' ' || *line == '\t')
		line++;

	// Ignore comments #1
	if (line[0] == '#') {
		// debugPrintf("IGNORE %s\n", line);
		return 0;
	}

	// Ignore comments #2
	char *p = strchr(line, '#');
	if (p) {
		// debugPrintf("IGNORE %s\n", p);
		*p = '\0';
	}

	// Get token
	p = strchr(line, '=');
	if (!p)
		return -1;

	// Name of entry
	char name[MAX_CONFIG_NAME_LENGTH];
	int len = p - line;
	if (len > MAX_CONFIG_NAME_LENGTH-1)
		len = MAX_CONFIG_NAME_LENGTH-1;
	strncpy(name, line, len);
	name[len] = '\0';

	trim(name);

	// debugPrintf("NAME: %s\n", name);

	// String of entry
	char *string = p+1;

	// Trim at beginning
	while (*string == ' ' || *string == '\t')
		string++;

	// Trim at end
	trim(string);

	// debugPrintf("STRING: %s\n", string);

	int i;
	for (i = 0; i < n_entries; i++) {
		if (strcasecmp(name, entries[i].name) == 0) {
			switch (entries[i].type) {
				case CONFIG_TYPE_DECIMAL:
					*(uint32_t *)entries[i].value = getDecimal(string);
					// debugPrintf("VALUE DECIMAL: %d\n", *(uint32_t *)entries[i].value);
					break;
					
				case CONFIG_TYPE_HEXDECIMAL:
					*(uint32_t *)entries[i].value = getHexdecimal(string);
					// debugPrintf("VALUE HEXDECIMAL: 0x%X\n", *(uint32_t *)entries[i].value);
					break;
					
				case CONFIG_TYPE_BOOLEAN:
					*(uint32_t *)entries[i].value = getBoolean(string);
					// debugPrintf("VALUE BOOLEAN: %d\n", *(uint32_t *)entries[i].value);
					break;
					
				case CONFIG_TYPE_STRING:
				{
					char *value = getString(string);
					if (value) {
						*(uint32_t *)entries[i].value = (uint32_t)value;
						// debugPrintf("VALUE STRING: %s\n", *(uint32_t *)entries[i].value);
					}

					break;
				}
			}

			break;
		}
	}

	return 1;
}

int readConfigBuffer(void *buffer, int size, ConfigEntry *entries, int n_entries) {
	int res = 0;
	char line[MAX_CONFIG_LINE_LENGTH];
	char *p = buffer;

	// Skip UTF-8 bom
	uint32_t bom = 0xBFBBEF;
	if (memcmp(p, &bom, 3) == 0) {
		p += 3;
		size -= 3;
	}

	do {
		memset(line, 0, sizeof(line));
		res = GetLine(p, size, line);

		if (res > 0) {
			readEntry(line, entries, n_entries);
			size -= res;
			p += res;
		}
	} while (res > 0);

	return 0;
}

int readConfig(const char *path, ConfigEntry *entries, int n_entries) {
	void *buffer = NULL;
	int size = allocateReadFile(path, &buffer);
	if (size < 0)
		return size;

	readConfigBuffer(buffer, size, entries, n_entries);

	free(buffer);

	return 0;
}

static int writeEntry(SceUID fd, ConfigEntry *entry) {
	if (!entry->value)
		return -1;

    int result;
    if ((result = sceIoWrite(fd, entry->name, strlen(entry->name))) < 0)
        return result;

    if ((result = sceIoWrite(fd, " = ", 3)) < 0)
        return result;

    char *val;
    char buffer[33];

    switch (entry->type) {
        case CONFIG_TYPE_BOOLEAN:
            val = *(uint32_t *)entry->value != 0 ? "true" : "false";
            result = sceIoWrite(fd, val, strlen(val));
            break;
			
        case CONFIG_TYPE_DECIMAL:
            itoa(*(int *)entry->value, buffer, 10);
            result = sceIoWrite(fd, buffer, strlen(buffer));
            break;
			
        case CONFIG_TYPE_HEXDECIMAL:
            itoa(*(int *)entry->value, buffer, 16);
            result = sceIoWrite(fd, buffer, strlen(buffer));
            break;
			
        case CONFIG_TYPE_STRING:
            val = *(char **)entry->value;
            sceIoWrite(fd, "\"", 1);
            result = sceIoWrite(fd, val, strlen(val));
            sceIoWrite(fd, "\"", 1);
            break;
			
        default:
            return 1;
    }

    if (result < 0)
        return result;

    if ((sceIoWrite(fd, "\n", 1)) < 0)
        return result;

    return 0;
}

int writeConfig(const char *path, ConfigEntry *entries, int n_entries) {
    SceUID fd = sceIoOpen(path, SCE_O_WRONLY | SCE_O_CREAT | SCE_O_TRUNC, 0777);
    if (fd < 0)
        return fd;

    int i;
    for (i = 0; i < n_entries; i++) {
        int result = writeEntry(fd, entries+i);
        if (result != 0) {
            return result;
        }
    }

    sceIoClose(fd);

    return 0;
}