lib/cf.c

   1 /*
   2     ashd - A Sane HTTP Daemon
   3     Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>
   4
   5     This program is free software: you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation, either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24 #include <glob.h>
  25 #include <libgen.h>
  26 #include <sys/socket.h>
  27 #include <time.h>
  28 #include <errno.h>
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33 #include <utils.h>
  34 #include <cf.h>
  35 #include <mt.h>
  36 #include <proc.h>
  37 #include <log.h>
  38
  39 #define CH_SOCKET 0
  40 #define CH_FORK 1
  41
  42 struct stdchild {
  43     int type;
  44     char **argv;
  45     char **envp;
  46     int fd;
  47     int agains;
  48     time_t lastrep;
  49 };
  50
  51 static int parsefile(struct cfstate *s, FILE *in);
  52 static void stdmerge(struct child *old, struct child *new);
  53 static int stdhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata);
  54 static void stddestroy(struct child *ch);
  55
  56 static int doinclude(struct cfstate *s, char *spec)
  57 {
  58     int rv, i;
  59     FILE *inc;
  60     glob_t globm;
  61     char *fbk, *dir, *fspec;
  62
  63     rv = 0;
  64     fbk = s->file;
  65     if(spec[0] == '/') {
  66         fspec = spec;
  67     } else {
  68         dir = sstrdup(fbk);
  69         fspec = sprintf3("%s/%s", dirname(dir), spec);
  70         free(dir);
  71     }
  72     if(glob(fspec, 0, NULL, &globm))
  73         return(0);
  74     for(i = 0; i < globm.gl_pathc; i++) {
  75         if((inc = fopen(globm.gl_pathv[i], "r")) != NULL) {
  76             s->file = globm.gl_pathv[i];
  77             if(parsefile(s, inc)) {
  78                 fclose(inc);
  79                 rv = 1;
  80                 goto out;
  81             }
  82             fclose(inc);
  83             inc = NULL;
  84         }
  85     }
  86
  87 out:
  88     globfree(&globm);
  89     s->file = fbk;
  90     return(rv);
  91 }
  92
  93 static int parsefile(struct cfstate *s, FILE *in)
  94 {
  95     int i;
  96     char line[1024];
  97     int eof, argc;
  98     int ind, indst[80], indl;
  99     char *p, **w;
 100
 101     s->lno = 0;
 102     indst[indl = 0] = 0;
 103     eof = 0;
 104     while(1) {
 105         if(fgets(line, sizeof(line), in) == NULL) {
 106             eof = 1;
 107             line[0] = 0;
 108         }
 109         s->lno++;
 110         if(line[0]) {
 111             for(p = line + strlen(line) - 1; p >= line; p--) {
 112                 if(isspace(*p))
 113                     *p = 0;
 114                 else
 115                     break;
 116             }
 117         }
 118         for(ind = 0, p = line; *p; p++) {
 119             if(*p == ' ') {
 120                 ind++;
 121             } else if(*p == '\t') {
 122                 ind = ind - (ind % 8) + 8;
 123             } else {
 124                 break;
 125             }
 126         }
 127         if(!eof && (!*p || (*p == '#')))
 128             continue;
 129
 130     reindent:
 131         if(ind > indst[indl]) {
 132             indst[++indl] = ind;
 133             if(!s->expstart) {
 134                 s->res = tokenize("start");
 135                 if(yield())
 136                     return(1);
 137             } else {
 138                 s->expstart = 0;
 139             }
 140         } else {
 141             if(s->expstart) {
 142                 s->res = tokenize("end");
 143                 if(yield())
 144                     return(1);
 145                 s->expstart = 0;
 146             }
 147             while(ind < indst[indl]) {
 148                 indl--;
 149                 s->res = tokenize("end");
 150                 if(yield())
 151                     return(1);
 152             }
 153             if(ind > indst[indl]) {
 154                 flog(LOG_WARNING, "%s:%i: unexpected indentation level", s->file, s->lno);
 155                 goto reindent;
 156             }
 157         }
 158
 159         if(eof)
 160             return(0);
 161
 162         argc = calen(w = tokenize(line));
 163         if(argc < 1) {
 164             /* Shouldn't happen, but... */
 165             freeca(w);
 166             continue;
 167         }
 168
 169         if(indl == 0) {
 170             if(!strcmp(w[0], "include")) {
 171                 for(i = 1; i < argc; i++) {
 172                     if(doinclude(s, w[i])) {
 173                         freeca(w);
 174                         return(1);
 175                     }
 176                 }
 177                 freeca(w);
 178                 continue;
 179             }
 180         }
 181
 182         if(!strcmp(w[0], "start") ||
 183            !strcmp(w[0], "end") ||
 184            !strcmp(w[0], "eof")) {
 185             flog(LOG_WARNING, "%s:%i: illegal directive: %s", s->file, s->lno, w[0]);
 186         } else {
 187             s->res = w;
 188             if(yield())
 189                 return(1);
 190         }
 191     }
 192 }
 193
 194 static void parsefn(struct muth *mt, va_list args)
 195 {
 196     vavar(struct cfstate *, s);
 197     vavar(FILE *, in);
 198     vavar(char *, file);
 199
 200     s->file = sstrdup(file);
 201     if(parsefile(s, in))
 202         goto out;
 203     do {
 204         s->res = tokenize("eof");
 205     } while(!yield());
 206
 207 out:
 208     free(s->file);
 209 }
 210
 211 char **getcfline(struct cfstate *s)
 212 {
 213     freeca(s->argv);
 214     if(s->res == NULL)
 215         resume(s->pf, 0);
 216     s->argc = calen(s->argv = s->res);
 217     s->res = NULL;
 218     return(s->argv);
 219 }
 220
 221 struct cfstate *mkcfparser(FILE *in, char *name)
 222 {
 223     struct cfstate *s;
 224
 225     omalloc(s);
 226     s->pf = mustart(parsefn, s, in, name);
 227     return(s);
 228 }
 229
 230 void freecfparser(struct cfstate *s)
 231 {
 232     resume(s->pf, -1);
 233     freeca(s->argv);
 234     freeca(s->res);
 235     free(s);
 236 }
 237
 238 char *findstdconf(char *name)
 239 {
 240     char *home, *path, *p, *p2, *t;
 241
 242     if((home = getenv("HOME")) != NULL) {
 243         if(!access(t = sprintf2("%s/.ashd/etc/%s", home, name), R_OK))
 244             return(t);
 245         free(t);
 246     }
 247     if((path = getenv("PATH")) != NULL) {
 248         path = sstrdup(path);
 249         for(p = strtok(path, ":"); p != NULL; p = strtok(NULL, ":")) {
 250             if((p2 = strrchr(p, '/')) == NULL)
 251                 continue;
 252             *p2 = 0;
 253             if(!access(t = sprintf2("%s/etc/%s", p, name), R_OK)) {
 254                 free(path);
 255                 return(t);
 256             }
 257             free(t);
 258         }
 259         free(path);
 260     }
 261     return(NULL);
 262 }
 263
 264 struct child *newchild(char *name, struct chandler *iface, void *pdata)
 265 {
 266     struct child *ch;
 267
 268     omalloc(ch);
 269     ch->name = sstrdup(name);
 270     ch->iface = iface;
 271     ch->pdata = pdata;
 272     return(ch);
 273 }
 274
 275 void freechild(struct child *ch)
 276 {
 277     if(ch->iface->destroy != NULL)
 278         ch->iface->destroy(ch);
 279     if(ch->name != NULL)
 280         free(ch->name);
 281     free(ch);
 282 }
 283
 284 void mergechildren(struct child *dst, struct child *src)
 285 {
 286     struct child *ch1, *ch2;
 287
 288     for(ch1 = dst; ch1 != NULL; ch1 = ch1->next) {
 289         for(ch2 = src; ch2 != NULL; ch2 = ch2->next) {
 290             if(ch1->iface->merge && !strcmp(ch1->name, ch2->name)) {
 291                 ch1->iface->merge(ch1, ch2);
 292                 break;
 293             }
 294         }
 295     }
 296 }
 297
 298 void skipcfblock(struct cfstate *s)
 299 {
 300     char **w;
 301
 302     while(1) {
 303         w = getcfline(s);
 304         if(!strcmp(w[0], "end") || !strcmp(w[0], "eof"))
 305             return;
 306     }
 307 }
 308
 309 static struct chandler stdhandler = {
 310     .handle = stdhandle,
 311     .merge = stdmerge,
 312     .destroy = stddestroy,
 313 };
 314
 315 static char **expandargs(struct stdchild *sd)
 316 {
 317     int i;
 318     char **ret, *p, *p2, *p3, *np, *env;
 319     struct charbuf exp;
 320
 321     ret = szmalloc(sizeof(*ret) * (calen(sd->argv) + 1));
 322     bufinit(exp);
 323     for(i = 0; sd->argv[i] != NULL; i++) {
 324         if((p = strchr(sd->argv[i], '$')) == NULL) {
 325             ret[i] = sstrdup(sd->argv[i]);
 326         } else {
 327             exp.d = 0;
 328             for(p2 = sd->argv[i]; p != NULL; p2 = np, p = strchr(np, '$')) {
 329                 bufcat(exp, p2, p - p2);
 330                 if(p[1] == '{') {
 331                     if((p3 = strchr((p += 2), '}')) == NULL) {
 332                         np = p;
 333                         break;
 334                     }
 335                     np = p3 + 1;
 336                 } else {
 337                     for(p3 = ++p; *p3; p3++) {
 338                         if(!(((*p3 >= 'a') && (*p3 <= 'z')) ||
 339                              ((*p3 >= 'A') && (*p3 <= 'Z')) ||
 340                              ((*p3 >= '0') && (*p3 <= '9')) ||
 341                              (*p3 == '_'))) {
 342                             break;
 343                         }
 344                     }
 345                     np = p3;
 346                 }
 347                 char temp[(p3 - p) + 1];
 348                 memcpy(temp, p, p3 - p);
 349                 temp[p3 - p] = 0;
 350                 if((env = getenv(temp)) != NULL)
 351                     bufcatstr(exp, env);
 352             }
 353             bufcatstr2(exp, np);
 354             ret[i] = sstrdup(exp.b);
 355         }
 356     }
 357     ret[i] = NULL;
 358     buffree(exp);
 359     return(ret);
 360 }
 361
 362 struct sidata {
 363     struct stdchild *sd;
 364     void (*sinit)(void *);
 365     void *sdata;
 366 };
 367
 368 static void stdinit(void *data)
 369 {
 370     struct sidata *d = data;
 371     int i;
 372
 373     for(i = 0; d->sd->envp[i]; i += 2)
 374         putenv(sprintf2("%s=%s", d->sd->envp[i], d->sd->envp[i + 1]));
 375     if(d->sinit != NULL)
 376         d->sinit(d->sdata);
 377 }
 378
 379 static int stdhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *sdata)
 380 {
 381     struct stdchild *sd = ch->pdata;
 382     int serr;
 383     char **args;
 384     struct sidata idat;
 385
 386     if(sd->type == CH_SOCKET) {
 387         idat = (struct sidata) {.sd = sd, .sinit = chinit, .sdata = sdata};
 388         if(sd->fd < 0) {
 389             args = expandargs(sd);
 390             sd->fd = stdmkchild(args, stdinit, &idat);
 391             freeca(args);
 392         }
 393         if(sendreq2(sd->fd, req, fd, MSG_NOSIGNAL | MSG_DONTWAIT)) {
 394             serr = errno;
 395             if((serr == EPIPE) || (serr == ECONNRESET)) {
 396                 /* Assume that the child has crashed and restart it. */
 397                 close(sd->fd);
 398                 args = expandargs(sd);
 399                 sd->fd = stdmkchild(args, stdinit, &idat);
 400                 freeca(args);
 401                 if(!sendreq2(sd->fd, req, fd, MSG_NOSIGNAL | MSG_DONTWAIT))
 402                     goto ok;
 403                 serr = errno;
 404             }
 405             if(serr == EAGAIN) {
 406                 if(sd->agains++ == 0) {
 407                     flog(LOG_WARNING, "request to child %s denied due to buffer overload", ch->name);
 408                     sd->lastrep = time(NULL);
 409                 }
 410             } else {
 411                 flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(serr));
 412                 close(sd->fd);
 413                 sd->fd = -1;
 414             }
 415             return(-1);
 416         }
 417     ok:
 418         if((sd->agains > 0) && ((time(NULL) - sd->lastrep) > 10)) {
 419             flog(LOG_WARNING, "%i requests to child %s were denied due to buffer overload", sd->agains, ch->name);
 420             sd->agains = 0;
 421         }
 422     } else if(sd->type == CH_FORK) {
 423         args = expandargs(sd);
 424         if(stdforkserve(args, req, fd, chinit, sdata) < 0) {
 425             freeca(args);
 426             return(-1);
 427         }
 428         freeca(args);
 429     }
 430     return(0);
 431 }
 432
 433 static void stdmerge(struct child *dst, struct child *src)
 434 {
 435     struct stdchild *od, *nd;
 436
 437     if(src->iface == &stdhandler) {
 438         nd = dst->pdata;
 439         od = src->pdata;
 440         nd->fd = od->fd;
 441         od->fd = -1;
 442     }
 443 }
 444
 445 static void stddestroy(struct child *ch)
 446 {
 447     struct stdchild *d = ch->pdata;
 448
 449     if(d->fd >= 0)
 450         close(d->fd);
 451     if(d->argv)
 452         freeca(d->argv);
 453     if(d->envp)
 454         freeca(d->envp);
 455     free(d);
 456 }
 457
 458 struct child *parsechild(struct cfstate *s)
 459 {
 460     struct child *ch;
 461     struct stdchild *d;
 462     struct charvbuf envbuf;
 463     int i;
 464     int sl;
 465
 466     sl = s->lno;
 467     if(!strcmp(s->argv[0], "child")) {
 468         s->expstart = 1;
 469         if(s->argc < 2) {
 470             flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
 471             skipcfblock(s);
 472             return(NULL);
 473         }
 474         ch = newchild(s->argv[1], &stdhandler, omalloc(d));
 475         d->type = CH_SOCKET;
 476     } else if(!strcmp(s->argv[0], "fchild")) {
 477         s->expstart = 1;
 478         if(s->argc < 2) {
 479             flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
 480             skipcfblock(s);
 481             return(NULL);
 482         }
 483         ch = newchild(s->argv[1], &stdhandler, omalloc(d));
 484         d->type = CH_FORK;
 485     } else {
 486         return(NULL);
 487     }
 488     d->fd = -1;
 489
 490     bufinit(envbuf);
 491     while(1) {
 492         getcfline(s);
 493         if(!strcmp(s->argv[0], "exec")) {
 494             if(s->argc < 2) {
 495                 flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", s->file, s->lno);
 496                 continue;
 497             }
 498             d->argv = szmalloc(sizeof(*d->argv) * s->argc);
 499             for(i = 0; i < s->argc - 1; i++)
 500                 d->argv[i] = sstrdup(s->argv[i + 1]);
 501         } else if(!strcmp(s->argv[0], "env")) {
 502             if(s->argc < 3) {
 503                 flog(LOG_WARNING, "%s:%i: too few parameters to `env'", s->file, s->lno);
 504                 continue;
 505             }
 506             bufadd(envbuf, sstrdup(s->argv[1]));
 507             bufadd(envbuf, sstrdup(s->argv[2]));
 508         } else if(!strcmp(s->argv[0], "end") || !strcmp(s->argv[0], "eof")) {
 509             break;
 510         } else {
 511             flog(LOG_WARNING, "%s:%i: unknown directive `%s' in child declaration", s->file, s->lno, s->argv[0]);
 512         }
 513     }
 514     bufadd(envbuf, NULL);
 515     d->envp = envbuf.b;
 516     if(d->argv == NULL) {
 517         flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", s->file, sl, ch->name);
 518         freechild(ch);
 519         return(NULL);
 520     }
 521     return(ch);
 522 }
 523
 524 int childhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata)
 525 {
 526     return(ch->iface->handle(ch, req, fd, chinit, idata));
 527 }