1 /*-
2 * Copyright (c) 2002-2014 Devin Teske <dteske@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 #include <sys/param.h>
31
32 #include <ctype.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <fnmatch.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <unistd.h>
39
40 #include "figpar.h"
41 #include "string_m.h"
42
43 struct fp_config fp_dummy_config = {0, NULL, {0}, NULL};
44
45 /*
46 * Search for config option (struct fp_config) in the array of config options,
47 * returning the struct whose directive matches the given parameter. If no
48 * match is found, a pointer to the static dummy array (above) is returned.
49 *
50 * This is to eliminate dependency on the index position of an item in the
51 * array, since the index position is more apt to be changed as code grows.
52 */
53 struct fp_config *
get_config_option(struct fp_config options[],const char * directive)54 get_config_option(struct fp_config options[], const char *directive)
55 {
56 uint32_t n;
57
58 /* Check arguments */
59 if (options == NULL || directive == NULL)
60 return (&fp_dummy_config);
61
62 /* Loop through the array, return the index of the first match */
63 for (n = 0; options[n].directive != NULL; n++)
64 if (strcmp(options[n].directive, directive) == 0)
65 return (&(options[n]));
66
67 /* Re-initialize the dummy variable in case it was written to */
68 fp_dummy_config.directive = NULL;
69 fp_dummy_config.type = 0;
70 fp_dummy_config.action = NULL;
71 fp_dummy_config.value.u_num = 0;
72
73 return (&fp_dummy_config);
74 }
75
76 /*
77 * Parse the configuration file at `path' and execute the `action' call-back
78 * functions for any directives defined by the array of config options (first
79 * argument).
80 *
81 * For unknown directives that are encountered, you can optionally pass a
82 * call-back function for the third argument to be called for unknowns.
83 *
84 * Returns zero on success; otherwise returns -1 and errno should be consulted.
85 */
86 int
parse_config(struct fp_config options[],const char * path,int (* unknown)(struct fp_config * option,uint32_t line,char * directive,char * value),uint16_t processing_options)87 parse_config(struct fp_config options[], const char *path,
88 int (*unknown)(struct fp_config *option, uint32_t line, char *directive,
89 char *value), uint16_t processing_options)
90 {
91 uint8_t bequals;
92 uint8_t bsemicolon;
93 uint8_t case_sensitive;
94 uint8_t comment = 0;
95 uint8_t end;
96 uint8_t found;
97 uint8_t have_equals = 0;
98 uint8_t quote;
99 uint8_t require_equals;
100 uint8_t strict_equals;
101 char p[2];
102 char *directive;
103 char *t;
104 char *value;
105 int error;
106 int fd;
107 ssize_t r = 1;
108 uint32_t dsize;
109 uint32_t line = 1;
110 uint32_t n;
111 uint32_t vsize;
112 uint32_t x;
113 off_t charpos;
114 off_t curpos;
115 char rpath[PATH_MAX];
116
117 /* Sanity check: if no options and no unknown function, return */
118 if (options == NULL && unknown == NULL)
119 return (-1);
120
121 /* Processing options */
122 bequals = (processing_options & FP_BREAK_ON_EQUALS) == 0 ? 0 : 1;
123 bsemicolon = (processing_options & FP_BREAK_ON_SEMICOLON) == 0 ? 0 : 1;
124 case_sensitive = (processing_options & FP_CASE_SENSITIVE) == 0 ? 0 : 1;
125 require_equals = (processing_options & FP_REQUIRE_EQUALS) == 0 ? 0 : 1;
126 strict_equals = (processing_options & FP_STRICT_EQUALS) == 0 ? 0 : 1;
127
128 /* Initialize strings */
129 directive = value = 0;
130 vsize = dsize = 0;
131
132 /* Resolve the file path */
133 if (realpath(path, rpath) == 0)
134 return (-1);
135
136 /* Open the file */
137 if ((fd = open(rpath, O_RDONLY)) < 0)
138 return (-1);
139
140 /* Read the file until EOF */
141 while (r != 0) {
142 r = read(fd, p, 1);
143
144 /* skip to the beginning of a directive */
145 while (r != 0 && (isspace(*p) || *p == '#' || comment ||
146 (bsemicolon && *p == ';'))) {
147 if (*p == '#')
148 comment = 1;
149 else if (*p == '\n') {
150 comment = 0;
151 line++;
152 }
153 r = read(fd, p, 1);
154 }
155 /* Test for EOF; if EOF then no directive was found */
156 if (r == 0) {
157 close(fd);
158 return (0);
159 }
160
161 /* Get the current offset */
162 curpos = lseek(fd, 0, SEEK_CUR) - 1;
163 if (curpos == -1) {
164 close(fd);
165 return (-1);
166 }
167
168 /* Find the length of the directive */
169 for (n = 0; r != 0; n++) {
170 if (isspace(*p))
171 break;
172 if (bequals && *p == '=') {
173 have_equals = 1;
174 break;
175 }
176 if (bsemicolon && *p == ';')
177 break;
178 r = read(fd, p, 1);
179 }
180
181 /* Test for EOF, if EOF then no directive was found */
182 if (n == 0 && r == 0) {
183 close(fd);
184 return (0);
185 }
186
187 /* Go back to the beginning of the directive */
188 error = (int)lseek(fd, curpos, SEEK_SET);
189 if (error == (curpos - 1)) {
190 close(fd);
191 return (-1);
192 }
193
194 /* Allocate and read the directive into memory */
195 if (n > dsize) {
196 if ((directive = realloc(directive, n + 1)) == NULL) {
197 close(fd);
198 return (-1);
199 }
200 dsize = n;
201 }
202 r = read(fd, directive, n);
203
204 /* Advance beyond the equals sign if appropriate/desired */
205 if (bequals && *p == '=') {
206 if (lseek(fd, 1, SEEK_CUR) != -1)
207 r = read(fd, p, 1);
208 if (strict_equals && isspace(*p))
209 *p = '\n';
210 }
211
212 /* Terminate the string */
213 directive[n] = '\0';
214
215 /* Convert directive to lower case before comparison */
216 if (!case_sensitive)
217 strtolower(directive);
218
219 /* Move to what may be the start of the value */
220 if (!(bsemicolon && *p == ';') &&
221 !(strict_equals && *p == '=')) {
222 while (r != 0 && isspace(*p) && *p != '\n')
223 r = read(fd, p, 1);
224 }
225
226 /* An equals sign may have stopped us, should we eat it? */
227 if (r != 0 && bequals && *p == '=' && !strict_equals) {
228 have_equals = 1;
229 r = read(fd, p, 1);
230 while (r != 0 && isspace(*p) && *p != '\n')
231 r = read(fd, p, 1);
232 }
233
234 /* If no value, allocate a dummy value and jump to action */
235 if (r == 0 || *p == '\n' || *p == '#' ||
236 (bsemicolon && *p == ';')) {
237 /* Initialize the value if not already done */
238 if (value == NULL && (value = malloc(1)) == NULL) {
239 close(fd);
240 return (-1);
241 }
242 value[0] = '\0';
243 goto call_function;
244 }
245
246 /* Get the current offset */
247 curpos = lseek(fd, 0, SEEK_CUR) - 1;
248 if (curpos == -1) {
249 close(fd);
250 return (-1);
251 }
252
253 /* Find the end of the value */
254 quote = 0;
255 end = 0;
256 while (r != 0 && end == 0) {
257 /* Advance to the next character if we know we can */
258 if (*p != '\"' && *p != '#' && *p != '\n' &&
259 (!bsemicolon || *p != ';')) {
260 r = read(fd, p, 1);
261 continue;
262 }
263
264 /*
265 * If we get this far, we've hit an end-key
266 */
267
268 /* Get the current offset */
269 charpos = lseek(fd, 0, SEEK_CUR) - 1;
270 if (charpos == -1) {
271 close(fd);
272 return (-1);
273 }
274
275 /*
276 * Go back so we can read the character before the key
277 * to check if the character is escaped (which means we
278 * should continue).
279 */
280 error = (int)lseek(fd, -2, SEEK_CUR);
281 if (error == -3) {
282 close(fd);
283 return (-1);
284 }
285 r = read(fd, p, 1);
286
287 /*
288 * Count how many backslashes there are (an odd number
289 * means the key is escaped, even means otherwise).
290 */
291 for (n = 1; *p == '\\'; n++) {
292 /* Move back another offset to read */
293 error = (int)lseek(fd, -2, SEEK_CUR);
294 if (error == -3) {
295 close(fd);
296 return (-1);
297 }
298 r = read(fd, p, 1);
299 }
300
301 /* Move offset back to the key and read it */
302 error = (int)lseek(fd, charpos, SEEK_SET);
303 if (error == (charpos - 1)) {
304 close(fd);
305 return (-1);
306 }
307 r = read(fd, p, 1);
308
309 /*
310 * If an even number of backslashes was counted meaning
311 * key is not escaped, we should evaluate what to do.
312 */
313 if ((n & 1) == 1) {
314 switch (*p) {
315 case '\"':
316 /*
317 * Flag current sequence of characters
318 * to follow as being quoted (hashes
319 * are not considered comments).
320 */
321 quote = !quote;
322 break;
323 case '#':
324 /*
325 * If we aren't in a quoted series, we
326 * just hit an inline comment and have
327 * found the end of the value.
328 */
329 if (!quote)
330 end = 1;
331 break;
332 case '\n':
333 /*
334 * Newline characters must always be
335 * escaped, whether inside a quoted
336 * series or not, otherwise they
337 * terminate the value.
338 */
339 end = 1;
340 case ';':
341 if (!quote && bsemicolon)
342 end = 1;
343 break;
344 }
345 } else if (*p == '\n')
346 /* Escaped newline character. increment */
347 line++;
348
349 /* Advance to the next character */
350 r = read(fd, p, 1);
351 }
352
353 /* Get the current offset */
354 charpos = lseek(fd, 0, SEEK_CUR) - 1;
355 if (charpos == -1) {
356 close(fd);
357 return (-1);
358 }
359
360 /* Get the length of the value */
361 n = (uint32_t)(charpos - curpos);
362 if (r != 0) /* more to read, but don't read ending key */
363 n--;
364
365 /* Move offset back to the beginning of the value */
366 error = (int)lseek(fd, curpos, SEEK_SET);
367 if (error == (curpos - 1)) {
368 close(fd);
369 return (-1);
370 }
371
372 /* Allocate and read the value into memory */
373 if (n > vsize) {
374 if ((value = realloc(value, n + 1)) == NULL) {
375 close(fd);
376 return (-1);
377 }
378 vsize = n;
379 }
380 r = read(fd, value, n);
381
382 /* Terminate the string */
383 value[n] = '\0';
384
385 /* Cut trailing whitespace off by termination */
386 t = value + n;
387 while (isspace(*--t))
388 *t = '\0';
389
390 /* Escape the escaped quotes (replaceall is in string_m.c) */
391 x = strcount(value, "\\\""); /* in string_m.c */
392 if (x != 0 && (n + x) > vsize) {
393 if ((value = realloc(value, n + x + 1)) == NULL) {
394 close(fd);
395 return (-1);
396 }
397 vsize = n + x;
398 }
399 if (replaceall(value, "\\\"", "\\\\\"") < 0) {
400 /* Replace operation failed for some unknown reason */
401 close(fd);
402 return (-1);
403 }
404
405 /* Remove all new line characters */
406 if (replaceall(value, "\\\n", "") < 0) {
407 /* Replace operation failed for some unknown reason */
408 close(fd);
409 return (-1);
410 }
411
412 /* Resolve escape sequences */
413 strexpand(value); /* in string_m.c */
414
415 call_function:
416 /* Abort if we're seeking only assignments */
417 if (require_equals && !have_equals)
418 return (-1);
419
420 found = have_equals = 0; /* reset */
421
422 /* If there are no options defined, call unknown and loop */
423 if (options == NULL && unknown != NULL) {
424 error = unknown(NULL, line, directive, value);
425 if (error != 0) {
426 close(fd);
427 return (error);
428 }
429 continue;
430 }
431
432 /* Loop through the array looking for a match for the value */
433 for (n = 0; options[n].directive != NULL; n++) {
434 error = fnmatch(options[n].directive, directive,
435 FNM_NOESCAPE);
436 if (error == 0) {
437 found = 1;
438 /* Call function for array index item */
439 if (options[n].action != NULL) {
440 error = options[n].action(
441 &options[n],
442 line, directive, value);
443 if (error != 0) {
444 close(fd);
445 return (error);
446 }
447 }
448 } else if (error != FNM_NOMATCH) {
449 /* An error has occurred */
450 close(fd);
451 return (-1);
452 }
453 }
454 if (!found && unknown != NULL) {
455 /*
456 * No match was found for the value we read from the
457 * file; call function designated for unknown values.
458 */
459 error = unknown(NULL, line, directive, value);
460 if (error != 0) {
461 close(fd);
462 return (error);
463 }
464 }
465 }
466
467 close(fd);
468 return (0);
469 }
470