config.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142


#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"

char *read_file(const char *filename, long *size) {
	/* Open the file. */
	FILE *fp = fopen(filename, "r");
	/* Size of the file, in bytes. */
	long filesize = 0;
	/* Buffer of the file contents. */
	char *buf;

	/* Return NULL, if we couldn't open the file. */
	if (fp == NULL) {
		fclose(fp);
		return NULL;
	}

	/* Return NULL, if we couldn't seek to the end of the file. */
	if (fseek(fp, 0L, SEEK_END)) {
		fclose(fp);
		return NULL;
	}

	/* Get the size of the file, in bytes. */
	filesize = ftell(fp);

	/* Return NULL, if the returned size is negative. */
	if (filesize < 0) {
		fclose(fp);
		return NULL;
	}

	/* Allocate enough space for the entire file, plus one. */
	buf = malloc(filesize+1);

	/* Return NULL, if the buffer wasn't allocated. */
	if (buf == NULL) {
		fclose(fp);
		return NULL;
	}

	/* Zero out the buffer. */
	memset(buf, 0, filesize+1);

	/* Seek back to the start of the file. */
	rewind(fp);
	/* Read the entire file contents into the buffer. */
	fread(buf, sizeof(char), filesize, fp);
	/* Close the file. */
	fclose(fp);

	/* Return the filesize, in bytes. */
	*size = filesize;
	/* Return the buffer. */
	return buf;
}

char *get_line(char **str) {
	char *s;
	size_t i;
	char *tmp = *str;

	for (i = 0; tmp[i] != '\n' && tmp[i] != '\0'; i++);

	s = malloc(i+1);
	memset(s, 0, i+1);
	memcpy(s, *str, i);

	*str += (i+1);
	return s;
}

config_val parse_option_value(const config_opt *opt, char *value) {
	config_val val = {0};

	switch (opt->type) {
		case TYPE_INT	: val.i = strtol(value, NULL, 0); break;
		case TYPE_STRING: val.str = value; break;
		case TYPE_FLOAT	: val.f = strtof(value, NULL); break;
		case TYPE_BOOL	: val.b = strtol(value, NULL, 0); break;
		default		: break;
	}

	return val;
}

void set_config_opt(config *conf, config_type type, size_t offset, config_val val) {
	switch (type) {
		case TYPE_INT	: *(int *)(conf+offset) = val.i; break;
		case TYPE_STRING: *(char **)(conf+offset) = val.str; break;
		case TYPE_FLOAT	: *(float *)(conf+offset) = val.f; break;
		case TYPE_BOOL	: *(int *)(conf+offset) = val.b; break;
		default		: break;
	}
}

config *parse_config(const char *filename) {
	/* Size of the file, in bytes. */
	long filesize = 0;
	/* Config settings. */
	config *cfg;
	/* Buffer of the file contents. */
	char *buf = read_file(filename, &filesize);
	char *tmp = buf;

	/* Return NULL, if the buffer wasn't allocated */
	if (buf == NULL) {
		return NULL;
	}

	cfg = malloc(sizeof(config));

	/* Return NULL, if cfg wasn't allocated. */
	if (cfg == NULL) {
		free(buf);
		return NULL;
	}

	while (*tmp != '\0') {
		char *line = get_line(&tmp);
		char *value;
		char *name = strtok_r(line, "=", &value);
		const config_opt *opt;

		/* Check to see if the config option name we got is valid. */
		for (opt = config_opts; opt->name != NULL && strcmp(name, opt->name); opt++);

		/* Is the config option valid? */
		if (opt->name != NULL) {
			config_val val = parse_option_value(opt, value);
			set_config_opt(cfg, opt->type, opt->offset, val);
		}

		free(line);
	}

	free(buf);
	return cfg;
}