parse.c
Go to the documentation of this file.
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 
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 == '\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) {
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  ldns_fskipcs_l(f, del, line_nr);
165  *t = '\0';
166  if (p != 0) {
167  return -1;
168  }
169 
170  return (ssize_t)i;
171 }
172 
173 ssize_t
174 ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data,
175  const char *d_del, size_t data_limit)
176 {
177  return ldns_fget_keyword_data_l(f, keyword, k_del, data, d_del,
178  data_limit, NULL);
179 }
180 
181 ssize_t
182 ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data,
183  const char *d_del, size_t data_limit, int *line_nr)
184 {
185  /* we assume: keyword|sep|data */
186  char *fkeyword;
187  ssize_t i;
188 
189  if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN)
190  return -1;
191  fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
192  if(!fkeyword)
193  return -1;
194 
195  i = ldns_fget_token(f, fkeyword, k_del, LDNS_MAX_KEYWORDLEN);
196  if(i==0 || i==-1) {
197  LDNS_FREE(fkeyword);
198  return -1;
199  }
200 
201  /* case??? i instead of strlen? */
202  if (strncmp(fkeyword, keyword, LDNS_MAX_KEYWORDLEN - 1) == 0) {
203  /* whee! */
204  /* printf("%s\n%s\n", "Matching keyword", fkeyword); */
205  i = ldns_fget_token_l(f, data, d_del, data_limit, line_nr);
206  LDNS_FREE(fkeyword);
207  return i;
208  } else {
209  /*printf("no match for %s (read: %s)\n", keyword, fkeyword);*/
210  LDNS_FREE(fkeyword);
211  return -1;
212  }
213 }
214 
215 
216 ssize_t
217 ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit)
218 {
219  int c, lc;
220  int p; /* 0 -> no parenthese seen, >0 nr of ( seen */
221  int com, quoted;
222  char *t;
223  size_t i;
224  const char *d;
225  const char *del;
226 
227  /* standard delimiters */
228  if (!delim) {
229  /* from isspace(3) */
230  del = LDNS_PARSE_NORMAL;
231  } else {
232  del = delim;
233  }
234 
235  p = 0;
236  i = 0;
237  com = 0;
238  quoted = 0;
239  t = token;
240  lc = 0;
241  if (del[0] == '"') {
242  quoted = 1;
243  }
244 
245  while ((c = ldns_bgetc(b)) != EOF) {
246  if (c == '\r') /* carriage return */
247  c = ' ';
248  if (c == '(' && lc != '\\' && !quoted) {
249  /* this only counts for non-comments */
250  if (com == 0) {
251  p++;
252  }
253  lc = c;
254  continue;
255  }
256 
257  if (c == ')' && lc != '\\' && !quoted) {
258  /* this only counts for non-comments */
259  if (com == 0) {
260  p--;
261  }
262  lc = c;
263  continue;
264  }
265 
266  if (p < 0) {
267  /* more ) then ( */
268  *t = '\0';
269  return 0;
270  }
271 
272  /* do something with comments ; */
273  if (c == ';' && quoted == 0) {
274  if (lc != '\\') {
275  com = 1;
276  }
277  }
278  if (c == '"' && com == 0 && lc != '\\') {
279  quoted = 1 - quoted;
280  }
281 
282  if (c == '\n' && com != 0) {
283  /* comments */
284  com = 0;
285  *t = ' ';
286  lc = c;
287  continue;
288  }
289 
290  if (com == 1) {
291  *t = ' ';
292  lc = c;
293  continue;
294  }
295 
296  if (c == '\n' && p != 0) {
297  /* in parentheses */
298  *t++ = ' ';
299  lc = c;
300  continue;
301  }
302 
303  /* check if we hit the delim */
304  for (d = del; *d; d++) {
305  if (c == *d && lc != '\\' && p == 0) {
306  goto tokenread;
307  }
308  }
309 
310  i++;
311  if (limit > 0 && i >= limit) {
312  *t = '\0';
313  return -1;
314  }
315  *t++ = c;
316 
317  if (c == '\\' && lc == '\\') {
318  lc = 0;
319  } else {
320  lc = c;
321  }
322  }
323  *t = '\0';
324  if (i == 0) {
325  /* nothing read */
326  return -1;
327  }
328  if (p != 0) {
329  return -1;
330  }
331  return (ssize_t)i;
332 
333 tokenread:
334  ldns_bskipcs(b, del);
335  *t = '\0';
336 
337  if (p != 0) {
338  return -1;
339  }
340  return (ssize_t)i;
341 }
342 
343 void
344 ldns_bskipc(ldns_buffer *buffer, char c)
345 {
346  while (c == (char) ldns_buffer_read_u8_at(buffer, ldns_buffer_position(buffer))) {
347  if (ldns_buffer_available_at(buffer,
348  buffer->_position + sizeof(char), sizeof(char))) {
349  buffer->_position += sizeof(char);
350  } else {
351  return;
352  }
353  }
354 }
355 
356 void
357 ldns_bskipcs(ldns_buffer *buffer, const char *s)
358 {
359  bool found;
360  char c;
361  const char *d;
362 
363  while(ldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) {
364  c = (char) ldns_buffer_read_u8_at(buffer, buffer->_position);
365  found = false;
366  for (d = s; *d; d++) {
367  if (*d == c) {
368  found = true;
369  }
370  }
371  if (found && buffer->_limit > buffer->_position) {
372  buffer->_position += sizeof(char);
373  } else {
374  return;
375  }
376  }
377 }
378 
379 void
381 {
382 }
383 
384 
385 void
386 ldns_fskipcs(FILE *fp, const char *s)
387 {
388  ldns_fskipcs_l(fp, s, NULL);
389 }
390 
391 void
392 ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
393 {
394  bool found;
395  int c;
396  const char *d;
397 
398  while ((c = fgetc(fp)) != EOF) {
399  if (line_nr && c == '\n') {
400  *line_nr = *line_nr + 1;
401  }
402  found = false;
403  for (d = s; *d; d++) {
404  if (*d == c) {
405  found = true;
406  }
407  }
408  if (!found) {
409  /* with getc, we've read too far */
410  ungetc(c, fp);
411  return;
412  }
413  }
414 }
415 
416 ssize_t
417 ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, char
418 *data, const char *d_del, size_t data_limit)
419 {
420  /* we assume: keyword|sep|data */
421  char *fkeyword;
422  ssize_t i;
423 
424  if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN)
425  return -1;
426  fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
427  if(!fkeyword)
428  return -1; /* out of memory */
429 
430  i = ldns_bget_token(b, fkeyword, k_del, data_limit);
431  if(i==0 || i==-1) {
432  LDNS_FREE(fkeyword);
433  return -1; /* nothing read */
434  }
435 
436  /* case??? */
437  if (strncmp(fkeyword, keyword, strlen(keyword)) == 0) {
438  LDNS_FREE(fkeyword);
439  /* whee, the match! */
440  /* retrieve it's data */
441  i = ldns_bget_token(b, data, d_del, 0);
442  return i;
443  } else {
444  LDNS_FREE(fkeyword);
445  return -1;
446  }
447 }
448