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