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