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
  28 #ifdef HAVE_CONFIG_H
  29 #include <config.h>
  30 #endif
  31 #include <utils.h>
  32 #include <log.h>
  33 #include <req.h>
  34 #include <proc.h>
  35 #include <resp.h>
  36
  37 #define CH_SOCKET 0
  38 #define CH_FORK 1
  39
  40 #define PAT_REST 0
  41 #define PAT_URL 1
  42 #define PAT_METHOD 2
  43 #define PAT_HEADER 3
  44 #define PAT_ALL 4
  45 #define PAT_DEFAULT 5
  46
  47 #define PATFL_MSS 1
  48
  49 struct config {
  50     struct child *children;
  51     struct pattern *patterns;
  52 };
  53
  54 struct child {
  55     struct child *next;
  56     char *name;
  57     int type;
  58     char **argv;
  59     int fd;
  60 };
  61
  62 struct rule {
  63     int type;
  64     int fl;
  65     char *header;
  66     regex_t *pattern;
  67 };
  68
  69 struct pattern {
  70     struct pattern *next;
  71     char *childnm;
  72     struct rule **rules;
  73     char *restpat;
  74 };
  75
  76 static struct config *config;
  77
  78 static void freepattern(struct pattern *pat)
  79 {
  80     struct rule **rule;
  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     if(pat->childnm != NULL)
  92         free(pat->childnm);
  93     free(pat);
  94 }
  95
  96 static void freechild(struct child *ch)
  97 {
  98     if(ch->fd != -1)
  99         close(ch->fd);
 100     if(ch->name != NULL)
 101         free(ch->name);
 102     if(ch->argv != NULL)
 103         freeca(ch->argv);
 104     free(ch);
 105 }
 106
 107 static struct child *newchild(char *name, int type)
 108 {
 109     struct child *ch;
 110
 111     omalloc(ch);
 112     ch->name = sstrdup(name);
 113     ch->type = type;
 114     ch->fd = -1;
 115     return(ch);
 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 config *readconfig(char *filename)
 167 {
 168     int i;
 169     struct config *cf;
 170     FILE *s;
 171     char line[1024];
 172     char *p, **w;
 173     int ind, eof;
 174     int lno;
 175     int state;
 176     int rv;
 177     int argc;
 178     struct child *child;
 179     struct pattern *pat;
 180     struct rule *rule;
 181     regex_t *regex;
 182     int rxfl;
 183
 184     if((s = fopen(filename, "r")) == NULL)
 185         return(NULL);
 186     omalloc(cf);
 187     eof = 0;
 188     state = 0;
 189     w = NULL;
 190     lno = 0;
 191     do {
 192         if(fgets(line, sizeof(line), s) == NULL) {
 193             eof = 1;
 194             line[0] = 0;
 195         }
 196         lno++;
 197         for(p = line; *p; p++) {
 198             if(*p == '#')
 199                 continue;
 200             if(!isspace(*p))
 201                 break;
 202         }
 203         ind = isspace(line[0]);
 204         w = tokenize(line);
 205         argc = calen(w);
 206
 207     retry:
 208         if(state == 0) {
 209             if(ind) {
 210                 flog(LOG_WARNING, "%s%i: unexpected line indentation in global scope", filename, lno);
 211                 goto next;
 212             } else {
 213                 if(!w[0]) {
 214                 } else if(!strcmp(w[0], "child")) {
 215                     if(argc < 2) {
 216                         flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
 217                         goto next;
 218                     }
 219                     child = newchild(w[1], CH_SOCKET);
 220                     state = 1;
 221                 } else if(!strcmp(w[0], "fchild")) {
 222                     if(argc < 2) {
 223                         flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
 224                         goto next;
 225                     }
 226                     child = newchild(w[1], CH_FORK);
 227                     state = 1;
 228                 } else if(!strcmp(w[0], "match")) {
 229                     pat = newpattern();
 230                     state = 2;
 231                 } else {
 232                     flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
 233                 }
 234             }
 235         } else if(state == 1) {
 236             if(ind) {
 237                 if(!w[0]) {
 238                 } else if(!strcmp(w[0], "exec")) {
 239                     if(argc < 2) {
 240                         flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", filename, lno);
 241                         goto next;
 242                     }
 243                     child->argv = szmalloc(sizeof(*child->argv) * argc);
 244                     for(i = 0; i < argc - 1; i++)
 245                         child->argv[i] = sstrdup(w[i + 1]);
 246                 } else {
 247                     flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
 248                 }
 249             } else {
 250                 state = 0;
 251                 if(child->argv == NULL) {
 252                     flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", filename, lno, child->name);
 253                     freechild(child);
 254                     goto retry;
 255                 }
 256                 child->next = cf->children;
 257                 cf->children = child;
 258                 goto retry;
 259             }
 260         } else if(state == 2) {
 261             if(ind) {
 262                 rxfl = 0;
 263                 if(!w[0]) {
 264                 } else if(!strcmp(w[0], "point") ||
 265                           !strcmp(w[0], "url") ||
 266                           !strcmp(w[0], "method")) {
 267                     if(argc < 2) {
 268                         flog(LOG_WARNING, "%s:%i: missing pattern for `%s' match", w[0], filename, lno);
 269                         goto next;
 270                     }
 271                     if(argc >= 3) {
 272                         if(strchr(w[2], 'i'))
 273                             rxfl |= REG_ICASE;
 274                     }
 275                     if((regex = regalloc(w[1], rxfl)) == NULL) {
 276                         flog(LOG_WARNING, "%s:%i: invalid regex for `%s' match", w[0], filename, lno);
 277                         goto next;
 278                     }
 279                     rule = newrule(pat);
 280                     if(!strcmp(w[0], "point"))
 281                         rule->type = PAT_REST;
 282                     else if(!strcmp(w[0], "url"))
 283                         rule->type = PAT_URL;
 284                     else if(!strcmp(w[0], "method"))
 285                         rule->type = PAT_METHOD;
 286                     rule->pattern = regex;
 287                     if(argc >= 3) {
 288                         if(strchr(w[2], 's'))
 289                             rule->fl |= PATFL_MSS;
 290                     }
 291                 } else if(!strcmp(w[0], "header")) {
 292                     if(argc < 3) {
 293                         flog(LOG_WARNING, "%s:%i: missing header name or pattern for `header' match", filename, lno);
 294                         goto next;
 295                     }
 296                     if(argc >= 4) {
 297                         if(strchr(w[3], 'i'))
 298                             rxfl |= REG_ICASE;
 299                     }
 300                     if((regex = regalloc(w[2], rxfl)) == NULL) {
 301                         flog(LOG_WARNING, "%s:%i: invalid regex for `header' match", filename, lno);
 302                         goto next;
 303                     }
 304                     rule = newrule(pat);
 305                     rule->type = PAT_HEADER;
 306                     rule->header = sstrdup(w[1]);
 307                     rule->pattern = regex;
 308                     if(argc >= 4) {
 309                         if(strchr(w[3], 's'))
 310                             rule->fl |= PATFL_MSS;
 311                     }
 312                 } else if(!strcmp(w[0], "all")) {
 313                     newrule(pat)->type = PAT_ALL;
 314                 } else if(!strcmp(w[0], "default")) {
 315                     newrule(pat)->type = PAT_DEFAULT;
 316                 } else if(!strcmp(w[0], "handler")) {
 317                     if(argc < 2) {
 318                         flog(LOG_WARNING, "%s:%i: missing child name for `handler' directive", filename, lno);
 319                         goto next;
 320                     }
 321                     if(pat->childnm != NULL)
 322                         free(pat->childnm);
 323                     pat->childnm = sstrdup(w[1]);
 324                 } else if(!strcmp(w[0], "restpat")) {
 325                     if(argc < 2) {
 326                         flog(LOG_WARNING, "%s:%i: missing pattern for `restpat' directive", filename, lno);
 327                         goto next;
 328                     }
 329                     if(pat->restpat != NULL)
 330                         free(pat->restpat);
 331                     pat->restpat = sstrdup(w[1]);
 332                 } else {
 333                     flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
 334                 }
 335             } else {
 336                 state = 0;
 337                 if(pat->rules[0] == NULL) {
 338                     flog(LOG_WARNING, "%s:%i: missing rules in match declaration", filename, lno);
 339                     freepattern(pat);
 340                     goto retry;
 341                 }
 342                 if(pat->childnm == NULL) {
 343                     flog(LOG_WARNING, "%s:%i: missing handler in match declaration", filename, lno);
 344                     freepattern(pat);
 345                     goto retry;
 346                 }
 347                 pat->next = cf->patterns;
 348                 cf->patterns = pat;
 349                 goto retry;
 350             }
 351         }
 352
 353     next:
 354         freeca(w);
 355         w = NULL;
 356     } while(!eof);
 357     rv = 0;
 358
 359     if(w != NULL)
 360         freeca(w);
 361     fclose(s);
 362     return(cf);
 363 }
 364
 365 static void exprestpat(struct hthead *req, struct pattern *pat, char **mstr)
 366 {
 367     char *p, *p2, *hdr;
 368     int mc;
 369     struct charbuf buf;
 370
 371     if(mstr == NULL)
 372         mc = 0;
 373     else
 374         for(mc = 0; mstr[mc]; mc++);
 375     bufinit(buf);
 376     for(p = pat->restpat; *p; ) {
 377         if(*p == '$') {
 378             p++;
 379             if((*p >= '0') && (*p <= '9')) {
 380                 if(*p - '0' < mc)
 381                     bufcatstr(buf, mstr[*p - '0']);
 382                 p++;
 383             } else if(*p == '_') {
 384                 bufcatstr(buf, req->rest);
 385                 p++;
 386             } else if(*p == '$') {
 387                 bufadd(buf, '$');
 388                 p++;
 389             } else if(*p == '{') {
 390                 if((p2 = strchr(p, '{')) == NULL) {
 391                     p++;
 392                 } else {
 393                     hdr = getheader(req, sprintf3("$.*s", p2 - p - 1, p + 1));
 394                     if(hdr)
 395                         bufcatstr(buf, hdr);
 396                 }
 397             } else if(!*p) {
 398             }
 399         } else {
 400             bufadd(buf, *(p++));
 401         }
 402     }
 403     bufadd(buf, 0);
 404     replrest(req, buf.b);
 405     buffree(buf);
 406 }
 407
 408 static char *findmatch(struct config *cf, struct hthead *req, int trydefault)
 409 {
 410     int i, o;
 411     struct pattern *pat;
 412     struct rule *rule;
 413     int rmo, matched;
 414     char *pstr;
 415     char **mstr;
 416     regmatch_t gr[10];
 417
 418     mstr = NULL;
 419     for(pat = cf->patterns; pat != NULL; pat = pat->next) {
 420         rmo = -1;
 421         for(i = 0; (rule = pat->rules[i]) != NULL; i++) {
 422             matched = 0;
 423             if(rule->type == PAT_REST) {
 424                 if((matched = !regexec(rule->pattern, pstr = req->rest, 10, gr, 0)))
 425                     rmo = gr[0].rm_eo;
 426                 else
 427                     break;
 428             } else if(rule->type == PAT_URL) {
 429                 if(!(matched = !regexec(rule->pattern, pstr = req->url, 10, gr, 0)))
 430                     break;
 431             } else if(rule->type == PAT_METHOD) {
 432                 if(!(matched = !regexec(rule->pattern, pstr = req->method, 10, gr, 0)))
 433                     break;
 434             } else if(rule->type == PAT_HEADER) {
 435                 if(!(pstr = getheader(req, rule->header)))
 436                     break;
 437                 if(!(matched = !regexec(rule->pattern, pstr, 10, gr, 0)))
 438                     break;
 439             } else if(rule->type == PAT_ALL) {
 440             } else if(rule->type == PAT_DEFAULT) {
 441                 if(!trydefault)
 442                     break;
 443             }
 444             if(matched && (rule->fl & PATFL_MSS)) {
 445                 if(mstr) {
 446                     flog(LOG_WARNING, "two pattern rules marked with `s' flag found (for handler %s)", pat->childnm);
 447                     freeca(mstr);
 448                 }
 449                 for(o = 0; o < 10; o++) {
 450                     if(gr[o].rm_so < 0)
 451                         break;
 452                 }
 453                 mstr = szmalloc((o + 1) * sizeof(*mstr));
 454                 for(o = 0; o < 10; o++) {
 455                     if(gr[o].rm_so < 0)
 456                         break;
 457                     mstr[o] = smalloc(gr[o].rm_eo - gr[o].rm_so + 1);
 458                     memcpy(mstr[o], pstr + gr[o].rm_so, gr[o].rm_eo - gr[o].rm_so);
 459                     mstr[o][gr[o].rm_eo - gr[o].rm_so] = 0;
 460                 }
 461             }
 462         }
 463         if(!rule) {
 464             if(pat->restpat) {
 465                 exprestpat(req, pat, mstr);
 466             } else if(rmo != -1) {
 467                 replrest(req, req->rest + rmo);
 468             }
 469             if(mstr)
 470                 freeca(mstr);
 471             return(pat->childnm);
 472         }
 473         if(mstr) {
 474             freeca(mstr);
 475             mstr = NULL;
 476         }
 477     }
 478     return(NULL);
 479 }
 480
 481 static void forkchild(struct child *ch)
 482 {
 483     ch->fd = stdmkchild(ch->argv);
 484 }
 485
 486 static void passreq(struct child *ch, struct hthead *req, int fd)
 487 {
 488     if(ch->fd < 0)
 489         forkchild(ch);
 490     if(sendreq(ch->fd, req, fd)) {
 491         if(errno == EPIPE) {
 492             /* Assume that the child has crashed and restart it. */
 493             forkchild(ch);
 494             if(!sendreq(ch->fd, req, fd))
 495                 return;
 496         }
 497         flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(errno));
 498         close(ch->fd);
 499         ch->fd = -1;
 500     }
 501 }
 502
 503 static void serve(struct hthead *req, int fd)
 504 {
 505     char *chnm;
 506     struct child *ch;
 507
 508     if(((chnm = findmatch(config, req, 0)) == NULL) && ((chnm = findmatch(config, req, 1)) == NULL)) {
 509         simpleerror(fd, 404, "Not Found", "The requested resource could not be found on this server.");
 510         return;
 511     }
 512     if((ch = getchild(config, chnm)) == NULL) {
 513         flog(LOG_ERR, "child %s requested, but was not declared", chnm);
 514         simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", chnm);
 515         return;
 516     }
 517
 518     if(ch->type == CH_SOCKET) {
 519         passreq(ch, req, fd);
 520     } else if(ch->type == CH_FORK) {
 521         stdforkserve(ch->argv, req, fd);
 522     }
 523 }
 524
 525 int main(int argc, char **argv)
 526 {
 527     struct hthead *req;
 528     int fd;
 529
 530     if(argc < 2) {
 531         flog(LOG_ERR, "usage: patplex CONFIGFILE");
 532         exit(1);
 533     }
 534     config = readconfig(argv[1]);
 535     signal(SIGCHLD, SIG_IGN);
 536     while(1) {
 537         if((fd = recvreq(0, &req)) < 0) {
 538             if(errno != 0)
 539                 flog(LOG_ERR, "recvreq: %s", strerror(errno));
 540             break;
 541         }
 542         serve(req, fd);
 543         freehthead(req);
 544         close(fd);
 545     }
 546     return(0);
 547 }