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