src/patplex.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 <string.h>
  22 #include <unistd.h>
  23 #include <signal.h>
  24 #include <errno.h>
  25 #include <ctype.h>
  26 #include <regex.h>
  27 #include <sys/wait.h>
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32 #include <utils.h>
  33 #include <log.h>
  34 #include <req.h>
  35 #include <proc.h>
  36 #include <resp.h>
  37 #include <cf.h>
  38
  39 #define PAT_REST 0
  40 #define PAT_URL 1
  41 #define PAT_METHOD 2
  42 #define PAT_HEADER 3
  43 #define PAT_ALL 4
  44 #define PAT_DEFAULT 5
  45
  46 #define PATFL_MSS 1
  47 #define PATFL_UNQ 2
  48
  49 struct config {
  50     struct child *children;
  51     struct pattern *patterns;
  52 };
  53
  54 struct rule {
  55     int type;
  56     int fl;
  57     char *header;
  58     regex_t *pattern;
  59 };
  60
  61 struct headmod {
  62     struct headmod *next;
  63     char *name, *value;
  64 };
  65
  66 struct pattern {
  67     struct pattern *next;
  68     struct headmod *headers;
  69     char *childnm;
  70     struct rule **rules;
  71     char *restpat;
  72 };
  73
  74 static struct config *gconfig, *lconfig;
  75 static volatile int reload = 0;
  76
  77 static void freepattern(struct pattern *pat)
  78 {
  79     struct rule **rule;
  80     struct headmod *head;
  81
  82     for(rule = pat->rules; *rule; rule++) {
  83         if((*rule)->header != NULL)
  84             free((*rule)->header);
  85         if((*rule)->pattern != NULL) {
  86             regfree((*rule)->pattern);
  87             free((*rule)->pattern);
  88         }
  89         free(*rule);
  90     }
  91     while((head = pat->headers) != NULL) {
  92         pat->headers = head->next;
  93         free(head->name);
  94         free(head->value);
  95         free(head);
  96     }
  97     if(pat->childnm != NULL)
  98         free(pat->childnm);
  99     free(pat);
 100 }
 101
 102 static void freeconfig(struct config *cf)
 103 {
 104     struct child *ch, *nch;
 105     struct pattern *pat, *npat;
 106
 107     for(ch = cf->children; ch != NULL; ch = nch) {
 108         nch = ch->next;
 109         freechild(ch);
 110     }
 111     for(pat = cf->patterns; pat != NULL; pat = npat) {
 112         npat = pat->next;
 113         freepattern(pat);
 114     }
 115     free(cf);
 116 }
 117
 118 static struct child *getchild(struct config *cf, char *name)
 119 {
 120     struct child *ch;
 121
 122     for(ch = cf->children; ch; ch = ch->next) {
 123         if(!strcmp(ch->name, name))
 124             break;
 125     }
 126     return(ch);
 127 }
 128
 129 static struct rule *newrule(struct pattern *pat)
 130 {
 131     int i;
 132     struct rule *rule;
 133
 134     for(i = 0; pat->rules[i]; i++);
 135     pat->rules = srealloc(pat->rules, sizeof(*pat->rules) * (i + 2));
 136     rule = pat->rules[i] = szmalloc(sizeof(*rule));
 137     pat->rules[i + 1] = NULL;
 138     return(rule);
 139 }
 140
 141 static struct pattern *newpattern(void)
 142 {
 143     struct pattern *pat;
 144
 145     omalloc(pat);
 146     pat->rules = szmalloc(sizeof(*pat->rules));
 147     return(pat);
 148 }
 149
 150 static regex_t *regalloc(char *regex, int flags)
 151 {
 152     regex_t *ret;
 153     int res;
 154     char errbuf[256];
 155
 156     omalloc(ret);
 157     if((res = regcomp(ret, regex, flags | REG_EXTENDED)) != 0) {
 158         regerror(res, ret, errbuf, sizeof(errbuf));
 159         flog(LOG_WARNING, "%s: %s", regex, errbuf);
 160         free(ret);
 161         return(NULL);
 162     }
 163     return(ret);
 164 }
 165
 166 static struct pattern *parsepattern(struct cfstate *s)
 167 {
 168     struct pattern *pat;
 169     int sl;
 170     struct rule *rule;
 171     struct headmod *head;
 172     regex_t *regex;
 173     int rxfl;
 174
 175     if(!strcmp(s->argv[0], "match")) {
 176         s->expstart = 1;
 177         pat = newpattern();
 178     } else {
 179         return(NULL);
 180     }
 181
 182     sl = s->lno;
 183     while(1) {
 184         getcfline(s);
 185         if(!strcmp(s->argv[0], "point") ||
 186            !strcmp(s->argv[0], "url") ||
 187            !strcmp(s->argv[0], "method")) {
 188             if(s->argc < 2) {
 189                 flog(LOG_WARNING, "%s:%i: missing pattern for `%s' match", s->file, s->lno, s->argv[0]);
 190                 continue;
 191             }
 192             rxfl = 0;
 193             if(s->argc >= 3) {
 194                 if(strchr(s->argv[2], 'i'))
 195                     rxfl |= REG_ICASE;
 196             }
 197             if((regex = regalloc(s->argv[1], rxfl)) == NULL) {
 198                 flog(LOG_WARNING, "%s:%i: invalid regex for `%s' match", s->file, s->lno, s->argv[0]);
 199                 continue;
 200             }
 201             rule = newrule(pat);
 202             if(!strcmp(s->argv[0], "point"))
 203                 rule->type = PAT_REST;
 204             else if(!strcmp(s->argv[0], "url"))
 205                 rule->type = PAT_URL;
 206             else if(!strcmp(s->argv[0], "method"))
 207                 rule->type = PAT_METHOD;
 208             rule->pattern = regex;
 209             if(s->argc >= 3) {
 210                 if(strchr(s->argv[2], 's'))
 211                     rule->fl |= PATFL_MSS;
 212                 if(strchr(s->argv[2], 'q'))
 213                     rule->fl |= PATFL_UNQ;
 214             }
 215         } else if(!strcmp(s->argv[0], "header")) {
 216             if(s->argc < 3) {
 217                 flog(LOG_WARNING, "%s:%i: missing header name or pattern for `header' match", s->file, s->lno);
 218                 continue;
 219             }
 220             rxfl = 0;
 221             if(s->argc >= 4) {
 222                 if(strchr(s->argv[3], 'i'))
 223                     rxfl |= REG_ICASE;
 224             }
 225             if((regex = regalloc(s->argv[2], rxfl)) == NULL) {
 226                 flog(LOG_WARNING, "%s:%i: invalid regex for `header' match", s->file, s->lno);
 227                 continue;
 228             }
 229             rule = newrule(pat);
 230             rule->type = PAT_HEADER;
 231             rule->header = sstrdup(s->argv[1]);
 232             rule->pattern = regex;
 233             if(s->argc >= 4) {
 234                 if(strchr(s->argv[3], 's'))
 235                     rule->fl |= PATFL_MSS;
 236             }
 237         } else if(!strcmp(s->argv[0], "all")) {
 238             newrule(pat)->type = PAT_ALL;
 239         } else if(!strcmp(s->argv[0], "default")) {
 240             newrule(pat)->type = PAT_DEFAULT;
 241         } else if(!strcmp(s->argv[0], "handler")) {
 242             if(s->argc < 2) {
 243                 flog(LOG_WARNING, "%s:%i: missing child name for `handler' directive", s->file, s->lno);
 244                 continue;
 245             }
 246             if(pat->childnm != NULL)
 247                 free(pat->childnm);
 248             pat->childnm = sstrdup(s->argv[1]);
 249         } else if(!strcmp(s->argv[0], "restpat")) {
 250             if(s->argc < 2) {
 251                 flog(LOG_WARNING, "%s:%i: missing pattern for `restpat' directive", s->file, s->lno);
 252                 continue;
 253             }
 254             if(pat->restpat != NULL)
 255                 free(pat->restpat);
 256             pat->restpat = sstrdup(s->argv[1]);
 257         } else if(!strcmp(s->argv[0], "set") || !strcmp(s->argv[0], "xset")) {
 258             if(s->argc < 3) {
 259                 flog(LOG_WARNING, "%s:%i: missing header name or pattern for `%s' directive", s->file, s->lno, s->argv[0]);
 260                 continue;
 261             }
 262             omalloc(head);
 263             if(!strcmp(s->argv[0], "xset"))
 264                 head->name = sprintf2("X-Ash-%s", s->argv[1]);
 265             else
 266                 head->name = sstrdup(s->argv[1]);
 267             head->value = sstrdup(s->argv[2]);
 268             head->next = pat->headers;
 269             pat->headers = head;
 270         } else if(!strcmp(s->argv[0], "end") || !strcmp(s->argv[0], "eof")) {
 271             break;
 272         } else {
 273             flog(LOG_WARNING, "%s:%i: unknown directive `%s' in pattern declaration", s->file, s->lno, s->argv[0]);
 274         }
 275     }
 276
 277     if(pat->rules[0] == NULL) {
 278         flog(LOG_WARNING, "%s:%i: missing rules in match declaration", s->file, sl);
 279         freepattern(pat);
 280         return(NULL);
 281     }
 282     if(pat->childnm == NULL) {
 283         flog(LOG_WARNING, "%s:%i: missing handler in match declaration", s->file, sl);
 284         freepattern(pat);
 285         return(NULL);
 286     }
 287     return(pat);
 288 }
 289
 290 static struct config *readconfig(char *filename)
 291 {
 292     struct cfstate *s;
 293     struct config *cf;
 294     struct child *ch;
 295     struct pattern *pat;
 296     FILE *in;
 297
 298     if((in = fopen(filename, "r")) == NULL) {
 299         flog(LOG_WARNING, "%s: %s", filename, strerror(errno));
 300         return(NULL);
 301     }
 302     s = mkcfparser(in, filename);
 303     omalloc(cf);
 304
 305     while(1) {
 306         getcfline(s);
 307         if((ch = parsechild(s)) != NULL) {
 308             ch->next = cf->children;
 309             cf->children = ch;
 310         } else if((pat = parsepattern(s)) != NULL) {
 311             pat->next = cf->patterns;
 312             cf->patterns = pat;
 313         } else if(!strcmp(s->argv[0], "eof")) {
 314             break;
 315         } else {
 316             flog(LOG_WARNING, "%s:%i: unknown directive `%s'", s->file, s->lno, s->argv[0]);
 317         }
 318     }
 319
 320     freecfparser(s);
 321     fclose(in);
 322     return(cf);
 323 }
 324
 325 static void exprestpat(struct hthead *req, struct pattern *pat, char **mstr)
 326 {
 327     char *p, *p2, *hdr;
 328     int mc;
 329     struct charbuf buf;
 330
 331     if(mstr == NULL)
 332         mc = 0;
 333     else
 334         for(mc = 0; mstr[mc]; mc++);
 335     bufinit(buf);
 336     for(p = pat->restpat; *p; ) {
 337         if(*p == '$') {
 338             p++;
 339             if((*p >= '0') && (*p <= '9')) {
 340                 if(*p - '0' < mc)
 341                     bufcatstr(buf, mstr[*p - '0']);
 342                 p++;
 343             } else if(*p == '_') {
 344                 bufcatstr(buf, req->rest);
 345                 p++;
 346             } else if(*p == '$') {
 347                 bufadd(buf, '$');
 348                 p++;
 349             } else if(*p == '{') {
 350                 if((p2 = strchr(p, '}')) == NULL) {
 351                     p++;
 352                 } else {
 353                     hdr = getheader(req, sprintf3("%.*s", p2 - p - 1, p + 1));
 354                     if(hdr)
 355                         bufcatstr(buf, hdr);
 356                 }
 357             } else if(!*p) {
 358             }
 359         } else {
 360             bufadd(buf, *(p++));
 361         }
 362     }
 363     bufadd(buf, 0);
 364     replrest(req, buf.b);
 365     buffree(buf);
 366 }
 367
 368 static void qoffsets(char *buf, int *obuf, char *pstr, int unquote)
 369 {
 370     int i, o, d1, d2;
 371
 372     if(unquote) {
 373         i = o = 0;
 374         while(pstr[i]) {
 375             obuf[o] = i;
 376             if((pstr[i] == '%') && ((d1 = hexdigit(pstr[i + 1])) >= 0) && ((d2 = hexdigit(pstr[i + 2])) >= 0)) {
 377                 buf[o] = (d1 << 4) | d2;
 378                 i += 3;
 379             } else {
 380                 buf[o] = pstr[i];
 381                 i++;
 382             }
 383             o++;
 384         }
 385         buf[o] = 0;
 386         obuf[o] = i;
 387     } else {
 388         for(i = 0; pstr[i]; i++) {
 389             buf[i] = pstr[i];
 390             obuf[i] = i;
 391         }
 392         buf[i] = 0;
 393         obuf[i] = i;
 394     }
 395 }
 396
 397 static struct pattern *findmatch(struct config *cf, struct hthead *req, int trydefault)
 398 {
 399     int i, o;
 400     struct pattern *pat;
 401     struct rule *rule;
 402     int rmo;
 403     regex_t *rx;
 404     char *pstr;
 405     char **mstr;
 406     regmatch_t gr[10];
 407
 408     mstr = NULL;
 409     for(pat = cf->patterns; pat != NULL; pat = pat->next) {
 410         rmo = -1;
 411         for(i = 0; (rule = pat->rules[i]) != NULL; i++) {
 412             rx = NULL;
 413             if(rule->type == PAT_REST) {
 414                 rx = rule->pattern;
 415                 pstr = req->rest;
 416             } else if(rule->type == PAT_URL) {
 417                 rx = rule->pattern;
 418                 pstr = req->url;
 419             } else if(rule->type == PAT_METHOD) {
 420                 rx = rule->pattern;
 421                 pstr = req->method;
 422             } else if(rule->type == PAT_HEADER) {
 423                 rx = rule->pattern;
 424                 if(!(pstr = getheader(req, rule->header)))
 425                     break;
 426             }
 427             if(rx != NULL) {
 428                 char pbuf[strlen(pstr) + 1];
 429                 int  obuf[strlen(pstr) + 1];
 430                 qoffsets(pbuf, obuf, pstr, !!(rule->fl & PATFL_UNQ));
 431                 if(regexec(rx, pbuf, 10, gr, 0))
 432                     break;
 433                 else if(rule->type == PAT_REST)
 434                     rmo = obuf[gr[0].rm_eo];
 435                 if(rule->fl & PATFL_MSS) {
 436                     if(mstr) {
 437                         flog(LOG_WARNING, "two pattern rules marked with `s' flag found (for handler %s)", pat->childnm);
 438                         freeca(mstr);
 439                     }
 440                     for(o = 0; o < 10; o++) {
 441                         if(gr[o].rm_so < 0)
 442                             break;
 443                     }
 444                     mstr = szmalloc((o + 1) * sizeof(*mstr));
 445                     for(o = 0; o < 10; o++) {
 446                         if(gr[o].rm_so < 0)
 447                             break;
 448                         mstr[o] = smalloc(obuf[gr[o].rm_eo] - obuf[gr[o].rm_so] + 1);
 449                         memcpy(mstr[o], pstr + obuf[gr[o].rm_so], obuf[gr[o].rm_eo] - obuf[gr[o].rm_so]);
 450                         mstr[o][obuf[gr[o].rm_eo] - obuf[gr[o].rm_so]] = 0;
 451                     }
 452                 }
 453             } else if(rule->type == PAT_ALL) {
 454             } else if(rule->type == PAT_DEFAULT) {
 455                 if(!trydefault)
 456                     break;
 457             }
 458         }
 459         if(!rule) {
 460             if(pat->restpat) {
 461                 exprestpat(req, pat, mstr);
 462             } else if(rmo != -1) {
 463                 replrest(req, req->rest + rmo);
 464             }
 465             if(mstr)
 466                 freeca(mstr);
 467             return(pat);
 468         }
 469         if(mstr) {
 470             freeca(mstr);
 471             mstr = NULL;
 472         }
 473     }
 474     return(NULL);
 475 }
 476
 477 static void childerror(struct hthead *req, int fd)
 478 {
 479     if(errno == EAGAIN)
 480         simpleerror(fd, 500, "Server Error", "The request handler is overloaded.");
 481     else
 482         simpleerror(fd, 500, "Server Error", "The request handler crashed.");
 483 }
 484
 485 static void serve(struct hthead *req, int fd)
 486 {
 487     struct pattern *pat;
 488     struct headmod *head;
 489     struct child *ch;
 490
 491     pat = NULL;
 492     if(pat == NULL)
 493         pat = findmatch(lconfig, req, 0);
 494     if(pat == NULL)
 495         pat = findmatch(lconfig, req, 1);
 496     if(gconfig != NULL) {
 497         if(pat == NULL)
 498             pat = findmatch(gconfig, req, 0);
 499         if(pat == NULL)
 500             pat = findmatch(gconfig, req, 1);
 501     }
 502     if(pat == NULL) {
 503         simpleerror(fd, 404, "Not Found", "The requested resource could not be found on this server.");
 504         return;
 505     }
 506     ch = NULL;
 507     if(ch == NULL)
 508         ch = getchild(lconfig, pat->childnm);
 509     if(gconfig != NULL) {
 510         if(ch == NULL)
 511             ch = getchild(gconfig, pat->childnm);
 512     }
 513     if(ch == NULL) {
 514         flog(LOG_ERR, "child %s requested, but was not declared", pat->childnm);
 515         simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", pat->childnm);
 516         return;
 517     }
 518
 519     for(head = pat->headers; head != NULL; head = head->next) {
 520         headrmheader(req, head->name);
 521         headappheader(req, head->name, head->value);
 522     }
 523     if(childhandle(ch, req, fd, NULL, NULL))
 524         childerror(req, fd);
 525 }
 526
 527 static void reloadconf(char *nm)
 528 {
 529     struct config *cf;
 530
 531     if((cf = readconfig(nm)) == NULL) {
 532         flog(LOG_WARNING, "could not reload configuration file `%s'", nm);
 533         return;
 534     }
 535     mergechildren(cf->children, lconfig->children);
 536     freeconfig(lconfig);
 537     lconfig = cf;
 538 }
 539
 540 static void chldhandler(int sig)
 541 {
 542     pid_t pid;
 543     int st;
 544
 545     while((pid = waitpid(-1, &st, WNOHANG)) > 0) {
 546         if(WCOREDUMP(st))
 547             flog(LOG_WARNING, "child process %i dumped core", pid);
 548     }
 549 }
 550
 551 static void sighandler(int sig)
 552 {
 553     if(sig == SIGHUP)
 554         reload = 1;
 555 }
 556
 557 static void usage(FILE *out)
 558 {
 559     fprintf(out, "usage: patplex [-hN] CONFIGFILE\n");
 560 }
 561
 562 int main(int argc, char **argv)
 563 {
 564     int c;
 565     int nodef;
 566     char *gcf, *lcf;
 567     struct hthead *req;
 568     int fd;
 569
 570     nodef = 0;
 571     while((c = getopt(argc, argv, "hN")) >= 0) {
 572         switch(c) {
 573         case 'h':
 574             usage(stdout);
 575             exit(0);
 576         case 'N':
 577             nodef = 1;
 578             break;
 579         default:
 580             usage(stderr);
 581             exit(1);
 582         }
 583     }
 584     if(argc - optind < 1) {
 585         usage(stderr);
 586         exit(1);
 587     }
 588     if(!nodef) {
 589         if((gcf = findstdconf("ashd/patplex.rc")) != NULL) {
 590             gconfig = readconfig(gcf);
 591             free(gcf);
 592         }
 593     }
 594     if((strchr(lcf = argv[optind], '/')) == NULL) {
 595         if((lcf = findstdconf(sprintf3("ashd/%s", lcf))) == NULL) {
 596             flog(LOG_ERR, "could not find requested configuration file `%s'", argv[optind]);
 597             exit(1);
 598         }
 599     }
 600     if((lconfig = readconfig(lcf)) == NULL) {
 601         flog(LOG_ERR, "could not read `%s'", lcf);
 602         exit(1);
 603     }
 604     signal(SIGCHLD, chldhandler);
 605     signal(SIGHUP, sighandler);
 606     signal(SIGPIPE, sighandler);
 607     while(1) {
 608         if(reload) {
 609             reloadconf(lcf);
 610             reload = 0;
 611         }
 612         if((fd = recvreq(0, &req)) < 0) {
 613             if(errno == EINTR)
 614                 continue;
 615             if(errno != 0)
 616                 flog(LOG_ERR, "recvreq: %s", strerror(errno));
 617             break;
 618         }
 619         serve(req, fd);
 620         freehthead(req);
 621         close(fd);
 622     }
 623     return(0);
 624 }