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 
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 ldns_status
31 ldns_fget_token_l_st(FILE *f, char **token, size_t *limit, bool fixed
32  , const char *delim, int *line_nr)
33 {
34  int c, prev_c;
35  int p; /* 0 -> no parentheses seen, >0 nr of ( seen */
36  int com, quoted;
37  char *t, *old_token;
38  size_t i;
39  const char *d;
40  const char *del;
41 
42  /* standard delimiters */
43  if (!delim) {
44  /* from isspace(3) */
45  del = LDNS_PARSE_NORMAL;
46  } else {
47  del = delim;
48  }
49  if (!token || !limit)
50  return LDNS_STATUS_NULL;
51 
52  if (fixed) {
53  if (*token == NULL || *limit == 0)
54  return LDNS_STATUS_NULL;
55 
56  } else if (*token == NULL) {
57  *limit = LDNS_MAX_LINELEN;
58  if (!(*token = LDNS_XMALLOC(char, *limit + 1)))
59  return LDNS_STATUS_MEM_ERR;
60 
61  } else if (*limit == 0)
62  return LDNS_STATUS_ERR;
63  p = 0;
64  i = 0;
65  com = 0;
66  quoted = 0;
67  prev_c = 0;
68  t = *token;
69  if (del[0] == '"') {
70  quoted = 1;
71  }
72  while ((c = getc(f)) != EOF) {
73  if (c == '\r') /* carriage return */
74  c = ' ';
75  if (c == '(' && prev_c != '\\' && !quoted) {
76  /* this only counts for non-comments */
77  if (com == 0) {
78  p++;
79  }
80  prev_c = c;
81  continue;
82  }
83 
84  if (c == ')' && prev_c != '\\' && !quoted) {
85  /* this only counts for non-comments */
86  if (com == 0) {
87  p--;
88  }
89  prev_c = c;
90  continue;
91  }
92 
93  if (p < 0) {
94  /* more ) then ( - close off the string */
95  *t = '\0';
96  return i == 0 ? LDNS_STATUS_SYNTAX_EMPTY
97  : LDNS_STATUS_OK;
98  }
99 
100  /* do something with comments ; */
101  if (c == ';' && quoted == 0) {
102  if (prev_c != '\\') {
103  com = 1;
104  }
105  }
106  if (c == '\"' && com == 0 && prev_c != '\\') {
107  quoted = 1 - quoted;
108  }
109 
110  if (c == '\n' && com != 0) {
111  /* comments */
112  com = 0;
113  *t = ' ';
114  if (line_nr) {
115  *line_nr = *line_nr + 1;
116  }
117  if (p == 0 && i > 0) {
118  goto tokenread;
119  } else {
120  prev_c = c;
121  continue;
122  }
123  }
124 
125  if (com == 1) {
126  *t = ' ';
127  prev_c = c;
128  continue;
129  }
130 
131  if (c == '\n' && p != 0 && t > *token) {
132  /* in parentheses */
133  if (line_nr) {
134  *line_nr = *line_nr + 1;
135  }
136  if (*limit > 0
137  && (i >= *limit || (size_t)(t - *token) >= *limit)) {
138  if (fixed) {
139  *t = '\0';
140  return LDNS_STATUS_SYNTAX_ERR;
141  }
142  old_token = *token;
143  *limit *= 2;
144  *token = LDNS_XREALLOC(*token, char, *limit + 1);
145  if (*token == NULL) {
146  *token = old_token;
147  *t = '\0';
148  return LDNS_STATUS_MEM_ERR;
149  }
150  if (*token != old_token)
151  t = *token + (t - old_token);
152  }
153  *t++ = ' ';
154  prev_c = c;
155  continue;
156  }
157 
158  /* check if we hit the delim */
159  for (d = del; *d; d++) {
160  if (c == *d && i > 0 && prev_c != '\\' && p == 0) {
161  if (c == '\n' && line_nr) {
162  *line_nr = *line_nr + 1;
163  }
164  goto tokenread;
165  }
166  }
167  if (c != '\0' && c != '\n') {
168  i++;
169  }
170  if (*limit > 0
171  && (i >= *limit || (size_t)(t - *token) >= *limit)) {
172  if (fixed) {
173  *t = '\0';
174  return LDNS_STATUS_SYNTAX_ERR;
175  }
176  old_token = *token;
177  *limit *= 2;
178  *token = LDNS_XREALLOC(*token, char, *limit + 1);
179  if (*token == NULL) {
180  *token = old_token;
181  *t = '\0';
182  return LDNS_STATUS_MEM_ERR;
183  }
184  if (*token != old_token)
185  t = *token + (t - old_token);
186  }
187  if (c != '\0' && c != '\n') {
188  *t++ = c;
189  }
190  if (c == '\n' && line_nr) {
191  *line_nr = *line_nr + 1;
192  }
193  if (c == '\\' && prev_c == '\\')
194  prev_c = 0;
195  else prev_c = c;
196  }
197  *t = '\0';
198  if (c == EOF) {
199  return i == 0 ? LDNS_STATUS_SYNTAX_EMPTY : LDNS_STATUS_OK;
200  }
201 
202  if (p != 0) {
203  return LDNS_STATUS_SYNTAX_ERR;
204  }
205  return i == 0 ? LDNS_STATUS_SYNTAX_EMPTY : LDNS_STATUS_OK;
206 
207 tokenread:
208  if(*del == '"') /* do not skip over quotes, they are significant */
209  ldns_fskipcs_l(f, del+1, line_nr);
210  else ldns_fskipcs_l(f, del, line_nr);
211  *t = '\0';
212  if (p != 0) {
213  return LDNS_STATUS_SYNTAX_ERR;
214  }
215  return i == 0 ? LDNS_STATUS_SYNTAX_EMPTY : LDNS_STATUS_OK;
216 }
217 
218 
219 ssize_t
220 ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
221 {
222  if (limit == 0)
223  limit = LDNS_MAX_LINELEN;
224  if (ldns_fget_token_l_st(f, &token, &limit, true, delim, line_nr))
225  return -1;
226  else
227  return (ssize_t)strlen(token);
228 }
229 
230 ssize_t
231 ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data,
232  const char *d_del, size_t data_limit)
233 {
234  return ldns_fget_keyword_data_l(f, keyword, k_del, data, d_del,
235  data_limit, NULL);
236 }
237 
238 ssize_t
239 ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data,
240  const char *d_del, size_t data_limit, int *line_nr)
241 {
242  /* we assume: keyword|sep|data */
243  char *fkeyword;
244  ssize_t i;
245 
246  if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN)
247  return -1;
248  fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
249  if(!fkeyword)
250  return -1;
251 
252  i = ldns_fget_token(f, fkeyword, k_del, LDNS_MAX_KEYWORDLEN);
253  if(i==0 || i==-1) {
254  LDNS_FREE(fkeyword);
255  return -1;
256  }
257 
258  /* case??? i instead of strlen? */
259  if (strncmp(fkeyword, keyword, LDNS_MAX_KEYWORDLEN - 1) == 0) {
260  /* whee! */
261  /* printf("%s\n%s\n", "Matching keyword", fkeyword); */
262  i = ldns_fget_token_l(f, data, d_del, data_limit, line_nr);
263  LDNS_FREE(fkeyword);
264  return i;
265  } else {
266  /*printf("no match for %s (read: %s)\n", keyword, fkeyword);*/
267  LDNS_FREE(fkeyword);
268  return -1;
269  }
270 }
271 
272 
273 ssize_t
274 ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit)
275 {
276  int c, lc;
277  int p; /* 0 -> no parentheses seen, >0 nr of ( seen */
278  int com, quoted;
279  char *t;
280  size_t i;
281  const char *d;
282  const char *del;
283 
284  /* standard delimiters */
285  if (!delim) {
286  /* from isspace(3) */
287  del = LDNS_PARSE_NORMAL;
288  } else {
289  del = delim;
290  }
291 
292  p = 0;
293  i = 0;
294  com = 0;
295  quoted = 0;
296  t = token;
297  lc = 0;
298  if (del[0] == '"') {
299  quoted = 1;
300  }
301 
302  while ((c = ldns_bgetc(b)) != EOF) {
303  if (c == '\r') /* carriage return */
304  c = ' ';
305  if (c == '(' && lc != '\\' && !quoted) {
306  /* this only counts for non-comments */
307  if (com == 0) {
308  p++;
309  }
310  lc = c;
311  continue;
312  }
313 
314  if (c == ')' && lc != '\\' && !quoted) {
315  /* this only counts for non-comments */
316  if (com == 0) {
317  p--;
318  }
319  lc = c;
320  continue;
321  }
322 
323  if (p < 0) {
324  /* more ) then ( */
325  *t = '\0';
326  return 0;
327  }
328 
329  /* do something with comments ; */
330  if (c == ';' && quoted == 0) {
331  if (lc != '\\') {
332  com = 1;
333  }
334  }
335  if (c == '"' && com == 0 && lc != '\\') {
336  quoted = 1 - quoted;
337  }
338 
339  if (c == '\n' && com != 0) {
340  /* comments */
341  com = 0;
342  *t = ' ';
343  lc = c;
344  continue;
345  }
346 
347  if (com == 1) {
348  *t = ' ';
349  lc = c;
350  continue;
351  }
352 
353  if (c == '\n' && p != 0) {
354  /* in parentheses */
355  *t++ = ' ';
356  lc = c;
357  continue;
358  }
359 
360  /* check if we hit the delim */
361  for (d = del; *d; d++) {
362  if (c == *d && lc != '\\' && p == 0) {
363  goto tokenread;
364  }
365  }
366 
367  i++;
368  if (limit > 0 && (i >= limit || (size_t)(t-token) >= limit)) {
369  *t = '\0';
370  return -1;
371  }
372  *t++ = c;
373 
374  if (c == '\\' && lc == '\\') {
375  lc = 0;
376  } else {
377  lc = c;
378  }
379  }
380  *t = '\0';
381  if (i == 0) {
382  /* nothing read */
383  return -1;
384  }
385  if (p != 0) {
386  return -1;
387  }
388  return (ssize_t)i;
389 
390 tokenread:
391  if(*del == '"') /* do not skip over quotes, they are significant */
392  ldns_bskipcs(b, del+1);
393  else ldns_bskipcs(b, del);
394  *t = '\0';
395 
396  if (p != 0) {
397  return -1;
398  }
399  return (ssize_t)i;
400 }
401 
402 
403 void
404 ldns_bskipcs(ldns_buffer *buffer, const char *s)
405 {
406  bool found;
407  char c;
408  const char *d;
409 
410  while(ldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) {
411  c = (char) ldns_buffer_read_u8_at(buffer, buffer->_position);
412  found = false;
413  for (d = s; *d; d++) {
414  if (*d == c) {
415  found = true;
416  }
417  }
418  if (found && buffer->_limit > buffer->_position) {
419  buffer->_position += sizeof(char);
420  } else {
421  return;
422  }
423  }
424 }
425 
426 void
427 ldns_fskipcs(FILE *fp, const char *s)
428 {
429  ldns_fskipcs_l(fp, s, NULL);
430 }
431 
432 void
433 ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
434 {
435  bool found;
436  int c;
437  const char *d;
438 
439  while ((c = fgetc(fp)) != EOF) {
440  if (line_nr && c == '\n') {
441  *line_nr = *line_nr + 1;
442  }
443  found = false;
444  for (d = s; *d; d++) {
445  if (*d == c) {
446  found = true;
447  }
448  }
449  if (!found) {
450  /* with getc, we've read too far */
451  ungetc(c, fp);
452  return;
453  }
454  }
455 }
456 
457 ssize_t
458 ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, char
459 *data, const char *d_del, size_t data_limit)
460 {
461  /* we assume: keyword|sep|data */
462  char *fkeyword;
463  ssize_t i;
464 
465  if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN)
466  return -1;
467  fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
468  if(!fkeyword)
469  return -1; /* out of memory */
470 
471  i = ldns_bget_token(b, fkeyword, k_del, data_limit);
472  if(i==0 || i==-1) {
473  LDNS_FREE(fkeyword);
474  return -1; /* nothing read */
475  }
476 
477  /* case??? */
478  if (strncmp(fkeyword, keyword, strlen(keyword)) == 0) {
479  LDNS_FREE(fkeyword);
480  /* whee, the match! */
481  /* retrieve it's data */
482  i = ldns_bget_token(b, data, d_del, 0);
483  return i;
484  } else {
485  LDNS_FREE(fkeyword);
486  return -1;
487  }
488 }
489 
ldns_bgetc
int ldns_bgetc(ldns_buffer *buffer)
returns the next character from a buffer.
Definition: buffer.c:157
LDNS_STATUS_SYNTAX_ERR
@ LDNS_STATUS_SYNTAX_ERR
Definition: error.h:97
LDNS_STATUS_NULL
@ LDNS_STATUS_NULL
Definition: error.h:51
LDNS_STATUS_ERR
@ LDNS_STATUS_ERR
Definition: error.h:37
LDNS_STATUS_MEM_ERR
@ LDNS_STATUS_MEM_ERR
Definition: error.h:34
LDNS_STATUS_OK
@ LDNS_STATUS_OK
Definition: error.h:26
LDNS_STATUS_SYNTAX_EMPTY
@ LDNS_STATUS_SYNTAX_EMPTY
Definition: error.h:91
ldns_status
enum ldns_enum_status ldns_status
Definition: error.h:146
ldns.h
Including this file will include all ldns files, and define some lookup tables.
ldns_fget_token_l
ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
returns a token/char from the stream F.
Definition: parse.c:220
ldns_directive_types
ldns_lookup_table ldns_directive_types[]
Definition: parse.c:16
ldns_fget_keyword_data
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)
Definition: parse.c:231
ldns_bget_keyword_data
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)
Definition: parse.c:458
ldns_fget_token
ssize_t ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit)
returns a token/char from the stream F.
Definition: parse.c:25
ldns_fget_token_l_st
ldns_status ldns_fget_token_l_st(FILE *f, char **token, size_t *limit, bool fixed, const char *delim, int *line_nr)
returns a token/char from the stream f.
Definition: parse.c:31
ldns_fskipcs
void ldns_fskipcs(FILE *fp, const char *s)
skips all of the characters in the given string in the fp, moving the position to the first character...
Definition: parse.c:427
ldns_bskipcs
void ldns_bskipcs(ldns_buffer *buffer, const char *s)
skips all of the characters in the given string in the buffer, moving the position to the first chara...
Definition: parse.c:404
ldns_fskipcs_l
void ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
skips all of the characters in the given string in the fp, moving the position to the first character...
Definition: parse.c:433
ldns_fget_keyword_data_l
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)
Definition: parse.c:239
ldns_bget_token
ssize_t ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit)
returns a token/char from the buffer b.
Definition: parse.c:274
LDNS_MAX_KEYWORDLEN
#define LDNS_MAX_KEYWORDLEN
Definition: parse.h:24
LDNS_MAX_LINELEN
#define LDNS_MAX_LINELEN
Definition: parse.h:23
LDNS_DIR_TTL
@ LDNS_DIR_TTL
Definition: parse.h:41
LDNS_DIR_INCLUDE
@ LDNS_DIR_INCLUDE
Definition: parse.h:43
LDNS_DIR_ORIGIN
@ LDNS_DIR_ORIGIN
Definition: parse.h:42
LDNS_PARSE_NORMAL
#define LDNS_PARSE_NORMAL
Definition: parse.h:21
ldns_struct_buffer
implementation of buffers to ease operations
Definition: buffer.h:51
ldns_struct_buffer::_position
size_t _position
The current position used for reading/writing.
Definition: buffer.h:53
ldns_struct_buffer::_limit
size_t _limit
The read/write limit.
Definition: buffer.h:56
ldns_struct_lookup_table
A general purpose lookup table.
Definition: util.h:156
LDNS_FREE
#define LDNS_FREE(ptr)
Definition: util.h:60
LDNS_XMALLOC
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
LDNS_XREALLOC
#define LDNS_XREALLOC(ptr, type, count)
Definition: util.h:57