src/dirplex/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 <time.h>
  28 #include <sys/wait.h>
  29 #include <sys/signal.h>
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34 #include <utils.h>
  35 #include <log.h>
  36 #include <req.h>
  37 #include <proc.h>
  38 #include <resp.h>
  39 #include <cf.h>
  40
  41 #include "dirplex.h"
  42
  43 time_t now;
  44
  45 static void chinit(void *idata)
  46 {
  47     char *twd = idata;
  48
  49     if(twd != NULL) {
  50         /* This should never be able to fail other than for critical
  51          * I/O errors or some such, since the path has already been
  52          * traversed. */
  53         if(chdir(twd))
  54             exit(127);
  55     }
  56 }
  57
  58 static void handle(struct hthead *req, int fd, char *path, struct pattern *pat)
  59 {
  60     struct child *ch;
  61     struct config *ccf;
  62     struct headmod *head;
  63     char *twd;
  64
  65     for(head = pat->headers; head != NULL; head = head->next) {
  66         headrmheader(req, head->name);
  67         headappheader(req, head->name, head->value);
  68     }
  69     if(!strncmp(path, "./", 2) && path[2])
  70         path += 2;
  71     if(pat->fchild) {
  72         headappheader(req, "X-Ash-File", path);
  73         stdforkserve(pat->fchild, req, fd, NULL, NULL);
  74     } else {
  75         if((ch = findchild(path, pat->childnm, &ccf)) == NULL) {
  76             flog(LOG_ERR, "child %s requested, but was not declared", pat->childnm);
  77             simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", pat->childnm);
  78             return;
  79         }
  80         if((twd = ccf?ccf->path:NULL) != NULL) {
  81             if(!strcmp(twd, ".")) {
  82                 twd = NULL;
  83             } else if(strncmp(path, twd, strlen(twd)) || (path[strlen(twd)] != '/')) {
  84                 /* Should be an impossible case under the current (and
  85                  * foreseeable) scheme. */
  86                 simpleerror(fd, 500, "Server Error", "An internal server error occurred.");
  87                 return;
  88             } else {
  89                 path = path + strlen(twd) + 1;
  90             }
  91         }
  92         headappheader(req, "X-Ash-File", path);
  93         if(childhandle(ch, req, fd, chinit, twd))
  94             simpleerror(fd, 500, "Server Error", "The request handler crashed.");
  95     }
  96 }
  97
  98 static void handle404(struct hthead *req, int fd, char *path)
  99 {
 100     struct child *ch;
 101     struct config *ccf;
 102     char *tmp;
 103
 104     tmp = sstrdup(path);
 105     ch = findchild(tmp, ".notfound", &ccf);
 106     if(childhandle(ch, req, fd, chinit, ccf?ccf->path:NULL))
 107         simpleerror(fd, 500, "Server Error", "The request handler crashed.");
 108     free(tmp);
 109 }
 110
 111 static void handlefile(struct hthead *req, int fd, char *path)
 112 {
 113     struct pattern *pat;
 114
 115     if((pat = findmatch(path, 0, 0)) == NULL) {
 116         handle404(req, fd, path);
 117         return;
 118     }
 119     handle(req, fd, path, pat);
 120 }
 121
 122 static char *findfile(char *path, char *name, struct stat *sb)
 123 {
 124     DIR *dir;
 125     struct stat sbuf;
 126     struct dirent *dent;
 127     char *p, *fp, *ret;
 128
 129     if(sb == NULL)
 130         sb = &sbuf;
 131     if((dir = opendir(path)) == NULL)
 132         return(NULL);
 133     ret = NULL;
 134     while((dent = readdir(dir)) != NULL) {
 135         /* Ignore backup files.
 136          * XXX: There is probably a better and more extensible way to
 137          * do this. */
 138         if(dent->d_name[strlen(dent->d_name) - 1] == '~')
 139             continue;
 140         if((p = strchr(dent->d_name, '.')) == NULL)
 141             continue;
 142         if(p - dent->d_name != strlen(name))
 143             continue;
 144         if(strncmp(dent->d_name, name, strlen(name)))
 145             continue;
 146         fp = sprintf3("%s/%s", path, dent->d_name);
 147         if(stat(fp, sb))
 148             continue;
 149         if(!S_ISREG(sb->st_mode))
 150             continue;
 151         ret = sstrdup(fp);
 152         break;
 153     }
 154     closedir(dir);
 155     return(ret);
 156 }
 157
 158 static void handledir(struct hthead *req, int fd, char *path)
 159 {
 160     struct config **cfs;
 161     int i, o;
 162     struct stat sb;
 163     char *inm, *ipath, *cpath;
 164     struct pattern *pat;
 165
 166     cpath = sprintf2("%s/", path);
 167     cfs = getconfigs(cpath);
 168     for(i = 0; cfs[i] != NULL; i++) {
 169         if(cfs[i]->index != NULL) {
 170             for(o = 0; cfs[i]->index[o] != NULL; o++) {
 171                 inm = cfs[i]->index[o];
 172                 ipath = sprintf2("%s/%s", path, inm);
 173                 if(!stat(ipath, &sb) && S_ISREG(sb.st_mode)) {
 174                     handlefile(req, fd, ipath);
 175                     free(ipath);
 176                     goto out;
 177                 }
 178                 free(ipath);
 179
 180                 if(!strchr(inm, '.') && ((ipath = findfile(path, inm, NULL)) != NULL)) {
 181                     handlefile(req, fd, ipath);
 182                     free(ipath);
 183                     goto out;
 184                 }
 185             }
 186             break;
 187         }
 188     }
 189     if((pat = findmatch(cpath, 0, 1)) != NULL) {
 190         handle(req, fd, cpath, pat);
 191         goto out;
 192     }
 193     simpleerror(fd, 403, "Not Authorized", "Will not send listings for this directory.");
 194
 195 out:
 196     free(cpath);
 197 }
 198
 199 static int checkpath(struct hthead *req, int fd, char *path, char *rest);
 200
 201 static int checkentry(struct hthead *req, int fd, char *path, char *rest, char *el)
 202 {
 203     struct stat sb;
 204     char *newpath;
 205     int rv;
 206
 207     if(*el == '.') {
 208         handle404(req, fd, sprintf3("%s/", path));
 209         return(1);
 210     }
 211     if(!stat(sprintf3("%s/%s", path, el), &sb)) {
 212         if(S_ISDIR(sb.st_mode)) {
 213             if(!*rest) {
 214                 stdredir(req, fd, 301, sprintf3("%s/", el));
 215                 return(1);
 216             }
 217             newpath = sprintf2("%s/%s", path, el);
 218             rv = checkpath(req, fd, newpath, rest + 1);
 219             free(newpath);
 220             return(rv);
 221         } else if(S_ISREG(sb.st_mode)) {
 222             newpath = sprintf2("%s/%s", path, el);
 223             replrest(req, rest);
 224             handlefile(req, fd, newpath);
 225             free(newpath);
 226             return(1);
 227         }
 228         handle404(req, fd, sprintf3("%s/", path));
 229         return(1);
 230     }
 231     if(!strchr(el, '.') && ((newpath = findfile(path, el, NULL)) != NULL)) {
 232         replrest(req, rest);
 233         handlefile(req, fd, newpath);
 234         free(newpath);
 235         return(1);
 236     }
 237     return(0);
 238 }
 239
 240 static int checkdir(struct hthead *req, int fd, char *path, char *rest)
 241 {
 242     char *cpath;
 243     struct config *cf, *ccf;
 244     struct child *ch;
 245
 246     cf = getconfig(path);
 247     if(cf->capture != NULL) {
 248         cpath = sprintf2("%s/", path);
 249         if((ch = findchild(cpath, cf->capture, &ccf)) == NULL) {
 250             free(cpath);
 251             flog(LOG_ERR, "child %s requested for capture, but was not declared", cf->capture);
 252             simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", cf->capture);
 253             return(1);
 254         }
 255         free(cpath);
 256         if(*rest == '/')
 257             rest++;
 258         replrest(req, rest);
 259         if(childhandle(ch, req, fd, chinit, ccf?ccf->path:NULL))
 260             simpleerror(fd, 500, "Server Error", "The request handler crashed.");
 261         return(1);
 262     }
 263     return(0);
 264 }
 265
 266 static int checkpath(struct hthead *req, int fd, char *path, char *rest)
 267 {
 268     char *p, *el;
 269     int rv;
 270
 271     el = NULL;
 272     rv = 0;
 273
 274     if(!strncmp(path, "./", 2))
 275         path += 2;
 276     if(checkdir(req, fd, path, rest))
 277         return(1);
 278
 279     if((p = strchr(rest, '/')) == NULL) {
 280         el = unquoteurl(rest);
 281         rest = "";
 282     } else {
 283         char buf[p - rest + 1];
 284         memcpy(buf, rest, p - rest);
 285         buf[p - rest] = 0;
 286         el = unquoteurl(buf);
 287         rest = p;
 288     }
 289     if(el == NULL) {
 290         simpleerror(fd, 400, "Bad Request", "The requested URL contains an invalid escape sequence.");
 291         rv = 1;
 292         goto out;
 293     }
 294     if(strchr(el, '/') || (!*el && *rest)) {
 295         handle404(req, fd, sprintf3("%s/", path));
 296         rv = 1;
 297         goto out;
 298     }
 299     if(!*el) {
 300         replrest(req, rest);
 301         handledir(req, fd, path);
 302         rv = 1;
 303         goto out;
 304     }
 305     rv = checkentry(req, fd, path, rest, el);
 306
 307 out:
 308     if(el != NULL)
 309         free(el);
 310     return(rv);
 311 }
 312
 313 static void serve(struct hthead *req, int fd)
 314 {
 315     now = time(NULL);
 316     if(!checkpath(req, fd, ".", req->rest))
 317         handle404(req, fd, ".");
 318 }
 319
 320 static void chldhandler(int sig)
 321 {
 322     pid_t pid;
 323     int st;
 324
 325     while((pid = waitpid(-1, &st, WNOHANG)) > 0) {
 326         if(WCOREDUMP(st))
 327             flog(LOG_WARNING, "child process %i dumped core", pid);
 328     }
 329 }
 330
 331 static void sighandler(int sig)
 332 {
 333 }
 334
 335 static void usage(FILE *out)
 336 {
 337     fprintf(out, "usage: dirplex [-hN] [-c CONFIG] DIR\n");
 338 }
 339
 340 int main(int argc, char **argv)
 341 {
 342     int c;
 343     int nodef;
 344     char *gcf, *lcf, *clcf;
 345     struct hthead *req;
 346     int fd;
 347
 348     nodef = 0;
 349     lcf = NULL;
 350     while((c = getopt(argc, argv, "hNc:")) >= 0) {
 351         switch(c) {
 352         case 'h':
 353             usage(stdout);
 354             exit(0);
 355         case 'N':
 356             nodef = 1;
 357             break;
 358         case 'c':
 359             lcf = optarg;
 360             break;
 361         default:
 362             usage(stderr);
 363             exit(1);
 364         }
 365     }
 366     if(argc - optind < 1) {
 367         usage(stderr);
 368         exit(1);
 369     }
 370     if(!nodef) {
 371         if((gcf = findstdconf("ashd/dirplex.rc")) != NULL) {
 372             gconfig = readconfig(gcf);
 373             free(gcf);
 374         }
 375     }
 376     if(lcf != NULL) {
 377         if(strchr(lcf, '/') == NULL) {
 378             if((clcf = findstdconf(sprintf3("ashd/%s", lcf))) == NULL) {
 379                 flog(LOG_ERR, "could not find requested configuration `%s'", lcf);
 380                 exit(1);
 381             }
 382             if((lconfig = readconfig(clcf)) == NULL)
 383                 exit(1);
 384             free(clcf);
 385         } else {
 386             if((lconfig = readconfig(lcf)) == NULL)
 387                 exit(1);
 388         }
 389     }
 390     if(chdir(argv[optind])) {
 391         flog(LOG_ERR, "could not change directory to %s: %s", argv[optind], strerror(errno));
 392         exit(1);
 393     }
 394     signal(SIGCHLD, chldhandler);
 395     signal(SIGPIPE, sighandler);
 396     while(1) {
 397         if((fd = recvreq(0, &req)) < 0) {
 398             if(errno != 0)
 399                 flog(LOG_ERR, "recvreq: %s", strerror(errno));
 400             break;
 401         }
 402         serve(req, fd);
 403         freehthead(req);
 404         close(fd);
 405     }
 406     return(0);
 407 }