chiark / gitweb /
Cope with moved changelogs.
[userv.git] / parser.c
1 /*
2  * userv - parser.c
3  * configuration file parser; this file is actually #included from
4  * lexer.c, which is generated using flex from lexer.l, in turn from
5  * lexer.l.m4.  It's in a separate file so that we don't have to worry
6  * about m4 quoting &c., but we have to #include it so that the C
7  * objects from the lexer are available.
8  *
9  * Copyright (C)1996-1997 Ian Jackson
10  *
11  * This is free software; you can redistribute it and/or modify it
12  * under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful, but
17  * WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with userv; if not, write to the Free Software
23  * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24  */
25
26 static int parse_file(const char *string, int *didexist);
27 static int parser(int allowce);
28 int parse_string(const char *string, const char *descrip, int isinternal);
29
30 /*
31  * Error-handling routines
32  */
33
34 static void closeerrorfile(void) {
35   if (eh.file && !eh.filekeep) {
36     if (fclose(eh.file)) {
37       eh.handling= tokv_word_errorstostderr;
38       parseerrprint("error writing to error log file `%s': %s",
39                     eh.filename,strerror(errno));
40     }
41     free(eh.filename);
42   }
43   eh.handling= 0;
44   eh.file= 0; eh.filename= 0; eh.filekeep= 0;
45 }
46
47 static void senderrmsg(const char *errmsg, int useehandling) {
48   char suberrmsg[MAX_ERRMSG_LEN];
49   int e;
50   time_t now;
51   struct tm *lt;
52
53   switch (useehandling) {
54   case tokv_word_errorstostderr:
55     senderrmsgstderr(errmsg);
56     break;
57   case tokv_word_errorstosyslog:
58     ensurelogopen(eh.logfacility);
59     syslog(eh.loglevel,"%s",errmsg);
60     break;
61   case tokv_word_errorstofile:
62     if (time(&now)==-1) syscallerror("get current time");
63     lt= localtime(&now); if (!lt) syscallerror("convert current time");
64     if (fprintf(eh.file,"%d-%02d-%02d %02d:%02d:%02d: uservd: %s\n",
65                 lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday,
66                 lt->tm_hour, lt->tm_min, lt->tm_sec,
67                 errmsg) == EOF) {
68       e= errno;
69       closeerrorfile(); eh.handling= tokv_word_errorstofile;
70       snyprintf(suberrmsg,sizeof(suberrmsg),
71                 "error writing to error log file `%.*s': %s;"
72                 " reverting to errors-to-stderr",
73                 (int)(sizeof(suberrmsg)>>1),eh.filename,strerror(e));
74       senderrmsg(suberrmsg,eh.handling);
75       senderrmsg(errmsg,eh.handling);
76     }
77     break;
78   default:
79     abort();
80   }
81 }
82
83 static void errwhere(struct parser_state *tstate, char *bufput, int bufputlen) {
84   static const char suffix[]= "references ...";
85   char errmsg[MAX_ERRMSG_LEN];
86   
87   if (!tstate) {
88     strnycpy(bufput,"<initialisation>: ",bufputlen);
89     return;
90   }
91   if (!tstate->notedreferer && tstate->upstate && !tstate->upstate->isinternal) {
92     errwhere(tstate->upstate,errmsg,sizeof(errmsg)-sizeof(suffix));
93     strcat(errmsg,suffix);
94     senderrmsg(errmsg,eh.handling);
95     tstate->notedreferer= 1;
96   }
97   snyprintf(bufput,bufputlen,"%.*s:%d: ",bufputlen-10,
98             tstate->filename,tstate->reportlineno);
99 }
100
101 void parseerrprint(const char *fmt, ...) {
102   va_list al;
103   char errmsg[MAX_ERRMSG_LEN];
104
105   va_start(al,fmt);
106   errwhere(cstate,errmsg,sizeof(errmsg)>>1);
107   vsnytprintfcat(errmsg,sizeof(errmsg),fmt,al);
108   senderrmsg(errmsg,eh.handling);
109   va_end(al);
110 }
111
112 static int unexpected(int found, int wanted, const char *wantedstr) {
113   /* pass wanted==-1 if you know it's not what you wanted;
114    * otherwise this function will check it for you.
115    */
116   if (found == wanted) return 0;
117   if (found == tokv_error) return found;
118   parseerrprint("found %s, expected %s",printtoken(found),wantedstr);
119   return tokv_error;
120 }
121
122 static int stringoverflow(const char *where) {
123   parseerrprint("string buffer became far too large building %s",where);
124   return tokv_error;
125 }
126
127 /*
128  * General assistance functions
129  */
130
131 static void freecharparray(char **array) {
132   char **pp;
133
134   if (!array) return;
135   for (pp=array; *pp; pp++) free(*pp);
136   free(array);
137 }
138
139 static int dequote(char *inplace) {
140   char *p, *q, buf[4], *bep;
141   int v;
142   
143   p=q=inplace;
144   assert(*p++ = '"');
145   while (*p && *p != '"') {
146     if (*p != '\\') { *q++= *p++; continue; }
147     switch (*++p) {
148     case 'n': *q++= '\n'; continue;
149     case 'r': *q++= '\r'; continue;
150     case 't': *q++= '\t'; continue;
151     case 'x':
152       assert(buf[0]= *++p); assert(buf[1]= *++p); buf[2]= 0;
153       v= strtoul(buf,&bep,16); assert(bep == buf+2);
154       assert(!(v & ~0xff)); *q++= v; p++; continue;
155     default:
156       if (isalpha(*p)) {
157         parseerrprint("unknown \\<letter> sequence \\%c in quoted string",*p);
158         return tokv_error;
159       } else if (isdigit(*p)) {
160         assert(buf[0]= *++p); assert(buf[1]= *++p); assert(buf[2]= *++p);
161         buf[3]= 0; v= strtoul(buf,&bep,8);
162         if (bep != buf+3 || (v & ~0xff)); {
163           parseerrprint("invalid \\<octal> sequence \\%s in quoted string",buf);
164           return tokv_error;
165         }
166         *q++= v; p++; continue;
167       } else if (ispunct(*p)) {
168         *q++= *p++; continue;
169       } else {
170         while (*p==' ' || *p=='\t') p++;
171         assert(*p=='\n');
172       }
173     }
174   }
175   assert(*p); assert(!*++p);
176   *q++= 0;
177   return tokv_quotedstring;
178 }
179
180 const char *printtoken(int token) {
181   /* Returns pointer to static buffer, overwritten by next call. */
182   static const char keywordfmt[]= "keyword `%s'";
183   static const char operatorfmt[]= "operator `%s'";
184   
185   static char buf[250];
186   
187   char *q;
188   const char *p;
189   int i, c, l;
190   
191   if ((token & tokm_repres) == tokr_word) {
192     assert(strlen(yytext)+sizeof(keywordfmt)<sizeof(buf));
193     snyprintf(buf,sizeof(buf),keywordfmt,yytext);
194     return buf;
195   } else if (token & tokt_number) {
196     snyprintf(buf,sizeof(buf),"number %d",lr_min); return buf;
197   } else if (token & tokt_fdrange && lr_max==-1) {
198     snyprintf(buf,sizeof(buf),"fdrange %d-",lr_min); return buf;
199   } else if (token & tokt_fdrange) {
200     snyprintf(buf,sizeof(buf),"fdrange %d-%d",lr_min,lr_max); return buf;
201   } else if ((token & tokm_repres) == tokr_punct) {
202     assert(strlen(yytext)+sizeof(operatorfmt)<sizeof(buf));
203     snyprintf(buf,sizeof(buf),operatorfmt,yytext);
204     return buf;
205   } else if (token & tokt_string) {
206     switch (token) {
207     case tokv_barestring: strcpy(buf,"unquoted string (bare word)"); break;
208     case tokv_quotedstring: strcpy(buf,"quoted string"); break;
209     default: abort();
210     }
211     strcat(buf," `");
212     l= strlen(buf); i= sizeof(buf)-l-2; p= yytext; q= buf+l;
213     while ((c= *p++)) {
214       if (i-- <= 0) { q--; strcpy(q-3,"..."); break; }
215       if (isspace(c)) c= ' ';
216       else if (!isprint(c) || iscntrl(c)) c= '?';
217       else *q++= c;
218     }
219     strcpy(q,"'");
220     return buf;
221   } else {
222     switch (token) {
223     case tokv_lwsp:    return "linear whitespace";
224     case tokv_newline: return "newline (or comment followed by newline)";
225     case tokv_eof:     return "end of input file";
226     case tokv_error:   return "syntax error token";
227     default:
228       sprintf(buf,"token#0%o",token); return buf;
229     }
230   }
231 }
232
233 static const char *string2path(const char *in) {
234   /* Returned pointers become invalid on next call.
235    * May return 0, having printed an error message.
236    */
237   static char *p;
238   static int pl;
239   
240   if (strncmp(in,"~/",2)) return in;
241   if (makeroom(&p,&pl,strlen(serviceuser_dir)+1+strlen(in+2)+1)) {
242     stringoverflow("pathname");
243     return 0;
244   }
245   snyprintf(p,pl,"%s/%s",serviceuser_dir,in+2);
246   return p;
247 }
248
249 /*
250  * Parser component functions for parsing parameters to directives
251  *
252  * Functions pa_... parse just one parameter,
253  *  and return tokv_error or 0, having scanned exactly what they were expecting
254  * Functions paa_... parse complete parameter lists, including the leading lwsp,
255  *  and return tokv_error or 0, having scanned up to and including the newline
256  *
257  * For any function which takes `const char **rv' the
258  * value returned in *rv is overwritten by repeated calls to
259  * any of those functions (whether the same or another).
260  */
261
262 static int pa_mnl(void) {
263   return unexpected(yylex(),tokv_newline,"newline");
264 }
265 static int pa_mwsp(void) {
266   return unexpected(yylex(),tokv_lwsp,"linear whitespace");
267 }
268
269 static int pa_string(const char **rv) {
270   static char *p= 0;
271   static int pl= 0;
272
273   int r, l;
274
275   r= pa_mwsp(); if (r) return r;
276   r= yylex(); if (r == tokv_error) return r;
277   if ((r & tokm_repres) == tokr_nonstring) return unexpected(r,-1,"string");
278   l= strlen(yytext)+1;
279   if (makeroom(&p,&pl,l)) return stringoverflow("string argument");
280   strcpy(p,yytext); *rv= p;
281
282   return 0;
283 }  
284
285 static int pa_numberdollar(int *value_r) {
286   /* Also parses the whitespace beforehand. */
287   int r;
288
289   r= pa_mwsp(); if (r) return r;
290   r= yylex(); if (r == tokv_error || r == tokv_dollar) return r;
291   if (unexpected(r,tokv_ordinal,"expected number or dollar")) return tokv_error;
292   *value_r= lr_min;
293   return r;
294 }
295
296 static int paa_1string(const char **rv) {
297   int r;
298
299   r= pa_string(rv); if (r) return r;
300   return pa_mnl();
301 }  
302
303 static int paa_1path(const char **rv) {
304   const char *cp;
305   int r;
306   
307   r= paa_1string(&cp); if (r) return r;
308   *rv= string2path(cp); if (!*rv) return tokv_error;
309   return 0;
310 }
311
312 static int paa_pathargs(const char **path_r, char ***newargs_r) {
313   /* Repeated calls do _not_ overwrite newargs_r; caller must free.
314    * Repeated calls _do_ overwrite string returned in path_r.
315    * Any call to this function invalidates previous returns in *rv.
316    */
317   char **newargs;
318   const char *string;
319   int used, size, r;
320
321   r= pa_string(&string); if (r == tokv_error) return r;
322   *path_r= string2path(string); if (!*path_r) return tokv_error;
323   
324   used=0; size=0;
325   newargs= xmalloc(sizeof(char*)*(size+1));
326
327   for (;;) {
328     r= yylex(); if (r == tokv_error) goto error;
329     if (r==tokv_newline) break;
330     if (unexpected(r,tokv_lwsp,"newline after or whitespace between arguments")) {
331       r= tokv_error; goto error;
332     }
333     r= yylex(); if (r==tokv_error) goto error;
334     if ((r & tokm_repres) == tokr_nonstring) {
335       r= unexpected(r,-1,"string for command argument");
336       goto error;
337     }
338     if (used>=size) {
339       if (used >= MAX_ARGSDEFVAR) {
340         parseerrprint("far too many arguments to service program");
341         r= tokv_error; goto error;
342       }
343       size= (used+5)<<1;
344       newargs= xrealloc(newargs,sizeof(char*)*(size+1));
345     }
346     newargs[used++]= xstrsave(yytext);
347   }
348   newargs[used]= 0;
349   *newargs_r= newargs;
350   return 0;
351   
352 error:
353   newargs[used]=0;
354   freecharparray(newargs);
355   return r;
356 }
357
358 static int paa_message(const char **message_r) {
359   /* Returned value is invalidated by repeated calls. */
360   static char *buildbuf;
361   static int buildbuflen;
362
363   int r, tl;
364
365   r= pa_mwsp(); if (r) return r;
366   tl= 1;
367   if (makeroom(&buildbuf,&buildbuflen,50)) return stringoverflow("start of message");
368   buildbuf[0]= 0;
369   for (;;) {
370     r= yylex(); if (r == tokv_error) return r;
371     if (r == tokv_eof) {
372       parseerrprint("unexpected end of file in message text");
373       return tokv_error;
374     }
375     if (r == tokv_newline) break;
376     tl+= strlen(yytext);
377     if (makeroom(&buildbuf,&buildbuflen,tl)) return stringoverflow("message");
378     strcat(buildbuf,yytext);
379   }
380   *message_r= buildbuf;
381   return 0;
382 }
383
384 /*
385  * Skipping routines (used by e.g. the `if' code).
386  */
387
388 static int skiptoeol(void) {
389   /* Returns 0 if OK, having just parsed the newline
390    * or tokv_error if an error occurs, leaving the position at the error
391    * (which may be EOF or a syntax error token).
392    */
393   int token;
394
395   do { token= yylex(); }
396   while (token != tokv_newline && !(token & tokt_exception));
397   if (token == tokv_newline) return 0;
398   if (token == tokv_error) return token;
399   assert(token == tokv_eof);
400   parseerrprint("unexpected end of file while looking for end of line");
401   return tokv_error;
402 }
403
404 static int skip(int allowce) {
405   /* Scans a piece of config without executing it.  Returns
406    * tokv_error (leaving the parsing state at the error),
407    * or the tokt_controlend token with type allowce if one
408    * was found (in which case rest of line, including any whitespace
409    * after tokt_controlend, has not been parsed), or tokv_eof.
410    */
411   int token, r;
412
413   for (;;) { /* loop over lines */
414     cstate->reportlineno= cstate->lineno;
415     do { token= yylex(); } while (token == tokv_lwsp);
416     if (token & tokt_exception) {
417       return token;
418     } else if (token & tokt_controlend) {
419       if (allowce == lr_controlend) return token;
420       else return unexpected(token,-1,"control structure end of a different kind");
421     } else if (token & tokt_controlstart) {
422       r= token;
423       while (r & tokt_controlstart) {
424         r= skiptoeol(); if (r) return r;
425         cstate->reportlineno= cstate->lineno;
426         r= skip(token); if (r & tokt_exception) return r;
427       }
428     } else if (!(token & tokt_directive) && !(token & tokt_condop)) {
429       parseerrprint("not a directive (or conditional operator) "
430                     "while looking for control structure end");
431       return tokv_error;
432     }
433     r= skiptoeol(); if (r) return r;
434   }
435 }
436
437 /*
438  * Routines for parsing and getting the values of parameters
439  */
440
441 static void parm_1string(char ***rvalues, const char *tocopy) {
442   char **a;
443   a= xmalloc(sizeof(char*)*2);
444   a[0]= xstrsave(tocopy);
445   a[1]= 0;
446   *rvalues= a;
447 }
448
449 static char *parm_ulong(unsigned long ul) {
450   char *p;
451   int l;
452
453   l= CHAR_BIT*sizeof(unsigned long)/3+4;
454   p= xmalloc(l);
455   snyprintf(p,l,"%lu",ul);
456   return p;
457 }
458
459 static int parm_usernameuid(char ***rvalues, const char *name, uid_t id) {
460   char **a;
461   
462   a= xmalloc(sizeof(char*)*3);
463   a[0]= xstrsave(name);
464   a[1]= parm_ulong(id);
465   a[2]= 0;
466   *rvalues= a;
467   return 0;
468 }
469
470 static int parm_groups(char ***rvalues, int size,
471                        gid_t *gids, const char *const *groups) {
472   char **a;
473   int i;
474   
475   if (size >= 2 && gids[0] == gids[1]) { size--; gids++; groups++; }
476   a= xmalloc(sizeof(char*)*(size+1)*2);
477   for (i=0; i<size; i++) {
478     a[i]= xstrsave(groups[i]);
479     a[size+i]= parm_ulong(gids[i]);
480   }
481   a[size*2]= 0;
482   *rvalues= a;
483   return 0;
484 }  
485
486 static int pf_service(int ptoken, char ***rvalues) {
487   parm_1string(rvalues,service); return 0;
488 }
489
490 static int pf_callinguser(int ptoken, char ***rvalues) {
491   return parm_usernameuid(rvalues,logname,request_mbuf.callinguid);
492 }
493
494 static int pf_serviceuser(int ptoken, char ***rvalues) {
495   return parm_usernameuid(rvalues,serviceuser,serviceuser_uid);
496 }
497
498 static int pf_callinggroup(int ptoken, char ***rvalues) {
499   return parm_groups(rvalues,request_mbuf.ngids,calling_gids,calling_groups);
500 }
501
502 static int pf_servicegroup(int ptoken, char ***rvalues) {
503   return parm_groups(rvalues,service_ngids,service_gids,service_groups);
504 }
505
506 static int pf_callingusershell(int ptoken, char ***rvalues) {
507   parm_1string(rvalues,callinguser_shell); return 0;
508 }
509
510 static int pf_serviceusershell(int ptoken, char ***rvalues) {
511   parm_1string(rvalues,serviceuser_shell); return 0;
512 }
513
514 static int pa_parameter(char ***rvalues, char **rname) {
515   /* Scans a single parameter token and calls the appropriate parameter
516    * function, returning tokv_error (leaving the parser state wherever),
517    * or 0 on success (having just parsed the parameter name).
518    * If rname is non-null then the name of the parameter (malloc'd) will
519    * be stored in it.
520    *
521    * Caller must free *rvalues using freecharparray.
522    */
523   int token, r, i;
524   char *name;
525
526   token= yylex(); if (token == tokv_error) return token;
527   name= xstrsave(yytext);
528   if ((token & tokm_repres) != tokr_nonstring &&
529       !memcmp(yytext,"u-",2) && strlen(yytext)>=3) {
530     for (i=0;
531          i<request_mbuf.nvars && strcmp(yytext+2,defvararray[i].key);
532          i++);
533     if (i>=request_mbuf.nvars) {
534       *rvalues= xmalloc(sizeof(char*));
535       **rvalues= 0;
536     } else {
537       parm_1string(rvalues,defvararray[i].value);
538     }
539   } else if (token & tokt_parameter) {
540     r= (lr_parameter)(token,rvalues);
541     if (r) { free(name); return r; }
542   } else {
543     free(name);
544     return unexpected(token,-1,"parameter name");
545   }
546   debug_dumpparameter(name,*rvalues);
547   if (rname) *rname= name;
548   else free(name);
549   return 0;
550 }
551
552 /*
553  * Routines for parsing conditions, including
554  * parameter-based conditional functions (parmcondition's).
555  */
556
557 int pcf_glob(int ctoken, char *const *pv, int *rtrue) {
558   int token, actrue, r;
559   char *const *pp;
560
561   actrue= 0;
562   r= pa_mwsp(); if (r) return r;
563   for (;;) {
564     token= yylex();
565     if ((token & tokm_repres) == tokr_nonstring)
566       return unexpected(token,-1,"glob pattern");
567     for (pp= pv; !actrue && *pp; pp++) if (!fnmatch(yytext,*pp,0)) actrue= 1;
568     token= yylex(); 
569     if (token == tokv_newline) break;
570     if (unexpected(token,tokv_lwsp,"newline after or whitespace between glob patterns"))
571       return tokv_error;
572   }
573   *rtrue= actrue;
574   return 0;
575 }
576
577 int pcf_range(int ctoken, char *const *pv, int *rtrue) {
578   int mintoken, min, maxtoken, max, r;
579   char *const *pp;
580   char *ep;
581   unsigned long v;
582
583   r= pa_mwsp(); if (r) return r;
584   mintoken= pa_numberdollar(&min); if (mintoken == tokv_error) return mintoken;
585   r= pa_mwsp(); if (r) return r;
586   maxtoken= pa_numberdollar(&max); if (maxtoken == tokv_error) return maxtoken;
587   r= pa_mnl(); if (r) return r;
588   for (pp= pv; *pp; pp++) {
589     v= strtoul(*pp,&ep,10); if (*ep) continue;
590     if (mintoken != tokv_dollar && v < min) continue;
591     if (maxtoken != tokv_dollar && v > max) continue;
592     *rtrue= 1; return 0;
593   }
594   *rtrue= 0; return 0;
595 }
596
597 int pcf_grep(int ctoken, char *const *pv, int *rtrue) {
598   FILE *file;
599   const char *cp;
600   char *const *pp;
601   char *buf, *p;
602   int r, maxlen, l, c, actrue, posstrue;
603   
604   r= paa_1path(&cp); if (r) return r;
605   file= fopen(cp,"r");
606   if (!file) {
607     parseerrprint("unable to open file `%s' for grep: %s",cp,strerror(errno));
608     return tokv_error;
609   }
610   maxlen= 0;
611   for (pp= pv; *pp; pp++) { l= strlen(*pp); if (l > maxlen) maxlen= l; }
612   buf= xmalloc(maxlen+2); actrue= 0; c= 0;
613   while (!actrue && c!=EOF) {
614     c= getc(file); if (c==EOF) break;
615     if (isspace(c)) continue;
616     l= maxlen+1; p= buf;
617     while (l>0 && c!='\n' && c!=EOF) { *p++= c; l--; c= getc(file); } 
618     if (c=='\n' || c==EOF || isspace(c)) {
619       while (p>buf && isspace(p[-1])) --p;
620       *p= 0; posstrue= 0;
621       for (pp= pv; !posstrue && *pp; pp++)
622         if (!strcmp(*pp,buf)) posstrue= 1;
623     } else {
624       posstrue= 0;
625     }
626     if (c!='\n' && c!=EOF) {
627       for (;;) {
628         c= getc(file);
629         if (c==EOF || c=='\n') break;
630         if (!isspace(c)) posstrue= 0;
631       }
632     }
633     if (posstrue) actrue= 1;
634   }
635   if (ferror(file)) {
636     parseerrprint("error while reading `%s' for grep: %s",cp,strerror(errno));
637     fclose(file); free(buf); return tokv_error;
638   }
639   assert(actrue || feof(file));
640   fclose(file); free(buf); *rtrue= actrue;
641   return 0;
642
643
644 static int pa_condition(int *rtrue) {
645   /* Scans up to and including the newline following the condition;
646    * may scan more than one line if the condition is a multi-line
647    * one.  Returns 0 (setting *rtrue, and parsing up to and including
648    * the last newline) or tokv_error.
649    * Expects to scan the whitespace before its condition.
650    */
651   int r, token, andor, ctrue, actrue;
652   char **parmvalues;
653
654   r= pa_mwsp(); if (r) return r;
655   token= yylex();
656   if (token == tokv_error) {
657     return token;
658   } else if (token == tokv_not) {
659     r= pa_condition(&ctrue); if (r) return r;
660     *rtrue= !ctrue; return 0;
661   } else if (token == tokv_openparen) {
662     andor= 0; actrue= -1;
663     for (;;) {
664       cstate->reportlineno= cstate->lineno;
665       r= pa_condition(&ctrue); if (r) return r;
666       switch (andor) {
667       case 0:         assert(actrue==-1); actrue= ctrue;           break;
668       case tokv_and:  assert(actrue>=0); actrue= actrue && ctrue;  break;
669       case tokv_or:   assert(actrue>=0); actrue= actrue || ctrue;  break;
670       default:        abort();
671       }
672       do { token= yylex(); } while (token == tokv_lwsp);
673       if (token == tokv_error) return token;
674       if (token == tokv_closeparen) break;
675       if (andor) {
676         r= unexpected(token,andor,"same conjunction as before"); if (r) return r;
677       } else {
678         if (token != tokv_and && token != tokv_or)
679           return unexpected(token,-1,"first conjunction inside connective");
680         andor= token;
681       }
682     }
683     r= pa_mnl(); if (r) return r;
684     *rtrue= actrue; return 0;
685   } else if (token & tokt_parmcondition) {
686     r= pa_mwsp(); if (r) return r;
687     r= pa_parameter(&parmvalues,0); if (r) return r;
688     r= (lr_parmcond)(token,parmvalues,rtrue); freecharparray(parmvalues);
689     return r;
690   } else {
691     return unexpected(token,-1,"condition");
692   }
693 }
694
695 /*
696  * Directive functions and associated `common code' functions
697  */
698
699 /* Directives specifying the service program (execute-... and reset) */
700
701 static void execreset(void) {
702   execute= 0;
703   execbuiltin= 0;
704   free(execpath); execpath= 0;
705   freecharparray(execargs); execargs= 0;
706 }
707
708 int df_reject(int dtoken) {
709   int r;
710   
711   r= pa_mnl(); if (r) return r;
712   execreset();
713   execute= tokv_word_reject;
714   return 0;
715 }
716
717 int df_executefrompath(int dtoken) {
718   int r;
719   
720   r= pa_mnl(); if (r) return r;
721   execreset();
722   execute= tokv_word_executefrompath;
723   return 0;
724 }
725
726 int df_execute(int dtoken) {
727   const char *rv;
728   char **newargs;
729   int r;
730
731   r= paa_pathargs(&rv,&newargs); if (r) return r;
732   execreset();
733   execute= tokv_word_execute;
734   execargs= newargs;
735   execpath= xstrsave(rv);
736   return 0;
737 }
738
739 int df_executefromdirectory(int dtoken) {
740   const char *p, *q, *rv;
741   struct stat stab;
742   char *fn, **newargs;
743   int l, r;
744
745   r= paa_pathargs(&rv,&newargs); if (r) return r;
746   p= strrchr(service,'/'); if (p) p++; else p= service;
747   if (!*p || !isalnum(*p)) {
748     parseerrprint("execute-from-directory requires initial char of service "
749                   "portion to be alphanumeric (service portion was `%s')",
750                   p);
751     freecharparray(newargs);
752     return tokv_error;
753   }
754   for (q=p+1; *q; q++) {
755     if (!isalnum(*q) && *q != '-') {
756       parseerrprint("execute-from-directory requires service portion to "
757                     "contain only alphanumerics and hyphens (was `%s')",
758                     p);
759       freecharparray(newargs);
760       return tokv_error;
761     }
762   }
763   l= strlen(rv)+1+strlen(p)+1;
764   fn= xmalloc(l);
765   snyprintf(fn,l,"%s/%s",rv,p);
766   if (stat(fn,&stab)) {
767     if (errno == ENOENT) { free(fn); freecharparray(newargs); return 0; }
768     parseerrprint("failed to stat `%s' for execute-from-directory: %s",
769                   fn,strerror(errno));
770     free(fn); freecharparray(newargs); return tokv_error;
771   }
772   if (!S_ISREG(stab.st_mode)) {
773     parseerrprint("file `%s' in execute-from-directory is not an ordinary file"
774                   " or link to one (mode=0%lo)",fn,(unsigned long)stab.st_mode);
775     free(fn); freecharparray(newargs); return tokv_error;
776   }
777   execreset();
778   execute= tokv_word_executefromdirectory;
779   execargs= newargs;
780   execpath= fn;
781   return 0;
782 }
783
784 /* Parsing builtin service requests (execute-builtin) */
785
786 static int bispa_none(char ***rnewargs) {
787   return pa_mnl();
788 }
789
790 static int bispa_parameter(char ***rnewargs) {
791   int r, i;
792   char **parmvalues, *name, **newargs;
793   
794   r= pa_mwsp(); if (r) return r;
795   r= pa_parameter(&parmvalues,&name); if (r) return r;
796   for (i=0; parmvalues[i]; i++);
797   newargs= xmalloc(sizeof(char*)*(i+2));
798   newargs[0]= name;
799   memcpy(newargs+1,parmvalues,sizeof(char*)*(i+1));
800   free(parmvalues);
801   r= pa_mnl(); if (r) { free(newargs); return r; }
802   *rnewargs= newargs;
803   return 0;
804 }
805
806 int df_executebuiltin(int dtoken) {
807   int r;
808   builtinserviceexec_fnt *bisexec;
809   char *newpath, **newargs;
810
811   r= pa_mwsp(); if (r) return r;
812   r= yylex(); if (r == tokv_error) return r;
813   if (!(r & tokt_builtinservice)) return unexpected(r,-1,"builtin service name");
814   bisexec= lr_bisexec;
815   newpath= xstrsave(yytext);
816   newargs= 0;
817   r= lr_bispa(&newargs); if (r) { free(newpath); return r; }
818
819   execreset();
820   execute= tokv_word_executebuiltin;
821   execbuiltin= bisexec;
822   execpath= newpath;
823   execargs= newargs;
824   return 0;
825 }
826
827 /* Directives for changing other execution parameters */
828
829 int dfg_setflag(int dtoken) {
830   int r;
831
832   r= pa_mnl(); if (r) return r;
833   *lr_flag= lr_flagval;
834   return 0;
835 }
836
837 int df_reset(int dtoken) {
838   int r;
839
840   r= pa_mnl(); if (r) return r;
841   r= parse_string(RESET_CONFIGURATION,"<builtin reset configuration>",1);
842   return r;
843 }
844
845 int dfg_fdwant(int dtoken) {
846   int fdmin, fdmax, r, needreadwrite, havereadwrite, fd;
847
848   needreadwrite= lr_fdwant_readwrite;
849   r= pa_mwsp(); if (r) return r;
850   r= yylex(); if (r == tokv_error) return r;
851   if (!(r & tokt_fdrange)) return unexpected(r,-1,"file descriptor range");
852   fdmin= lr_min; fdmax= lr_max;
853   if (fdmin<0 || fdmin>MAX_ALLOW_FD ||
854       (fdmax != -1 && fdmax<0) || fdmax>MAX_ALLOW_FD) {
855     parseerrprint("file descriptor in range is negative or far too large");
856     return tokv_error;
857   }
858   r= yylex(); if (r == tokv_error) return r;
859   if (r == tokv_newline) {
860     if (needreadwrite > 0) {
861       parseerrprint("read or write is required");
862       return tokv_error;
863     }
864     havereadwrite= 0;
865   } else if (r == tokv_lwsp) {
866     if (needreadwrite < 0) {
867       parseerrprint("read or write not allowed"); return tokv_error;
868     }
869     r= yylex(); if (r == tokv_error) return r;
870     if (!(r & tokt_readwrite))
871       return unexpected(r,-1,"read or write (or perhaps newline)");
872     havereadwrite= r;
873     r= pa_mnl(); if (r) return r;
874   } else {
875     return unexpected(r,-1,"whitespace before read or write or newline");
876   }
877   ensurefdarray(fdmin);
878   if (fdmax == -1) {
879     if (!(dtoken == tokv_word_rejectfd || dtoken == tokv_word_ignorefd))
880       parseerrprint("unspecified maximum only allowed with reject-fd and ignore-fd");
881     fdmax= fdarrayused-1;
882     restfdwantstate= dtoken;
883     restfdwantrw= havereadwrite;
884   }
885   ensurefdarray(fdmax);
886   for (fd=fdmin; fd<=fdmax; fd++) {
887     fdarray[fd].wantstate= dtoken;
888     fdarray[fd].wantrw= havereadwrite;
889   }
890   return 0;
891 }
892
893 /* Directives for changing error handling */
894
895 int df_errorstostderr(int dtoken) {
896   int r;
897   
898   r= pa_mnl(); if (r) return r;
899   closeerrorfile(); eh.handling= dtoken;
900   return 0;
901 }
902
903 int df_errorstosyslog(int dtoken) {
904   int token, level, facility;
905
906   facility= DEFUSERLOGFACILITY;
907   level= DEFUSERLOGLEVEL;
908   token= yylex();
909   if (token == tokv_lwsp) {
910     token= yylex(); if (token == tokv_error) return token;
911     if (!(token & tokt_logfacility))
912       return unexpected(token,-1,"syslog facility (or end of line)");
913     facility= lr_logfacility;
914     token= yylex();
915   }    
916   if (token == tokv_lwsp) {
917     token= yylex(); if (token == tokv_error) return token;
918     if (!(token & tokt_loglevel))
919       return unexpected(token,-1,"syslog level (or end of line) after facility");
920     level= lr_loglevel;
921     token= yylex();
922   }
923   if (unexpected(token,tokv_newline,"end of line after errors-to-syslog"))
924     return tokv_error;
925   closeerrorfile(); eh.handling= tokv_word_errorstosyslog;
926   eh.logfacility= facility; eh.loglevel= level;
927   return 0;
928 }
929
930 int df_errorstofile(int dtoken) {
931   const char *cp;
932   FILE *file;
933   int r;
934   
935   r= paa_1path(&cp); if (r) return r;
936   file= fopen(cp,"a");
937   if (!file) {
938     parseerrprint("unable to open error log file `%s': %s",cp,strerror(errno));
939     return tokv_error;
940   }
941   if (setvbuf(file,0,_IOLBF,MAX_ERRMSG_LEN)) {
942     parseerrprint("unable to set line buffering on errors file: %s",strerror(errno));
943     fclose(file); return tokv_error;
944   }
945   closeerrorfile(); eh.handling= tokv_word_errorstofile;
946   eh.file= file; eh.filename= xstrsave(cp);
947   return 0;
948 }
949
950 /* Directives for including other files or configuration data */
951
952 int dfi_includeuserrcfile(int dtoken) {
953   int r;
954
955   r= pa_mnl(); if (r) return r;
956   assert(userrcfile);
957   return parse_file(userrcfile,0);
958 }
959
960 int dfi_includeclientconfig(int dtoken) {
961   int r;
962
963   r= pa_mnl(); if (r) return r;
964   assert(overridedata);
965   return parse_string(overridedata,"<configuration override data>",0);
966 }
967
968 int df_include(int dtoken) {
969   const char *cp;
970   int r, found;
971
972   r= paa_1path(&cp); if (r) return r;
973   r= parse_file(cp,&found); if (r) return r;
974   if (found || dtoken == tokv_word_includeifexist) return 0;
975   parseerrprint(dtoken == tokv_word_includesysconfig ?
976                 "system configuration file `%s' does not exist" :
977                 "included file `%s' does not exist",
978                 cp);
979   return tokv_error;
980 }
981
982 int df_includedirectory(int dtoken) {
983   static char *buildbuf=0;
984   static int buildbuflen=0;
985   
986   int r, cpl, tel, c, found;
987   DIR *d;
988   struct dirent *de;
989   const char *p, *cp;
990   
991   r= paa_1path(&cp); if (r) return r;
992   d= opendir(cp);
993   if (!d) {
994     parseerrprint("unable to open directory `%s': %s",cp,strerror(errno));
995     return tokv_error;
996   }
997   cpl= strlen(cp);
998   while ((de= readdir(d))) {
999     tel= strlen(de->d_name);
1000     if (!tel) continue;
1001     p= de->d_name;
1002     if (!*p || !isalnum(*p)) continue;
1003     while ((c= *++p)) if (!(isalnum(c) || c=='-')) break;
1004     if (c) continue;
1005     if (makeroom(&buildbuf,&buildbuflen,cpl+1+tel+1))
1006       return stringoverflow("pathname in directory");
1007     snyprintf(buildbuf,buildbuflen,"%s/%s",cp,de->d_name);
1008     r= parse_file(buildbuf,&found); if (r) { closedir(d); return r; }
1009     if (!found) {
1010       parseerrprint("unable to open file `%s' in included directory `%s': %s",
1011                     de->d_name,cp,strerror(errno));
1012       closedir(d);
1013       return tokv_error;
1014     }
1015   }
1016   if (closedir(d)) {
1017     parseerrprint("error closing directory `%s': %s",cp,strerror(errno));
1018     return tokv_error;
1019   }
1020   return 0;
1021 }
1022
1023 int df_includelookup(int dtoken) {
1024   static char *buildbuf=0;
1025   int buildbuflen=0;
1026   
1027   char **parmvalues, **pp, *p, *q;
1028   const char *cp;
1029   struct stat stab;
1030   int r, done, thisdone, cpl, c;
1031
1032   r= pa_mwsp(); if (r) return r;
1033   r= pa_parameter(&parmvalues,0); if (r) return r;
1034   r= paa_1path(&cp); if (r) { freecharparray(parmvalues); return r; }
1035   if (stat(cp,&stab)) {
1036     parseerrprint("unable to access directory `%s': %s",cp,strerror(errno));
1037     freecharparray(parmvalues); return tokv_error;
1038   }
1039   if (!S_ISDIR(stab.st_mode)) {
1040     parseerrprint("object `%s' is not a directory or link to one",cp);
1041     freecharparray(parmvalues); return tokv_error;
1042   }
1043   done= 0;
1044   cpl= strlen(cp);
1045   if (!parmvalues[0]) {
1046     if (makeroom(&buildbuf,&buildbuflen,cpl+1+sizeof(NONEINCLUDELOOKUP)))
1047       return stringoverflow("pathname in directory for lookup of undefined parameter");
1048     snyprintf(buildbuf,buildbuflen,"%s/" NONEINCLUDELOOKUP,cp);
1049     r= parse_file(buildbuf,&thisdone);
1050     if (r) { freecharparray(parmvalues); return r; }
1051     if (thisdone) done= 1;
1052   } else {
1053     for (pp=parmvalues;
1054          *pp && (!done || dtoken == tokv_word_includelookupall);
1055          pp++) {
1056       if (makeroom(&buildbuf,&buildbuflen,
1057                    cpl+1+strlen(*pp)*2+3+sizeof(EMPTYINCLUDELOOKUP)+1))
1058         return stringoverflow("pathname in directory for lookup");
1059       strcpy(buildbuf,cp);
1060       p= *pp; q= buildbuf+cpl;
1061       *q++= '/';
1062       if (!*p) {
1063         strcpy(q,EMPTYINCLUDELOOKUP);
1064       } else {
1065         if (*p=='.') *q++= ':';
1066         while ((c= *p++)) {
1067           if (c=='/') { *q++= ':'; c='-'; }
1068           else if (c==':') { *q++= ':'; }
1069           *q++= c;
1070         }
1071         *q++= 0;
1072       }
1073       r= parse_file(buildbuf,&thisdone);
1074       if (r) { freecharparray(parmvalues); return r; }
1075       if (thisdone) done= 1;
1076     }
1077   }
1078   freecharparray(parmvalues);
1079   if (!done) {
1080     if (makeroom(&buildbuf,&buildbuflen,
1081                  cpl+1+sizeof(DEFAULTINCLUDELOOKUP)))
1082       return stringoverflow("pathname in directory for lookup of default");
1083     snyprintf(buildbuf,buildbuflen,"%s/" DEFAULTINCLUDELOOKUP,cp);
1084     r= parse_file(buildbuf,0); if (r) return r;
1085   }
1086   return 0;
1087 }
1088
1089 /* Control constructs */
1090
1091 int df_catchquit(int dtoken) {
1092   int r;
1093
1094   r= pa_mnl(); if (r) return r;
1095   r= parser(tokv_word_catchquit);
1096   if (r == tokv_quit || r == tokv_error) {
1097     if (r == tokv_error) {
1098       r= parse_string(RESET_CONFIGURATION,
1099                       "<builtin reset configuration (caught error)>",1);
1100       assert(!r);
1101     }
1102     r= skip(tokv_word_catchquit);
1103   }
1104   if (r & tokt_controlend) {
1105     assert(r == tokv_word_hctac);
1106     r= pa_mnl();
1107   }
1108   return r;
1109 }
1110
1111 int df_if(int dtoken) {
1112   int r, true, done;
1113   
1114   done= 0;
1115   do {
1116     r= pa_condition(&true); if (r) return r;
1117     if (!done && true) { r= parser(tokv_word_if); done= 1; }
1118     else { r= skip(tokv_word_if); }
1119     if (!(r & tokt_controlend)) return r;
1120   } while (r == tokv_word_elif);
1121   if (r == tokv_word_else) {
1122     r= pa_mnl(); if (r) return r;
1123     cstate->reportlineno= cstate->lineno;
1124     if (done) r= skip(tokv_word_if);
1125     else r= parser(tokv_word_if);
1126     if (!(r & tokt_controlend)) return r;
1127   }
1128   if (unexpected(r,tokv_word_fi,"`fi' to end `if'")) return tokv_error;
1129   return pa_mnl();
1130 }
1131
1132 int df_errorspush(int dt) {
1133   struct error_handling save;
1134   int r;
1135
1136   r= pa_mnl(); if (r) return r;
1137
1138   save= eh;
1139   eh.filekeep= 1;
1140
1141   r= parser(tokv_word_errorspush);
1142
1143   closeerrorfile();
1144   eh= save;
1145
1146   if (r & tokt_controlend) {
1147     assert(r == tokv_word_srorre);
1148     r= pa_mnl();
1149   }
1150   return r;
1151 }
1152
1153 /* Miscelleanous directives */
1154
1155 int df_cd(int dtoken) {
1156   const char *cp;
1157   int r;
1158
1159   r= paa_1path(&cp); if (r) return r;
1160   if (!chdir(cp)) return 0;
1161   parseerrprint("unable to change directory to `%s': %s",cp,strerror(errno));
1162   return tokv_error;
1163 }
1164
1165 int df_userrcfile(int dtoken) {
1166   const char *cp;
1167   int r;
1168
1169   r= paa_1path(&cp); if (r) return r;
1170   free(userrcfile); userrcfile= xstrsave(cp);
1171   return 0;
1172 }
1173
1174 int df_message(int dtoken) {
1175   const char *mp;
1176   int r;
1177
1178   r= paa_message(&mp); if (r) return r;
1179   parseerrprint("`message' directive: %s",mp);
1180   return 0;
1181 }
1182
1183 int df_error(int dtoken) {
1184   const char *mp;
1185   int r;
1186
1187   r= paa_message(&mp); if (r) return r;
1188   parseerrprint("`error' directive: %s",mp);
1189   return tokv_error;
1190 }
1191
1192 int df_eof(int dtoken) {
1193   int r;
1194
1195   r= pa_mnl(); if (r) return r;
1196   return tokv_eof;
1197 }
1198
1199 int df_quit(int dtoken) {
1200   int r;
1201
1202   r= pa_mnl(); if (r) return r;
1203   return tokv_quit;
1204 }
1205
1206 /*
1207  * Main parser routines
1208  */
1209       
1210 static void parser_push(struct parser_state *usestate,
1211                         const char *newfile,
1212                         const struct stat *newfilestab,
1213                         YY_BUFFER_STATE ybuf,
1214                         int isinternal) {
1215   usestate->lineno= 1;
1216   usestate->reportlineno= 1;
1217   usestate->filename= newfile;
1218   usestate->filestab= *newfilestab;
1219   usestate->notedreferer= 0;
1220   usestate->isinternal= isinternal;
1221   usestate->ybuf= ybuf;
1222   usestate->upstate= cstate;
1223
1224   cstate= usestate;
1225   yy_switch_to_buffer(ybuf);
1226 }
1227
1228 static void parser_pop(void) {
1229   struct parser_state *oldstate;
1230
1231   oldstate= cstate;
1232   cstate= cstate->upstate;
1233   if (cstate) yy_switch_to_buffer(cstate->ybuf);
1234   yy_delete_buffer(oldstate->ybuf);
1235 }
1236
1237 int parse_string(const char *string, const char *descrip, int isinternal) {
1238   /* Returns the same things as parser, except that tokv_eof is turned
1239    * into 0.  *string must be statically allocated or copied, so that
1240    * it is not overwritten while the parsing takes place (unlike with
1241    * parse_file).
1242    */
1243   static const struct stat blankstab;
1244   
1245   struct parser_state usestate;
1246   YY_BUFFER_STATE ybuf;
1247   int r;
1248
1249   ybuf= yy_scan_string(string);
1250   if (!ybuf) syscallerror("unable to create flex buffer for internal string");
1251   parser_push(&usestate,descrip,&blankstab,ybuf,isinternal);
1252   
1253   r= parser(0);
1254
1255   parser_pop();
1256   if (r == tokv_eof) r= 0;
1257   return r;
1258 }
1259
1260 static int parse_file(const char *string, int *didexist) {
1261   /* Returns the same things as parser, except that tokv_eof is turned
1262    * into 0.  If *didexist is 0 then errno will have been set.
1263    * *string will be copied by parse_file so it may be be overwritten
1264    * during the parsing (so, for example, yytext need not be copied).
1265    */
1266   static int fileparselevel= 0;
1267   
1268   struct parser_state usestate, *checkrecurse;
1269   YY_BUFFER_STATE ybuf;
1270   int r;
1271   FILE *file;
1272   char *filename;
1273   struct stat newstab;
1274
1275   if (fileparselevel >= MAX_INCLUDE_NEST) {
1276     parseerrprint("too many nested levels of included files");
1277     return tokv_error;
1278   }
1279   file= fopen(string,"r");
1280   if (!file) {
1281     if (errno == ENOENT) {
1282       if (didexist) *didexist= 0;
1283       return 0;
1284     }
1285     parseerrprint("unable to open config file `%s': %s",string,strerror(errno));
1286     return tokv_error;
1287   }
1288   r= fstat(fileno(file),&newstab); if (r) syscallerror("unable to fstat new file");
1289   for (checkrecurse= cstate; checkrecurse; checkrecurse= checkrecurse->upstate) {
1290     if (!checkrecurse->filestab.st_mode) continue;
1291     if (newstab.st_dev==checkrecurse->filestab.st_dev &&
1292         newstab.st_ino==checkrecurse->filestab.st_ino) {
1293       parseerrprint("recursion detected - config file `%s' calls itself",string);
1294       fclose(file);
1295       return tokv_error;
1296     }
1297   }
1298   
1299   if (didexist) *didexist= 1;
1300
1301   ybuf= yy_create_buffer(file,YY_BUF_SIZE);
1302   if (!ybuf) syscallerror("unable to create flex buffer for file");
1303   filename= xstrsave(string);
1304   parser_push(&usestate,filename,&newstab,ybuf,0);
1305   fileparselevel++;
1306   
1307   r= parser(0);
1308   if (ferror(file)) {
1309     parseerrprint("error reading configuration file `%s'",string);
1310     r= tokv_error;
1311   }
1312
1313   fileparselevel--;
1314   parser_pop();
1315   free(filename);
1316   fclose(file);
1317   if (r == tokv_eof) r= 0;
1318   return r;
1319 }
1320
1321 static int parser(int allowce) {
1322   /* Returns:
1323    *  an exception (error, eof or quit)
1324    *   then rest of `file' is uninteresting
1325    * or
1326    *  token if allowce was !0 and equal to token's controlend
1327    *   then rest of `file' (including rest of line with the
1328    *   controlend - even the whitespace) not scanned yet
1329    */
1330   int token, r;
1331
1332   for (;;) { /* loop over lines */
1333     cstate->reportlineno= cstate->lineno;
1334     do { token= yylex(); } while (token == tokv_lwsp);
1335     if (token & tokt_exception) {
1336       return token;
1337     } else if (token & tokt_controlend) {
1338       if (lr_controlend == allowce) return token;
1339       else return unexpected(token,-1,"directive (not this kind of"
1340                              " control structure end)");
1341     } else if (token & tokt_directive) {
1342       if ((token & tokt_internal) && !cstate->isinternal)
1343         return unexpected(token,-1,"published directive, not internal-use-only one");
1344       r= (lr_dir)(token); if (r) { assert(r & tokt_exception); return r; }
1345     } else if (token == tokv_newline) {
1346       /* ignore blank lines (and comment-only lines) */
1347     } else {
1348       return unexpected(token,-1,"directive");
1349     }
1350   }
1351 }