Merge from vendor branch OPENSSL:
[dragonfly.git] / contrib / ntpd / parse.y
1 /*      $OpenBSD: src/usr.sbin/ntpd/parse.y,v 1.24 2004/11/25 06:27:41 henning Exp $ */
2
3 /*
4  * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org>
5  * Copyright (c) 2001 Markus Friedl.  All rights reserved.
6  * Copyright (c) 2001 Daniel Hartmeier.  All rights reserved.
7  * Copyright (c) 2001 Theo de Raadt.  All rights reserved.
8  *
9  * Permission to use, copy, modify, and distribute this software for any
10  * purpose with or without fee is hereby granted, provided that the above
11  * copyright notice and this permission notice appear in all copies.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20  */
21
22 %{
23 #include <sys/types.h>
24 #include <sys/socket.h>
25 #include <netinet/in.h>
26 #include <arpa/inet.h>
27
28 #include <ctype.h>
29 #include <errno.h>
30 #include <limits.h>
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <syslog.h>
35
36 #include "ntpd.h"
37
38 static struct ntpd_conf         *conf;
39 static FILE                     *fin = NULL;
40 static int                       lineno = 1;
41 static int                       errors = 0;
42 const char                      *infile;
43
44 int      yyerror(const char *, ...);
45 int      yyparse(void);
46 int      kw_cmp(const void *, const void *);
47 int      lookup(char *);
48 int      lgetc(FILE *);
49 int      lungetc(int);
50 int      findeol(void);
51 int      yylex(void);
52
53 typedef struct {
54         union {
55                 u_int32_t                number;
56                 char                    *string;
57                 struct ntp_addr_wrap    *addr;
58         } v;
59         int lineno;
60 } YYSTYPE;
61
62 %}
63
64 %token  LISTEN ON
65 %token  SERVER SERVERS
66 %token  ERROR
67 %token  <v.string>              STRING
68 %type   <v.addr>                address
69 %%
70
71 grammar         : /* empty */
72                 | grammar '\n'
73                 | grammar conf_main '\n'
74                 | grammar error '\n'            { errors++; }
75                 ;
76
77 conf_main       : LISTEN ON address     {
78                         struct listen_addr      *la;
79                         struct ntp_addr         *h, *next;
80
81                         if ((h = $3->a) == NULL &&
82                             (host_dns($3->name, &h) == -1 || !h)) {
83                                 yyerror("could not resolve \"%s\"", $3->name);
84                                 free($3->name);
85                                 free($3);
86                                 YYERROR;
87                         }
88
89                         for (; h != NULL; h = next) {
90                                 next = h->next;
91                                 if (h->ss.ss_family == AF_UNSPEC) {
92                                         conf->listen_all = 1;
93                                         free(h);
94                                         continue;
95                                 }
96                                 la = calloc(1, sizeof(struct listen_addr));
97                                 if (la == NULL)
98                                         fatal("listen on calloc");
99                                 la->fd = -1;
100                                 memcpy(&la->sa, &h->ss,
101                                     sizeof(struct sockaddr_storage));
102                                 TAILQ_INSERT_TAIL(&conf->listen_addrs, la,
103                                     entry);
104                                 free(h);
105                         }
106                         free($3->name);
107                         free($3);
108                 }
109                 | SERVERS address       {
110                         struct ntp_peer         *p;
111                         struct ntp_addr         *h, *next;
112
113                         h = $2->a;
114                         do {
115                                 if (h != NULL) {
116                                         next = h->next;
117                                         if (h->ss.ss_family != AF_INET &&
118                                             h->ss.ss_family != AF_INET6) {
119                                                 yyerror("IPv4 or IPv6 address "
120                                                     "or hostname expected");
121                                                 free(h);
122                                                 free($2->name);
123                                                 free($2);
124                                                 YYERROR;
125                                         }
126                                         h->next = NULL;
127                                 } else
128                                         next = NULL;
129
130                                 p = new_peer();
131                                 p->addr = h;
132                                 p->addr_head.a = h;
133                                 p->addr_head.pool = 1;
134                                 p->addr_head.name = strdup($2->name);
135                                 if (p->addr_head.name == NULL)
136                                         fatal(NULL);
137                                 TAILQ_INSERT_TAIL(&conf->ntp_peers, p, entry);
138
139                                 h = next;
140                         } while (h != NULL);
141
142                         free($2->name);
143                         free($2);
144                 }
145                 | SERVER address        {
146                         struct ntp_peer         *p;
147                         struct ntp_addr         *h, *next;
148
149                         p = new_peer();
150                         for (h = $2->a; h != NULL; h = next) {
151                                 next = h->next;
152                                 if (h->ss.ss_family != AF_INET &&
153                                     h->ss.ss_family != AF_INET6) {
154                                         yyerror("IPv4 or IPv6 address "
155                                             "or hostname expected");
156                                         free(h);
157                                         free(p);
158                                         free($2->name);
159                                         free($2);
160                                         YYERROR;
161                                 }
162                                 h->next = p->addr;
163                                 p->addr = h;
164                         }
165
166                         p->addr_head.a = p->addr;
167                         p->addr_head.pool = 0;
168                         p->addr_head.name = strdup($2->name);
169                         if (p->addr_head.name == NULL)
170                                 fatal(NULL);
171                         TAILQ_INSERT_TAIL(&conf->ntp_peers, p, entry);
172                         free($2->name);
173                         free($2);
174                 }
175                 ;
176
177 address         : STRING                {
178                         if (($$ = calloc(1, sizeof(struct ntp_addr_wrap))) ==
179                             NULL)
180                                 fatal(NULL);
181                         if (host($1, &$$->a) == -1) {
182                                 yyerror("could not parse address spec \"%s\"",
183                                     $1);
184                                 free($1);
185                                 free($$);
186                                 YYERROR;
187                         }
188                         $$->name = $1;
189                 }
190                 ;
191
192 %%
193
194 struct keywords {
195         const char      *k_name;
196         int              k_val;
197 };
198
199 int
200 yyerror(const char *fmt, ...)
201 {
202         va_list          ap;
203         char            *nfmt;
204
205         errors = 1;
206         va_start(ap, fmt);
207         if (asprintf(&nfmt, "%s:%d: %s", infile, yylval.lineno, fmt) == -1)
208                 fatalx("yyerror asprintf");
209         vlog(LOG_CRIT, nfmt, ap);
210         va_end(ap);
211         free(nfmt);
212         return (0);
213 }
214
215 int
216 kw_cmp(const void *k, const void *e)
217 {
218         return (strcmp(k, ((const struct keywords *)e)->k_name));
219 }
220
221 int
222 lookup(char *s)
223 {
224         /* this has to be sorted always */
225         static const struct keywords keywords[] = {
226                 { "listen",             LISTEN},
227                 { "on",                 ON},
228                 { "server",             SERVER},
229                 { "servers",            SERVERS}
230         };
231         const struct keywords   *p;
232
233         p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
234             sizeof(keywords[0]), kw_cmp);
235
236         if (p)
237                 return (p->k_val);
238         else
239                 return (STRING);
240 }
241
242 #define MAXPUSHBACK     128
243
244 char    *parsebuf;
245 int      parseindex;
246 char     pushback_buffer[MAXPUSHBACK];
247 int      pushback_index = 0;
248
249 int
250 lgetc(FILE *f)
251 {
252         int     c, next;
253
254         if (parsebuf) {
255                 /* Read character from the parsebuffer instead of input. */
256                 if (parseindex >= 0) {
257                         c = parsebuf[parseindex++];
258                         if (c != '\0')
259                                 return (c);
260                         parsebuf = NULL;
261                 } else
262                         parseindex++;
263         }
264
265         if (pushback_index)
266                 return (pushback_buffer[--pushback_index]);
267
268         while ((c = getc(f)) == '\\') {
269                 next = getc(f);
270                 if (next != '\n') {
271                         if (isspace(next))
272                                 yyerror("whitespace after \\");
273                         ungetc(next, f);
274                         break;
275                 }
276                 yylval.lineno = lineno;
277                 lineno++;
278         }
279         if (c == '\t' || c == ' ') {
280                 /* Compress blanks to a single space. */
281                 do {
282                         c = getc(f);
283                 } while (c == '\t' || c == ' ');
284                 ungetc(c, f);
285                 c = ' ';
286         }
287
288         return (c);
289 }
290
291 int
292 lungetc(int c)
293 {
294         if (c == EOF)
295                 return (EOF);
296         if (parsebuf) {
297                 parseindex--;
298                 if (parseindex >= 0)
299                         return (c);
300         }
301         if (pushback_index < MAXPUSHBACK-1)
302                 return (pushback_buffer[pushback_index++] = c);
303         else
304                 return (EOF);
305 }
306
307 int
308 findeol(void)
309 {
310         int     c;
311
312         parsebuf = NULL;
313         pushback_index = 0;
314
315         /* skip to either EOF or the first real EOL */
316         while (1) {
317                 c = lgetc(fin);
318                 if (c == '\n') {
319                         lineno++;
320                         break;
321                 }
322                 if (c == EOF)
323                         break;
324         }
325         return (ERROR);
326 }
327
328 int
329 yylex(void)
330 {
331         char     buf[8096];
332         char    *p;
333         int      endc, c;
334         int      token;
335
336         p = buf;
337         while ((c = lgetc(fin)) == ' ')
338                 ; /* nothing */
339
340         yylval.lineno = lineno;
341         if (c == '#')
342                 while ((c = lgetc(fin)) != '\n' && c != EOF)
343                         ; /* nothing */
344
345         switch (c) {
346         case '\'':
347         case '"':
348                 endc = c;
349                 while (1) {
350                         if ((c = lgetc(fin)) == EOF)
351                                 return (0);
352                         if (c == endc) {
353                                 *p = '\0';
354                                 break;
355                         }
356                         if (c == '\n') {
357                                 lineno++;
358                                 continue;
359                         }
360                         if (p + 1 >= buf + sizeof(buf) - 1) {
361                                 yyerror("string too long");
362                                 return (findeol());
363                         }
364                         *p++ = (char)c;
365                 }
366                 yylval.v.string = strdup(buf);
367                 if (yylval.v.string == NULL)
368                         fatal("yylex: strdup");
369                 return (STRING);
370         }
371
372 #define allowed_in_string(x) \
373         (isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
374         x != '{' && x != '}' && x != '<' && x != '>' && \
375         x != '!' && x != '=' && x != '/' && x != '#' && \
376         x != ','))
377
378         if (isalnum(c) || c == ':' || c == '_' || c == '*') {
379                 do {
380                         *p++ = c;
381                         if ((unsigned)(p-buf) >= sizeof(buf)) {
382                                 yyerror("string too long");
383                                 return (findeol());
384                         }
385                 } while ((c = lgetc(fin)) != EOF && (allowed_in_string(c)));
386                 lungetc(c);
387                 *p = '\0';
388                 if ((token = lookup(buf)) == STRING)
389                         if ((yylval.v.string = strdup(buf)) == NULL)
390                                 fatal("yylex: strdup");
391                 return (token);
392         }
393         if (c == '\n') {
394                 yylval.lineno = lineno;
395                 lineno++;
396         }
397         if (c == EOF)
398                 return (0);
399         return (c);
400 }
401
402 int
403 parse_config(const char *filename, struct ntpd_conf *xconf)
404 {
405         conf = xconf;
406         lineno = 1;
407         errors = 0;
408         TAILQ_INIT(&conf->listen_addrs);
409         TAILQ_INIT(&conf->ntp_peers);
410
411         if ((fin = fopen(filename, "r")) == NULL) {
412                 log_warn("%s", filename);
413                 return (-1);
414         }
415         infile = filename;
416
417         yyparse();
418
419         fclose(fin);
420
421         return (errors ? -1 : 0);
422 }