1/*
2 * a generic (simple) parser. Use to parse rr's, private key
3 * information and /etc/resolv.conf files
4 *
5 * a Net::DNS like library for C
6 * LibDNS Team @ NLnet Labs
7 * (c) NLnet Labs, 2005-2006
8 * See the file LICENSE for the license
9 */
10#include "config.h"
11#include "sldns/parse.h"
12#include "sldns/parseutil.h"
13#include "sldns/sbuffer.h"
14
15#include <limits.h>
16#include <strings.h>
17
18sldns_lookup_table sldns_directive_types[] = {
19        { LDNS_DIR_TTL, "$TTL" },
20        { LDNS_DIR_ORIGIN, "$ORIGIN" },
21        { LDNS_DIR_INCLUDE, "$INCLUDE" },
22        { 0, NULL }
23};
24
25/* add max_limit here? */
26ssize_t
27sldns_fget_token(FILE *f, char *token, const char *delim, size_t limit)
28{
29	return sldns_fget_token_l(f, token, delim, limit, NULL);
30}
31
32ssize_t
33sldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
34{
35	int c, prev_c;
36	int p; /* 0 -> no parentheses seen, >0 nr of ( seen */
37	int com, quoted;
38	char *t;
39	size_t i;
40	const char *d;
41	const char *del;
42
43	/* standard delimiters */
44	if (!delim) {
45		/* from isspace(3) */
46		del = LDNS_PARSE_NORMAL;
47	} else {
48		del = delim;
49	}
50
51	p = 0;
52	i = 0;
53	com = 0;
54	quoted = 0;
55	prev_c = 0;
56	t = token;
57	if (del[0] == '"') {
58		quoted = 1;
59	}
60	while ((c = getc(f)) != EOF) {
61		if (c == '\r') /* carriage return */
62			c = ' ';
63		if (c == '(' && prev_c != '\\' && !quoted) {
64			/* this only counts for non-comments */
65			if (com == 0) {
66				p++;
67			}
68			prev_c = c;
69			continue;
70		}
71
72		if (c == ')' && prev_c != '\\' && !quoted) {
73			/* this only counts for non-comments */
74			if (com == 0) {
75				p--;
76			}
77			prev_c = c;
78			continue;
79		}
80
81		if (p < 0) {
82			/* more ) then ( - close off the string */
83			*t = '\0';
84			return 0;
85		}
86
87		/* do something with comments ; */
88		if (c == ';' && quoted == 0) {
89			if (prev_c != '\\') {
90				com = 1;
91			}
92		}
93		if (c == '\"' && com == 0 && prev_c != '\\') {
94			quoted = 1 - quoted;
95		}
96
97		if (c == '\n' && com != 0) {
98			/* comments */
99			com = 0;
100			*t = ' ';
101			if (line_nr) {
102				*line_nr = *line_nr + 1;
103			}
104			if (p == 0 && i > 0) {
105				goto tokenread;
106			} else {
107				prev_c = c;
108				continue;
109			}
110		}
111
112		if (com == 1) {
113			*t = ' ';
114			prev_c = c;
115			continue;
116		}
117
118		if (c == '\n' && p != 0 && t > token) {
119			/* in parentheses */
120			if (line_nr) {
121				*line_nr = *line_nr + 1;
122			}
123			if (limit > 0 && (i+1 >= limit || (size_t)(t-token)+1 >= limit)) {
124				*t = '\0';
125				return -1;
126			}
127			*t++ = ' ';
128			prev_c = c;
129			continue;
130		}
131
132		/* check if we hit the delim */
133		for (d = del; *d; d++) {
134			if (c == *d && i > 0 && prev_c != '\\' && p == 0) {
135				if (c == '\n' && line_nr) {
136					*line_nr = *line_nr + 1;
137				}
138				goto tokenread;
139			}
140		}
141		if (c != '\0' && c != '\n') {
142			i++;
143		}
144		/* is there space for the character and the zero after it */
145		if (limit > 0 && (i+1 >= limit || (size_t)(t-token)+1 >= limit)) {
146			*t = '\0';
147			return -1;
148		}
149		if (c != '\0' && c != '\n') {
150			*t++ = c;
151		}
152		if (c == '\\' && prev_c == '\\')
153			prev_c = 0;
154		else	prev_c = c;
155	}
156	*t = '\0';
157	if (c == EOF) {
158		return (ssize_t)i;
159	}
160
161	if (i == 0) {
162		/* nothing read */
163		return -1;
164	}
165	if (p != 0) {
166		return -1;
167	}
168	return (ssize_t)i;
169
170tokenread:
171	if(*del == '"')
172		/* do not skip over quotes after the string, they are part
173		 * of the next string.  But skip over whitespace (if needed)*/
174		sldns_fskipcs_l(f, del+1, line_nr);
175	else	sldns_fskipcs_l(f, del, line_nr);
176	*t = '\0';
177	if (p != 0) {
178		return -1;
179	}
180
181	return (ssize_t)i;
182}
183
184ssize_t
185sldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data,
186               const char *d_del, size_t data_limit)
187{
188       return sldns_fget_keyword_data_l(f, keyword, k_del, data, d_del,
189		       data_limit, NULL);
190}
191
192ssize_t
193sldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data,
194               const char *d_del, size_t data_limit, int *line_nr)
195{
196       /* we assume: keyword|sep|data */
197       char *fkeyword;
198       ssize_t i;
199
200       if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN)
201               return -1;
202       fkeyword = (char*)malloc(LDNS_MAX_KEYWORDLEN);
203       if(!fkeyword)
204               return -1;
205
206       i = sldns_fget_token(f, fkeyword, k_del, LDNS_MAX_KEYWORDLEN);
207       if(i==0 || i==-1) {
208               free(fkeyword);
209               return -1;
210       }
211
212       /* case??? i instead of strlen? */
213       if (strncmp(fkeyword, keyword, LDNS_MAX_KEYWORDLEN - 1) == 0) {
214               /* whee! */
215               /* printf("%s\n%s\n", "Matching keyword", fkeyword); */
216               i = sldns_fget_token_l(f, data, d_del, data_limit, line_nr);
217               free(fkeyword);
218               return i;
219       } else {
220               /*printf("no match for %s (read: %s)\n", keyword, fkeyword);*/
221               free(fkeyword);
222               return -1;
223       }
224}
225
226int
227sldns_bgetc(sldns_buffer *buffer)
228{
229	if (!sldns_buffer_available_at(buffer, buffer->_position, sizeof(uint8_t))) {
230		sldns_buffer_set_position(buffer, sldns_buffer_limit(buffer));
231		/* sldns_buffer_rewind(buffer);*/
232		return EOF;
233	}
234	return (int)sldns_buffer_read_u8(buffer);
235}
236
237ssize_t
238sldns_bget_token(sldns_buffer *b, char *token, const char *delim, size_t limit)
239{
240	return sldns_bget_token_par(b, token, delim, limit, NULL, NULL);
241}
242
243ssize_t
244sldns_bget_token_par(sldns_buffer *b, char *token, const char *delim,
245	size_t limit, int* par, const char* skipw)
246{
247	int c, lc;
248	int p; /* 0 -> no parentheses seen, >0 nr of ( seen */
249	int com, quoted;
250	char *t;
251	size_t i;
252	const char *d;
253	const char *del;
254
255	/* standard delimiters */
256	if (!delim) {
257		/* from isspace(3) */
258		del = LDNS_PARSE_NORMAL;
259	} else {
260		del = delim;
261	}
262
263	p = (par?*par:0);
264	i = 0;
265	com = 0;
266	quoted = 0;
267	t = token;
268	lc = 0;
269	if (del[0] == '"') {
270		quoted = 1;
271	}
272
273	while ((c = sldns_bgetc(b)) != EOF) {
274		if (c == '\r') /* carriage return */
275			c = ' ';
276		if (c == '(' && lc != '\\' && !quoted) {
277			/* this only counts for non-comments */
278			if (com == 0) {
279				if(par) (*par)++;
280				p++;
281			}
282			lc = c;
283			continue;
284		}
285
286		if (c == ')' && lc != '\\' && !quoted) {
287			/* this only counts for non-comments */
288			if (com == 0) {
289				if(par) (*par)--;
290				p--;
291			}
292			lc = c;
293			continue;
294		}
295
296		if (p < 0) {
297			/* more ) then ( */
298			*t = '\0';
299			return 0;
300		}
301
302		/* do something with comments ; */
303		if (c == ';' && quoted == 0) {
304			if (lc != '\\') {
305				com = 1;
306			}
307		}
308		if (c == '"' && com == 0 && lc != '\\') {
309			quoted = 1 - quoted;
310		}
311
312		if (c == '\n' && com != 0) {
313			/* comments */
314			com = 0;
315			*t = ' ';
316			lc = c;
317			continue;
318		}
319
320		if (com == 1) {
321			*t = ' ';
322			lc = c;
323			continue;
324		}
325
326		if (c == '\n' && p != 0) {
327			/* in parentheses */
328			/* do not write ' ' if we want to skip spaces */
329			if(!(skipw && (strchr(skipw, c)||strchr(skipw, ' ')))) {
330				/* check for space for the space character and a zero delimiter after that. */
331				if (limit > 0 && (i+1 >= limit || (size_t)(t-token)+1 >= limit)) {
332					*t = '\0';
333					return -1;
334				}
335				*t++ = ' ';
336			}
337			lc = c;
338			continue;
339		}
340
341		/* check to skip whitespace at start, but also after ( */
342		if(skipw && i==0 && !com && !quoted && lc != '\\') {
343			if(strchr(skipw, c)) {
344				lc = c;
345				continue;
346			}
347		}
348
349		/* check if we hit the delim */
350		for (d = del; *d; d++) {
351			/* we can only exit if no parens or user tracks them */
352                        if (c == *d && lc != '\\' && (p == 0 || par)) {
353				goto tokenread;
354                        }
355		}
356
357		i++;
358		if (limit > 0 && (i+1 >= limit || (size_t)(t-token)+1 >= limit)) {
359			*t = '\0';
360			return -1;
361		}
362		*t++ = c;
363
364		if (c == '\\' && lc == '\\') {
365			lc = 0;
366		} else {
367			lc = c;
368		}
369	}
370	*t = '\0';
371	if (i == 0) {
372		/* nothing read */
373		return -1;
374	}
375	if (!par && p != 0) {
376		return -1;
377	}
378	return (ssize_t)i;
379
380tokenread:
381	if(*del == '"')
382		/* do not skip over quotes after the string, they are part
383		 * of the next string.  But skip over whitespace (if needed)*/
384		sldns_bskipcs(b, del+1);
385	else 	sldns_bskipcs(b, del);
386	*t = '\0';
387
388	if (!par && p != 0) {
389		return -1;
390	}
391	return (ssize_t)i;
392}
393
394
395void
396sldns_bskipcs(sldns_buffer *buffer, const char *s)
397{
398        int found;
399        char c;
400        const char *d;
401
402        while(sldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) {
403                c = (char) sldns_buffer_read_u8_at(buffer, buffer->_position);
404                found = 0;
405                for (d = s; *d; d++) {
406                        if (*d == c) {
407                                found = 1;
408                        }
409                }
410                if (found && buffer->_limit > buffer->_position) {
411                        buffer->_position += sizeof(char);
412                } else {
413                        return;
414                }
415        }
416}
417
418void
419sldns_fskipcs(FILE *fp, const char *s)
420{
421	sldns_fskipcs_l(fp, s, NULL);
422}
423
424void
425sldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
426{
427        int found;
428        int c;
429        const char *d;
430
431	while ((c = fgetc(fp)) != EOF) {
432		if (line_nr && c == '\n') {
433			*line_nr = *line_nr + 1;
434		}
435                found = 0;
436                for (d = s; *d; d++) {
437                        if (*d == c) {
438                                found = 1;
439                        }
440                }
441		if (!found) {
442			/* with getc, we've read too far */
443			ungetc(c, fp);
444			return;
445		}
446	}
447}
448
449ssize_t
450sldns_bget_keyword_data(sldns_buffer *b, const char *keyword, const char *k_del, char
451*data, const char *d_del, size_t data_limit)
452{
453       /* we assume: keyword|sep|data */
454       char *fkeyword;
455       ssize_t i;
456
457       if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN)
458               return -1;
459       fkeyword = (char*)malloc(LDNS_MAX_KEYWORDLEN);
460       if(!fkeyword)
461               return -1; /* out of memory */
462
463       i = sldns_bget_token(b, fkeyword, k_del, data_limit);
464       if(i==0 || i==-1) {
465               free(fkeyword);
466               return -1; /* nothing read */
467       }
468
469       /* case??? */
470       if (strncmp(fkeyword, keyword, strlen(keyword)) == 0) {
471               free(fkeyword);
472               /* whee, the match! */
473               /* retrieve it's data */
474               i = sldns_bget_token(b, data, d_del, 0);
475               return i;
476       } else {
477               free(fkeyword);
478               return -1;
479       }
480}
481
482