xref: /dragonfly/contrib/ldns/parse.c (revision bcb3e04d) 
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 <ldns/config.h>
11 #include <ldns/ldns.h>
12 
13 #include <limits.h>
14 #include <strings.h>
15 
16 ldns_lookup_table ldns_directive_types[] = {
17         { LDNS_DIR_TTL, "$TTL" },
18         { LDNS_DIR_ORIGIN, "$ORIGIN" },
19         { LDNS_DIR_INCLUDE, "$INCLUDE" },
20         { 0, NULL }
21 };
22 
23 /* add max_limit here? */
24 ssize_t
25 ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit)
26 {
27 	return ldns_fget_token_l(f, token, delim, limit, NULL);
28 }
29 
30 ssize_t
31 ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
32 {
33 	int c, prev_c;
34 	int p; /* 0 -> no parenthese seen, >0 nr of ( seen */
35 	int com, quoted;
36 	char *t;
37 	size_t i;
38 	const char *d;
39 	const char *del;
40 
41 	/* standard delimeters */
42 	if (!delim) {
43 		/* from isspace(3) */
44 		del = LDNS_PARSE_NORMAL;
45 	} else {
46 		del = delim;
47 	}
48 
49 	p = 0;
50 	i = 0;
51 	com = 0;
52 	quoted = 0;
53 	prev_c = 0;
54 	t = token;
55 	if (del[0] == '"') {
56 		quoted = 1;
57 	}
58 	while ((c = getc(f)) != EOF) {
59 		if (c == '(' && prev_c != '\\' && !quoted) {
60 			/* this only counts for non-comments */
61 			if (com == 0) {
62 				p++;
63 			}
64 			prev_c = c;
65 			continue;
66 		}
67 
68 		if (c == ')' && prev_c != '\\' && !quoted) {
69 			/* this only counts for non-comments */
70 			if (com == 0) {
71 				p--;
72 			}
73 			prev_c = c;
74 			continue;
75 		}
76 
77 		if (p < 0) {
78 			/* more ) then ( - close off the string */
79 			*t = '\0';
80 			return 0;
81 		}
82 
83 		/* do something with comments ; */
84 		if (c == ';' && quoted == 0) {
85 			if (prev_c != '\\') {
86 				com = 1;
87 			}
88 		}
89 		if (c == '\"' && com == 0 && prev_c != '\\') {
90 			quoted = 1 - quoted;
91 		}
92 
93 		if (c == '\n' && com != 0) {
94 			/* comments */
95 			com = 0;
96 			*t = ' ';
97 			if (line_nr) {
98 				*line_nr = *line_nr + 1;
99 			}
100 			if (p == 0 && i > 0) {
101 				goto tokenread;
102 			} else {
103 				prev_c = c;
104 				continue;
105 			}
106 		}
107 
108 		if (com == 1) {
109 			*t = ' ';
110 			prev_c = c;
111 			continue;
112 		}
113 
114 
115 		if (c == '\n' && p != 0 && t > token) {
116 			/* in parentheses */
117 			if (line_nr) {
118 				*line_nr = *line_nr + 1;
119 			}
120 			prev_c = c;
121 			continue;
122 		}
123 
124 		/* check if we hit the delim */
125 		for (d = del; *d; d++) {
126 			if (c == *d && i > 0 && prev_c != '\\') {
127 				if (c == '\n' && line_nr) {
128 					*line_nr = *line_nr + 1;
129 				}
130 				goto tokenread;
131 			}
132 		}
133 		if (c != '\0' && c != '\n') {
134 			*t++ = c;
135 			i++;
136 		}
137 		if (limit > 0 && i >= limit) {
138 			*t = '\0';
139 			return -1;
140 		}
141 		if (c == '\\' && prev_c == '\\')
142 			prev_c = 0;
143 		else	prev_c = c;
144 	}
145 	*t = '\0';
146 	if (c == EOF) {
147 		return (ssize_t)i;
148 	}
149 
150 	if (i == 0) {
151 		/* nothing read */
152 		return -1;
153 	}
154 	if (p != 0) {
155 		return -1;
156 	}
157 	return (ssize_t)i;
158 
159 tokenread:
160 	ldns_fskipcs_l(f, delim, line_nr);
161 	*t = '\0';
162 	if (p != 0) {
163 		return -1;
164 	}
165 
166 	return (ssize_t)i;
167 }
168 
169 ssize_t
170 ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data,
171                const char *d_del, size_t data_limit)
172 {
173        return ldns_fget_keyword_data_l(f, keyword, k_del, data, d_del,
174 		       data_limit, NULL);
175 }
176 
177 ssize_t
178 ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data,
179                const char *d_del, size_t data_limit, int *line_nr)
180 {
181        /* we assume: keyword|sep|data */
182        char *fkeyword;
183        ssize_t i;
184 
185        fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
186        i = 0;
187 
188        i = ldns_fget_token(f, fkeyword, k_del, LDNS_MAX_KEYWORDLEN);
189 
190        /* case??? i instead of strlen? */
191        if (strncmp(fkeyword, keyword, LDNS_MAX_KEYWORDLEN - 1) == 0) {
192                /* whee! */
193                /* printf("%s\n%s\n", "Matching keyword", fkeyword); */
194                i = ldns_fget_token_l(f, data, d_del, data_limit, line_nr);
195                LDNS_FREE(fkeyword);
196                return i;
197        } else {
198                /*printf("no match for %s (read: %s)\n", keyword, fkeyword);*/
199                LDNS_FREE(fkeyword);
200                return -1;
201        }
202 }
203 
204 
205 ssize_t
206 ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit)
207 {
208 	int c, lc;
209 	int p; /* 0 -> no parenthese seen, >0 nr of ( seen */
210 	int com, quoted;
211 	char *t;
212 	size_t i;
213 	const char *d;
214 	const char *del;
215 
216 	/* standard delimiters */
217 	if (!delim) {
218 		/* from isspace(3) */
219 		del = LDNS_PARSE_NORMAL;
220 	} else {
221 		del = delim;
222 	}
223 
224 	p = 0;
225 	i = 0;
226 	com = 0;
227 	quoted = 0;
228 	t = token;
229 	lc = 0;
230 	if (delim[0] == '"') {
231 		quoted = 1;
232 	}
233 
234 	while ((c = ldns_bgetc(b)) != EOF) {
235 		if (c == '(' && lc != '\\' && !quoted) {
236 			/* this only counts for non-comments */
237 			if (com == 0) {
238 				p++;
239 			}
240 			lc = c;
241 			continue;
242 		}
243 
244 		if (c == ')' && lc != '\\' && !quoted) {
245 			/* this only counts for non-comments */
246 			if (com == 0) {
247 				p--;
248 			}
249 			lc = c;
250 			continue;
251 		}
252 
253 		if (p < 0) {
254 			/* more ) then ( */
255 			*t = '\0';
256 			lc = c;
257 			return 0;
258 		}
259 
260 		/* do something with comments ; */
261 		if (c == ';' && quoted == 0) {
262 			if (lc != '\\') {
263 				com = 1;
264 			}
265 		}
266 		if (c == '"' && com == 0 && lc != '\\') {
267 			quoted = 1 - quoted;
268 		}
269 
270 		if (c == '\n' && com != 0) {
271 			/* comments */
272 			com = 0;
273 			*t = ' ';
274 			lc = c;
275 			continue;
276 		}
277 
278 		if (com == 1) {
279 			*t = ' ';
280 			lc = c;
281 			continue;
282 		}
283 
284 		if (c == '\n' && p != 0) {
285 			/* in parentheses */
286 			lc = c;
287 			continue;
288 		}
289 
290 		/* check if we hit the delim */
291 		for (d = del; *d; d++) {
292                         if (c == *d && lc != '\\') {
293 				goto tokenread;
294                         }
295 		}
296 
297 		*t++ = c;
298 		i++;
299 		if (limit > 0 && i >= limit - 1) {
300 			*t = '\0';
301 			return -1;
302 		}
303 
304 		if (c == '\\' && lc == '\\') {
305 			lc = 0;
306 		} else {
307 			lc = c;
308 		}
309 	}
310 	*t = '\0';
311 	if (i == 0) {
312 		/* nothing read */
313 		return -1;
314 	}
315 	if (p != 0) {
316 		return -1;
317 	}
318 	return (ssize_t)i;
319 
320 tokenread:
321 	ldns_bskipcs(b, delim);
322 	*t = '\0';
323 
324 	if (p != 0) {
325 		return -1;
326 	}
327 	return (ssize_t)i;
328 }
329 
330 void
331 ldns_bskipc(ldns_buffer *buffer, char c)
332 {
333         while (c == (char) ldns_buffer_read_u8_at(buffer, ldns_buffer_position(buffer))) {
334                 if (ldns_buffer_available_at(buffer,
335 					buffer->_position + sizeof(char), sizeof(char))) {
336                         buffer->_position += sizeof(char);
337                 } else {
338                         return;
339                 }
340         }
341 }
342 
343 void
344 ldns_bskipcs(ldns_buffer *buffer, const char *s)
345 {
346         bool found;
347         char c;
348         const char *d;
349 
350         while(ldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) {
351                 c = (char) ldns_buffer_read_u8_at(buffer, buffer->_position);
352                 found = false;
353                 for (d = s; *d; d++) {
354                         if (*d == c) {
355                                 found = true;
356                         }
357                 }
358                 if (found && buffer->_limit > buffer->_position) {
359                         buffer->_position += sizeof(char);
360                 } else {
361                         return;
362                 }
363         }
364 }
365 
366 void
367 ldns_fskipc(FILE *fp, char c)
368 {
369 	fp = fp;
370 	c = c;
371 }
372 
373 
374 void
375 ldns_fskipcs(FILE *fp, const char *s)
376 {
377 	ldns_fskipcs_l(fp, s, NULL);
378 }
379 
380 void
381 ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
382 {
383         bool found;
384         int c;
385         const char *d;
386 
387 	while ((c = fgetc(fp)) != EOF) {
388 		if (line_nr && c == '\n') {
389 			*line_nr = *line_nr + 1;
390 		}
391                 found = false;
392                 for (d = s; *d; d++) {
393                         if (*d == c) {
394                                 found = true;
395                         }
396                 }
397 		if (!found) {
398 			/* with getc, we've read too far */
399 			ungetc(c, fp);
400 			return;
401 		}
402 	}
403 }
404 
405 ssize_t
406 ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, char
407 *data, const char *d_del, size_t data_limit)
408 {
409        /* we assume: keyword|sep|data */
410        char *fkeyword;
411        ssize_t i;
412 
413        fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
414        i = 0;
415 
416        i = ldns_bget_token(b, fkeyword, k_del, data_limit);
417 
418        /* case??? */
419        if (strncmp(fkeyword, keyword, strlen(keyword)) == 0) {
420                /* whee, the match! */
421                /* retrieve it's data */
422                i = ldns_bget_token(b, data, d_del, 0);
423                return i;
424        } else {
425                return -1;
426        }
427 }
428 
429