src/dirplex.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 <errno.h>
  24 #include <sys/stat.h>
  25 #include <ctype.h>
  26 #include <dirent.h>
  27 #include <fnmatch.h>
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32 #include <utils.h>
  33 #include <mt.h>
  34 #include <log.h>
  35 #include <req.h>
  36 #include <proc.h>
  37 #include <resp.h>
  38 #include <cf.h>
  39
  40 #define CH_SOCKET 0
  41 #define CH_FORK 1
  42
  43 #define PAT_BASENAME 0
  44 #define PAT_PATHNAME 1
  45 #define PAT_ALL 2
  46 #define PAT_DEFAULT 3
  47
  48 struct config {
  49     struct config *next, *prev;
  50     char *path;
  51     time_t mtime;
  52     struct child *children;
  53     struct pattern *patterns;
  54 };
  55
  56 struct rule {
  57     int type;
  58     char *pattern;
  59 };
  60
  61 struct pattern {
  62     struct pattern *next;
  63     char *childnm;
  64     struct rule **rules;
  65 };
  66
  67 struct config *cflist;
  68
  69 static void freepattern(struct pattern *pat)
  70 {
  71     struct rule **rule;
  72
  73     for(rule = pat->rules; *rule; rule++) {
  74         if((*rule)->pattern != NULL)
  75             free((*rule)->pattern);
  76         free(*rule);
  77     }
  78     if(pat->childnm != NULL)
  79         free(pat->childnm);
  80     free(pat);
  81 }
  82
  83 static void freeconfig(struct config *cf)
  84 {
  85     struct child *ch, *nch;
  86     struct pattern *pat, *npat;
  87
  88     if(cf->prev != NULL)
  89         cf->prev->next = cf->next;
  90     if(cf->next != NULL)
  91         cf->next->prev = cf->prev;
  92     if(cf == cflist)
  93         cflist = cf->next;
  94     free(cf->path);
  95     for(ch = cf->children; ch != NULL; ch = nch) {
  96         nch = ch->next;
  97         freechild(ch);
  98     }
  99     for(pat = cf->patterns; pat != NULL; pat = npat) {
 100         npat = pat->next;
 101         freepattern(pat);
 102     }
 103     free(cf);
 104 }
 105
 106 static struct child *getchild(struct config *cf, char *name)
 107 {
 108     struct child *ch;
 109
 110     for(ch = cf->children; ch; ch = ch->next) {
 111         if(!strcmp(ch->name, name))
 112             break;
 113     }
 114     return(ch);
 115 }
 116
 117 static struct rule *newrule(struct pattern *pat)
 118 {
 119     int i;
 120     struct rule *rule;
 121
 122     for(i = 0; pat->rules[i]; i++);
 123     pat->rules = srealloc(pat->rules, sizeof(*pat->rules) * (i + 2));
 124     rule = pat->rules[i] = szmalloc(sizeof(*rule));
 125     pat->rules[i + 1] = NULL;
 126     return(rule);
 127 }
 128
 129 static struct pattern *newpattern(void)
 130 {
 131     struct pattern *pat;
 132
 133     omalloc(pat);
 134     pat->rules = szmalloc(sizeof(*pat->rules));
 135     return(pat);
 136 }
 137
 138 static struct pattern *parsepattern(struct cfstate *s)
 139 {
 140     struct pattern *pat;
 141     struct rule *rule;
 142     int sl;
 143
 144     if(!strcmp(s->argv[0], "match")) {
 145         s->expstart = 1;
 146         pat = newpattern();
 147     } else {
 148         return(NULL);
 149     }
 150
 151     sl = s->lno;
 152     while(1) {
 153         getcfline(s);
 154         if(!strcmp(s->argv[0], "filename")) {
 155             if(s->argc < 2) {
 156                 flog(LOG_WARNING, "%s:%i: missing pattern for `filename' match", s->file, s->lno);
 157                 continue;
 158             }
 159             rule = newrule(pat);
 160             rule->type = PAT_BASENAME;
 161             rule->pattern = sstrdup(s->argv[1]);
 162         } else if(!strcmp(s->argv[0], "pathname")) {
 163             if(s->argc < 2) {
 164                 flog(LOG_WARNING, "%s:%i: missing pattern for `pathname' match", s->file, s->lno);
 165                 continue;
 166             }
 167             rule = newrule(pat);
 168             rule->type = PAT_PATHNAME;
 169             rule->pattern = sstrdup(s->argv[1]);
 170         } else if(!strcmp(s->argv[0], "all")) {
 171             newrule(pat)->type = PAT_ALL;
 172         } else if(!strcmp(s->argv[0], "default")) {
 173             newrule(pat)->type = PAT_DEFAULT;
 174         } else if(!strcmp(s->argv[0], "handler")) {
 175             if(s->argc < 2) {
 176                 flog(LOG_WARNING, "%s:%i: missing child name for `handler' directive", s->file, s->lno);
 177                 continue;
 178             }
 179             if(pat->childnm != NULL)
 180                 free(pat->childnm);
 181             pat->childnm = sstrdup(s->argv[1]);
 182         } else if(!strcmp(s->argv[0], "end") || !strcmp(s->argv[0], "eof")) {
 183             break;
 184         } else {
 185             flog(LOG_WARNING, "%s:%i: unknown directive `%s' in pattern declaration", s->file, s->lno, s->argv[0]);
 186         }
 187     }
 188
 189     if(pat->rules[0] == NULL) {
 190         flog(LOG_WARNING, "%s:%i: missing rules in match declaration", s->file, sl);
 191         freepattern(pat);
 192         return(NULL);
 193     }
 194     if(pat->childnm == NULL) {
 195         flog(LOG_WARNING, "%s:%i: missing handler in match declaration", s->file, sl);
 196         freepattern(pat);
 197         return(NULL);
 198     }
 199     return(pat);
 200 }
 201
 202 static struct config *readconfig(char *path)
 203 {
 204     struct cfstate *s;
 205     FILE *in;
 206     struct config *cf;
 207     struct child *child;
 208     struct pattern *pat;
 209     struct stat sb;
 210     char *p;
 211
 212     p = sprintf3("%s/.htrc", path);
 213     if(stat(p, &sb))
 214         return(NULL);
 215     if((in = fopen(p, "r")) == NULL) {
 216         flog(LOG_WARNING, "%s: %s", p, strerror(errno));
 217         return(NULL);
 218     }
 219     s = mkcfparser(in, p);
 220     omalloc(cf);
 221     cf->mtime = sb.st_mtime;
 222     cf->path = sstrdup(path);
 223
 224     while(1) {
 225         getcfline(s);
 226         if((child = parsechild(s)) != NULL) {
 227             child->next = cf->children;
 228             cf->children = child;
 229         } else if((pat = parsepattern(s)) != NULL) {
 230             pat->next = cf->patterns;
 231             cf->patterns = pat;
 232         } else if(!strcmp(s->argv[0], "eof")) {
 233             break;
 234         } else {
 235             flog(LOG_WARNING, "%s:%i: unknown directive `%s'", s->file, s->lno, s->argv[0]);
 236         }
 237     }
 238
 239     freecfparser(s);
 240     fclose(in);
 241     return(cf);
 242 }
 243
 244 static struct config *getconfig(char *path)
 245 {
 246     struct config *cf;
 247     struct stat sb;
 248
 249     for(cf = cflist; cf != NULL; cf = cf->next) {
 250         if(!strcmp(cf->path, path)) {
 251             if(stat(sprintf3("%s/.htrc", path), &sb))
 252                 return(NULL);
 253             if(sb.st_mtime != cf->mtime) {
 254                 freeconfig(cf);
 255                 break;
 256             }
 257             return(cf);
 258         }
 259     }
 260     if((cf = readconfig(path)) != NULL) {
 261         cf->next = cflist;
 262         cflist = cf;
 263     }
 264     return(cf);
 265 }
 266
 267 static struct child *findchild(char *file, char *name)
 268 {
 269     char *buf, *p;
 270     struct config *cf;
 271     struct child *ch;
 272
 273     buf = sstrdup(file);
 274     while(1) {
 275         ch = NULL;
 276         if(!strcmp(buf, "."))
 277             break;
 278         if((p = strrchr(buf, '/')) != NULL)
 279             *p = 0;
 280         else
 281             strcpy(buf, ".");
 282         cf = getconfig(buf);
 283         if(cf == NULL)
 284             continue;
 285         if((ch = getchild(cf, name)) != NULL)
 286             break;
 287     }
 288     free(buf);
 289     return(ch);
 290 }
 291
 292 static struct pattern *findmatch(char *file, int trydefault)
 293 {
 294     int i;
 295     char *buf, *p, *bn;
 296     struct config *cf;
 297     struct pattern *pat;
 298     struct rule *rule;
 299
 300     if((bn = strrchr(file, '/')) != NULL)
 301         bn++;
 302     else
 303         bn = file;
 304     buf = sstrdup(file);
 305     while(1) {
 306         pat = NULL;
 307         if(!strcmp(buf, "."))
 308             break;
 309         if((p = strrchr(buf, '/')) != NULL)
 310             *p = 0;
 311         else
 312             strcpy(buf, ".");
 313         cf = getconfig(buf);
 314         if(cf == NULL)
 315             continue;
 316         for(pat = cf->patterns; pat != NULL; pat = pat->next) {
 317             for(i = 0; (rule = pat->rules[i]) != NULL; i++) {
 318                 if(rule->type == PAT_BASENAME) {
 319                     if(fnmatch(rule->pattern, bn, 0))
 320                         break;
 321                 } else if(rule->type == PAT_PATHNAME) {
 322                     if(fnmatch(rule->pattern, file, FNM_PATHNAME))
 323                         break;
 324                 } else if(rule->type == PAT_ALL) {
 325                 } else if(rule->type == PAT_DEFAULT) {
 326                     if(!trydefault)
 327                         break;
 328                 }
 329             }
 330             if(!rule)
 331                 goto out;
 332         }
 333     }
 334
 335 out:
 336     free(buf);
 337     return(pat);
 338 }
 339
 340 static void forkchild(struct child *ch)
 341 {
 342     ch->fd = stdmkchild(ch->argv);
 343 }
 344
 345 static void passreq(struct child *ch, struct hthead *req, int fd)
 346 {
 347     if(ch->fd < 0)
 348         forkchild(ch);
 349     if(sendreq(ch->fd, req, fd)) {
 350         if(errno == EPIPE) {
 351             /* Assume that the child has crashed and restart it. */
 352             forkchild(ch);
 353             if(!sendreq(ch->fd, req, fd))
 354                 return;
 355         }
 356         flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(errno));
 357         close(ch->fd);
 358         ch->fd = -1;
 359         simpleerror(fd, 500, "Server Error", "The request handler crashed.");
 360     }
 361 }
 362
 363 static void handlefile(struct hthead *req, int fd, char *path)
 364 {
 365     struct pattern *pat;
 366     struct child *ch;
 367
 368     headappheader(req, "X-Ash-File", path);
 369     if(((pat = findmatch(path, 0)) == NULL) && ((pat = findmatch(path, 1)) == NULL)) {
 370         /* XXX: Send a 500 error? 404? */
 371         return;
 372     }
 373     if((ch = findchild(path, pat->childnm)) == NULL) {
 374         flog(LOG_ERR, "child %s requested, but was not declared", pat->childnm);
 375         simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", pat->childnm);
 376         return;
 377     }
 378
 379     if(ch->type == CH_SOCKET) {
 380         passreq(ch, req, fd);
 381     } else if(ch->type == CH_FORK) {
 382         stdforkserve(ch->argv, req, fd);
 383     }
 384 }
 385
 386 static void handledir(struct hthead *req, int fd, char *path)
 387 {
 388     /* XXX: Todo */
 389     simpleerror(fd, 403, "Not Authorized", "Will not send directory listings or indices yet.");
 390 }
 391
 392 static int checkdir(struct hthead *req, int fd, char *path)
 393 {
 394     return(0);
 395 }
 396
 397 static void serve(struct hthead *req, int fd)
 398 {
 399     char *p, *p2, *path, *tmp, *buf, *p3, *nm;
 400     struct stat sb;
 401     DIR *dir;
 402     struct dirent *dent;
 403
 404     nm = req->rest;
 405     path = sstrdup(".");
 406     p = nm;
 407     while(1) {
 408         if((p2 = strchr(p, '/')) == NULL) {
 409         } else {
 410             *(p2++) = 0;
 411         }
 412
 413         if(!*p) {
 414             if(p2 == NULL) {
 415                 if(stat(path, &sb)) {
 416                     flog(LOG_WARNING, "failed to stat previously stated directory %s: %s", path, strerror(errno));
 417                     simpleerror(fd, 500, "Internal Server Error", "The server encountered an unexpected condition.");
 418                     goto fail;
 419                 }
 420                 break;
 421             } else {
 422                 simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
 423                 goto fail;
 424             }
 425         }
 426         if(*p == '.') {
 427             simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
 428             goto fail;
 429         }
 430
 431         getconfig(path);
 432
 433         /*
 434          * First, check the name verbatimely:
 435          */
 436         buf = sprintf3("%s/%s", path, p);
 437         if(!stat(buf, &sb)) {
 438             if(S_ISDIR(sb.st_mode)) {
 439                 tmp = path;
 440                 if(!strcmp(path, "."))
 441                     path = sstrdup(p);
 442                 else
 443                     path = sprintf2("%s/%s", path, p);
 444                 free(tmp);
 445                 if(checkdir(req, fd, path))
 446                     break;
 447                 goto next;
 448             }
 449             if(S_ISREG(sb.st_mode)) {
 450                 tmp = path;
 451                 path = sprintf2("%s/%s", path, p);
 452                 free(tmp);
 453                 break;
 454             }
 455             simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
 456             goto fail;
 457         }
 458
 459         /*
 460          * Check the file extensionlessly:
 461          */
 462         if(!strchr(p, '.') && ((dir = opendir(path)) != NULL)) {
 463             while((dent = readdir(dir)) != NULL) {
 464                 buf = sprintf3("%s/%s", path, dent->d_name);
 465                 if((p3 = strchr(dent->d_name, '.')) != NULL)
 466                     *p3 = 0;
 467                 if(strcmp(dent->d_name, p))
 468                     continue;
 469                 if(stat(buf, &sb))
 470                     continue;
 471                 if(!S_ISREG(sb.st_mode))
 472                     continue;
 473                 tmp = path;
 474                 path = sstrdup(buf);
 475                 free(tmp);
 476                 break;
 477             }
 478             closedir(dir);
 479             if(dent != NULL)
 480                 break;
 481         }
 482
 483         simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
 484         goto fail;
 485
 486     next:
 487         if(p2 == NULL)
 488             break;
 489         p = p2;
 490     }
 491     if(p2 == NULL)
 492         replrest(req, "");
 493     else
 494         replrest(req, p2);
 495     if(!strncmp(path, "./", 2))
 496         memmove(path, path + 2, strlen(path + 2) + 1);
 497     if(S_ISDIR(sb.st_mode)) {
 498         handledir(req, fd, path);
 499     } else if(S_ISREG(sb.st_mode)) {
 500         handlefile(req, fd, path);
 501     } else {
 502         simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
 503         goto fail;
 504     }
 505     goto out;
 506
 507 fail:
 508     /* No special handling, for now at least. */
 509 out:
 510     free(path);
 511 }
 512
 513 int main(int argc, char **argv)
 514 {
 515     struct hthead *req;
 516     int fd;
 517
 518     if(argc < 2) {
 519         flog(LOG_ERR, "usage: dirplex DIR");
 520         exit(1);
 521     }
 522     if(chdir(argv[1])) {
 523         flog(LOG_ERR, "could not change directory to %s: %s", argv[1], strerror(errno));
 524         exit(1);
 525     }
 526     signal(SIGCHLD, SIG_IGN);
 527     while(1) {
 528         if((fd = recvreq(0, &req)) < 0) {
 529             if(errno != 0)
 530                 flog(LOG_ERR, "recvreq: %s", strerror(errno));
 531             break;
 532         }
 533         serve(req, fd);
 534         freehthead(req);
 535         close(fd);
 536     }
 537     return(0);
 538 }