rework string handling for directory listing, avoid redundant string scanning
[project/uhttpd.git] / file.c
1 /*
2  * uhttpd - Tiny single-threaded httpd
3  *
4  *   Copyright (C) 2010-2012 Jo-Philipp Wich <xm@subsignal.org>
5  *   Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
6  *
7  *  Licensed under the Apache License, Version 2.0 (the "License");
8  *  you may not use this file except in compliance with the License.
9  *  You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  *  Unless required by applicable law or agreed to in writing, software
14  *  distributed under the License is distributed on an "AS IS" BASIS,
15  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  *  See the License for the specific language governing permissions and
17  *  limitations under the License.
18  */
19
20 #define _BSD_SOURCE
21 #define _XOPEN_SOURCE 700
22
23 #include <sys/types.h>
24 #include <sys/dir.h>
25 #include <time.h>
26 #include <strings.h>
27
28 #include <libubox/blobmsg.h>
29
30 #include "uhttpd.h"
31 #include "mimetypes.h"
32
33 static LIST_HEAD(index_files);
34 static LIST_HEAD(dispatch_handlers);
35
36 struct index_file {
37         struct list_head list;
38         const char *name;
39 };
40
41 enum file_hdr {
42         HDR_AUTHORIZATION,
43         HDR_IF_MODIFIED_SINCE,
44         HDR_IF_UNMODIFIED_SINCE,
45         HDR_IF_MATCH,
46         HDR_IF_NONE_MATCH,
47         HDR_IF_RANGE,
48         __HDR_MAX
49 };
50
51 void uh_index_add(const char *filename)
52 {
53         struct index_file *idx;
54
55         idx = calloc(1, sizeof(*idx));
56         idx->name = filename;
57         list_add_tail(&idx->list, &index_files);
58 }
59
60 static char * canonpath(const char *path, char *path_resolved)
61 {
62         const char *path_cpy = path;
63         char *path_res = path_resolved;
64
65         if (conf.no_symlinks)
66                 return realpath(path, path_resolved);
67
68         /* normalize */
69         while ((*path_cpy != '\0') && (path_cpy < (path + PATH_MAX - 2))) {
70                 if (*path_cpy != '/')
71                         goto next;
72
73                 /* skip repeating / */
74                 if (path_cpy[1] == '/') {
75                         path_cpy++;
76                         continue;
77                 }
78
79                 /* /./ or /../ */
80                 if (path_cpy[1] == '.') {
81                         /* skip /./ */
82                         if ((path_cpy[2] == '/') || (path_cpy[2] == '\0')) {
83                                 path_cpy += 2;
84                                 continue;
85                         }
86
87                         /* collapse /x/../ */
88                         if ((path_cpy[2] == '.') &&
89                             ((path_cpy[3] == '/') || (path_cpy[3] == '\0'))) {
90                                 while ((path_res > path_resolved) && (*--path_res != '/'));
91
92                                 path_cpy += 3;
93                                 continue;
94                         }
95                 }
96
97 next:
98                 *path_res++ = *path_cpy++;
99         }
100
101         /* remove trailing slash if not root / */
102         if ((path_res > (path_resolved+1)) && (path_res[-1] == '/'))
103                 path_res--;
104         else if (path_res == path_resolved)
105                 *path_res++ = '/';
106
107         *path_res = '\0';
108
109         return path_resolved;
110 }
111
112 /* Returns NULL on error.
113 ** NB: improperly encoded URL should give client 400 [Bad Syntax]; returning
114 ** NULL here causes 404 [Not Found], but that's not too unreasonable. */
115 static struct path_info *
116 uh_path_lookup(struct client *cl, const char *url)
117 {
118         static char path_phys[PATH_MAX];
119         static char path_info[PATH_MAX];
120         static struct path_info p;
121
122         const char *docroot = conf.docroot;
123         int docroot_len = strlen(docroot);
124         char *pathptr = NULL;
125         bool slash;
126
127         int i = 0;
128         int len;
129         struct stat s;
130         struct index_file *idx;
131
132         /* back out early if url is undefined */
133         if (url == NULL)
134                 return NULL;
135
136         memset(&p, 0, sizeof(p));
137         path_phys[0] = 0;
138         path_info[0] = 0;
139
140         strcpy(uh_buf, docroot);
141
142         /* separate query string from url */
143         if ((pathptr = strchr(url, '?')) != NULL) {
144                 p.query = pathptr[1] ? pathptr + 1 : NULL;
145
146                 /* urldecode component w/o query */
147                 if (pathptr > url) {
148                         if (uh_urldecode(&uh_buf[docroot_len],
149                                          sizeof(uh_buf) - docroot_len - 1,
150                                          url, pathptr - url ) < 0)
151                                 return NULL;
152                 }
153         }
154
155         /* no query string, decode all of url */
156         else if (uh_urldecode(&uh_buf[docroot_len],
157                               sizeof(uh_buf) - docroot_len - 1,
158                               url, strlen(url) ) < 0)
159                 return NULL;
160
161         /* create canon path */
162         len = strlen(uh_buf);
163         slash = len && uh_buf[len - 1] == '/';
164         len = min(len, sizeof(path_phys) - 1);
165
166         for (i = len; i >= 0; i--) {
167                 char ch = uh_buf[i];
168                 bool exists;
169
170                 if (ch != 0 && ch != '/')
171                         continue;
172
173                 uh_buf[i] = 0;
174                 exists = !!canonpath(uh_buf, path_phys);
175                 uh_buf[i] = ch;
176
177                 snprintf(path_info, sizeof(path_info), "%s", uh_buf + i);
178                 break;
179         }
180
181         /* check whether found path is within docroot */
182         if (strncmp(path_phys, docroot, docroot_len) != 0 ||
183             (path_phys[docroot_len] != 0 &&
184              path_phys[docroot_len] != '/'))
185                 return NULL;
186
187         /* test current path */
188         if (stat(path_phys, &p.stat))
189                 return NULL;
190
191         /* is a regular file */
192         if (p.stat.st_mode & S_IFREG) {
193                 p.root = docroot;
194                 p.phys = path_phys;
195                 p.name = &path_phys[docroot_len];
196                 p.info = path_info[0] ? path_info : NULL;
197                 return &p;
198         }
199
200         if (!(p.stat.st_mode & S_IFDIR))
201                 return NULL;
202
203         if (path_info[0])
204             return NULL;
205
206         pathptr = path_phys + strlen(path_phys);
207
208         /* ensure trailing slash */
209         if (pathptr[-1] != '/') {
210                 pathptr[0] = '/';
211                 pathptr[1] = 0;
212                 pathptr++;
213         }
214
215         /* if requested url resolves to a directory and a trailing slash
216            is missing in the request url, redirect the client to the same
217            url with trailing slash appended */
218         if (!slash) {
219                 uh_http_header(cl, 302, "Found");
220                 ustream_printf(cl->us, "Location: %s%s%s\r\n\r\n",
221                                 &path_phys[docroot_len],
222                                 p.query ? "?" : "",
223                                 p.query ? p.query : "");
224                 uh_request_done(cl);
225                 p.redirected = 1;
226                 return &p;
227         }
228
229         /* try to locate index file */
230         len = path_phys + sizeof(path_phys) - pathptr - 1;
231         list_for_each_entry(idx, &index_files, list) {
232                 if (strlen(idx->name) > len)
233                         continue;
234
235                 strcpy(pathptr, idx->name);
236                 if (!stat(path_phys, &s) && (s.st_mode & S_IFREG))
237                         break;
238
239                 *pathptr = 0;
240         }
241
242         p.root = docroot;
243         p.phys = path_phys;
244         p.name = &path_phys[docroot_len];
245
246         return p.phys ? &p : NULL;
247 }
248
249 #ifdef __APPLE__
250 time_t timegm (struct tm *tm);
251 #endif
252
253 static const char * uh_file_mime_lookup(const char *path)
254 {
255         struct mimetype *m = &uh_mime_types[0];
256         const char *e;
257
258         while (m->extn) {
259                 e = &path[strlen(path)-1];
260
261                 while (e >= path) {
262                         if ((*e == '.' || *e == '/') && !strcasecmp(&e[1], m->extn))
263                                 return m->mime;
264
265                         e--;
266                 }
267
268                 m++;
269         }
270
271         return "application/octet-stream";
272 }
273
274 static const char * uh_file_mktag(struct stat *s, char *buf)
275 {
276         snprintf(buf, sizeof(buf), "\"%x-%x-%x\"",
277                          (unsigned int) s->st_ino,
278                          (unsigned int) s->st_size,
279                          (unsigned int) s->st_mtime);
280
281         return buf;
282 }
283
284 static time_t uh_file_date2unix(const char *date)
285 {
286         struct tm t;
287
288         memset(&t, 0, sizeof(t));
289
290         if (strptime(date, "%a, %d %b %Y %H:%M:%S %Z", &t) != NULL)
291                 return timegm(&t);
292
293         return 0;
294 }
295
296 static char * uh_file_unix2date(time_t ts, char *buf)
297 {
298         struct tm *t = gmtime(&ts);
299
300         strftime(buf, sizeof(buf), "%a, %d %b %Y %H:%M:%S GMT", t);
301
302         return buf;
303 }
304
305 static char *uh_file_header(struct client *cl, int idx)
306 {
307         if (!cl->dispatch.file.hdr[idx])
308                 return NULL;
309
310         return (char *) blobmsg_data(cl->dispatch.file.hdr[idx]);
311 }
312
313 static void uh_file_response_ok_hdrs(struct client *cl, struct stat *s)
314 {
315         char buf[128];
316
317         if (s) {
318                 ustream_printf(cl->us, "ETag: %s\r\n", uh_file_mktag(s, buf));
319                 ustream_printf(cl->us, "Last-Modified: %s\r\n",
320                                uh_file_unix2date(s->st_mtime, buf));
321         }
322         ustream_printf(cl->us, "Date: %s\r\n", uh_file_unix2date(time(NULL), buf));
323 }
324
325 static void uh_file_response_200(struct client *cl, struct stat *s)
326 {
327         uh_http_header(cl, 200, "OK");
328         return uh_file_response_ok_hdrs(cl, s);
329 }
330
331 static void uh_file_response_304(struct client *cl, struct stat *s)
332 {
333         uh_http_header(cl, 304, "Not Modified");
334
335         return uh_file_response_ok_hdrs(cl, s);
336 }
337
338 static void uh_file_response_412(struct client *cl)
339 {
340         uh_http_header(cl, 412, "Precondition Failed");
341 }
342
343 static bool uh_file_if_match(struct client *cl, struct stat *s)
344 {
345         char buf[128];
346         const char *tag = uh_file_mktag(s, buf);
347         char *hdr = uh_file_header(cl, HDR_IF_MATCH);
348         char *p;
349         int i;
350
351         if (!hdr)
352                 return true;
353
354         p = &hdr[0];
355         for (i = 0; i < strlen(hdr); i++)
356         {
357                 if ((hdr[i] == ' ') || (hdr[i] == ',')) {
358                         hdr[i++] = 0;
359                         p = &hdr[i];
360                 } else if (!strcmp(p, "*") || !strcmp(p, tag)) {
361                         return true;
362                 }
363         }
364
365         uh_file_response_412(cl);
366         return false;
367 }
368
369 static int uh_file_if_modified_since(struct client *cl, struct stat *s)
370 {
371         char *hdr = uh_file_header(cl, HDR_IF_MODIFIED_SINCE);
372
373         if (!hdr)
374                 return true;
375
376         if (uh_file_date2unix(hdr) >= s->st_mtime) {
377                 uh_file_response_304(cl, s);
378                 return false;
379         }
380
381         return true;
382 }
383
384 static int uh_file_if_none_match(struct client *cl, struct stat *s)
385 {
386         char buf[128];
387         const char *tag = uh_file_mktag(s, buf);
388         char *hdr = uh_file_header(cl, HDR_IF_NONE_MATCH);
389         char *p;
390         int i;
391
392         if (!hdr)
393                 return true;
394
395         p = &hdr[0];
396         for (i = 0; i < strlen(hdr); i++) {
397                 if ((hdr[i] == ' ') || (hdr[i] == ',')) {
398                         hdr[i++] = 0;
399                         p = &hdr[i];
400                 } else if (!strcmp(p, "*") || !strcmp(p, tag)) {
401                         if ((cl->request.method == UH_HTTP_MSG_GET) ||
402                                 (cl->request.method == UH_HTTP_MSG_HEAD))
403                                 uh_file_response_304(cl, s);
404                         else
405                                 uh_file_response_412(cl);
406
407                         return false;
408                 }
409         }
410
411         return true;
412 }
413
414 static int uh_file_if_range(struct client *cl, struct stat *s)
415 {
416         char *hdr = uh_file_header(cl, HDR_IF_RANGE);
417
418         if (hdr) {
419                 uh_file_response_412(cl);
420                 return false;
421         }
422
423         return true;
424 }
425
426 static int uh_file_if_unmodified_since(struct client *cl, struct stat *s)
427 {
428         char *hdr = uh_file_header(cl, HDR_IF_UNMODIFIED_SINCE);
429
430         if (hdr && uh_file_date2unix(hdr) <= s->st_mtime) {
431                 uh_file_response_412(cl);
432                 return false;
433         }
434
435         return true;
436 }
437
438
439 static int uh_file_scandir_filter_dir(const struct dirent *e)
440 {
441         return strcmp(e->d_name, ".") ? 1 : 0;
442 }
443
444 static void uh_file_dirlist(struct client *cl, struct path_info *pi)
445 {
446         int i;
447         int count = 0;
448         char filename[PATH_MAX];
449         char *pathptr;
450         struct dirent **files = NULL;
451         struct stat s;
452         char buf[128];
453
454         uh_file_response_200(cl, NULL);
455         ustream_printf(cl->us, "Content-Type: text/html\r\n\r\n");
456
457         uh_chunk_printf(cl,
458                 "<html><head><title>Index of %s</title></head>"
459                 "<body><h1>Index of %s</h1><hr /><ol>",
460                 pi->name, pi->name);
461
462         if ((count = scandir(pi->phys, &files, uh_file_scandir_filter_dir,
463                                                  alphasort)) > 0)
464         {
465                 int len;
466
467                 strcpy(filename, pi->phys);
468                 len = strlen(filename);
469                 pathptr = filename + len;
470                 len = PATH_MAX - len;
471
472                 /* list subdirs */
473                 for (i = 0; i < count; i++) {
474                         snprintf(pathptr, len, "%s", files[i]->d_name);
475
476                         if (!stat(filename, &s) &&
477                                 (s.st_mode & S_IFDIR) && (s.st_mode & S_IXOTH))
478                                 uh_chunk_printf(cl,
479                                         "<li><strong><a href='%s%s/'>%s</a>/"
480                                         "</strong><br /><small>modified: %s"
481                                         "<br />directory - %.02f kbyte<br />"
482                                         "<br /></small></li>",
483                                         pi->name, files[i]->d_name,
484                                         files[i]->d_name,
485                                         uh_file_unix2date(s.st_mtime, buf),
486                                         s.st_size / 1024.0);
487
488                         *pathptr = 0;
489                 }
490
491                 /* list files */
492                 for (i = 0; i < count; i++) {
493                         snprintf(pathptr, len, "%s", files[i]->d_name);
494
495                         if (!stat(filename, &s) &&
496                                 !(s.st_mode & S_IFDIR) && (s.st_mode & S_IROTH))
497                                 uh_chunk_printf(cl,
498                                         "<li><strong><a href='%s%s'>%s</a>"
499                                         "</strong><br /><small>modified: %s"
500                                         "<br />%s - %.02f kbyte<br />"
501                                         "<br /></small></li>",
502                                         pi->name, files[i]->d_name,
503                                         files[i]->d_name,
504                                         uh_file_unix2date(s.st_mtime, buf),
505                                         uh_file_mime_lookup(filename),
506                                         s.st_size / 1024.0);
507
508                         *pathptr = 0;
509                 }
510         }
511
512         uh_chunk_printf(cl, "</ol><hr /></body></html>");
513         uh_request_done(cl);
514
515         if (files)
516         {
517                 for (i = 0; i < count; i++)
518                         free(files[i]);
519
520                 free(files);
521         }
522 }
523
524 static void file_write_cb(struct client *cl)
525 {
526         int fd = cl->dispatch.file.fd;
527         int r;
528
529         while (cl->us->w.data_bytes < 256) {
530                 r = read(fd, uh_buf, sizeof(uh_buf));
531                 if (r < 0) {
532                         if (errno == EINTR)
533                                 continue;
534                 }
535
536                 if (!r) {
537                         uh_request_done(cl);
538                         return;
539                 }
540
541                 uh_chunk_write(cl, uh_buf, r);
542         }
543 }
544
545 static void uh_file_free(struct client *cl)
546 {
547         close(cl->dispatch.file.fd);
548 }
549
550 static void uh_file_data(struct client *cl, struct path_info *pi, int fd)
551 {
552         /* test preconditions */
553         if (!uh_file_if_modified_since(cl, &pi->stat) ||
554                 !uh_file_if_match(cl, &pi->stat) ||
555                 !uh_file_if_range(cl, &pi->stat) ||
556                 !uh_file_if_unmodified_since(cl, &pi->stat) ||
557                 !uh_file_if_none_match(cl, &pi->stat)) {
558                 uh_request_done(cl);
559                 close(fd);
560                 return;
561         }
562
563         /* write status */
564         uh_file_response_200(cl, &pi->stat);
565
566         ustream_printf(cl->us, "Content-Type: %s\r\n",
567                            uh_file_mime_lookup(pi->name));
568
569         ustream_printf(cl->us, "Content-Length: %i\r\n\r\n",
570                            pi->stat.st_size);
571
572
573         /* send body */
574         if (cl->request.method == UH_HTTP_MSG_HEAD) {
575                 uh_request_done(cl);
576                 close(fd);
577                 return;
578         }
579
580         cl->dispatch.file.fd = fd;
581         cl->dispatch.write_cb = file_write_cb;
582         cl->dispatch.free = uh_file_free;
583         cl->dispatch.close_fds = uh_file_free;
584         file_write_cb(cl);
585 }
586
587 static void uh_file_request(struct client *cl, const char *url,
588                             struct path_info *pi, struct blob_attr **tb)
589 {
590         int fd;
591
592         if (!(pi->stat.st_mode & S_IROTH))
593                 goto error;
594
595         if (pi->stat.st_mode & S_IFREG) {
596                 fd = open(pi->phys, O_RDONLY);
597                 if (fd < 0)
598                         goto error;
599
600                 cl->dispatch.file.hdr = tb;
601                 uh_file_data(cl, pi, fd);
602                 cl->dispatch.file.hdr = NULL;
603                 return;
604         }
605
606         if ((pi->stat.st_mode & S_IFDIR)) {
607                 if (conf.no_dirlists)
608                         goto error;
609
610                 uh_file_dirlist(cl, pi);
611                 return;
612         }
613
614 error:
615         uh_client_error(cl, 403, "Forbidden",
616                         "You don't have permission to access %s on this server.",
617                         url);
618 }
619
620 void uh_dispatch_add(struct dispatch_handler *d)
621 {
622         list_add_tail(&d->list, &dispatch_handlers);
623 }
624
625 static struct dispatch_handler *
626 dispatch_find(const char *url, struct path_info *pi)
627 {
628         struct dispatch_handler *d;
629
630         list_for_each_entry(d, &dispatch_handlers, list) {
631                 if (pi) {
632                         if (d->check_url)
633                                 continue;
634
635                         if (d->check_path(pi, url))
636                                 return d;
637                 } else {
638                         if (d->check_path)
639                                 continue;
640
641                         if (d->check_url(url))
642                                 return d;
643                 }
644         }
645
646         return NULL;
647 }
648
649 static bool __handle_file_request(struct client *cl, const char *url)
650 {
651         static const struct blobmsg_policy hdr_policy[__HDR_MAX] = {
652                 [HDR_AUTHORIZATION] = { "authorization", BLOBMSG_TYPE_STRING },
653                 [HDR_IF_MODIFIED_SINCE] = { "if-modified-since", BLOBMSG_TYPE_STRING },
654                 [HDR_IF_UNMODIFIED_SINCE] = { "if-unmodified-since", BLOBMSG_TYPE_STRING },
655                 [HDR_IF_MATCH] = { "if-match", BLOBMSG_TYPE_STRING },
656                 [HDR_IF_NONE_MATCH] = { "if-none-match", BLOBMSG_TYPE_STRING },
657                 [HDR_IF_RANGE] = { "if-range", BLOBMSG_TYPE_STRING },
658         };
659         struct dispatch_handler *d;
660         struct blob_attr *tb[__HDR_MAX];
661         struct path_info *pi;
662
663         pi = uh_path_lookup(cl, url);
664         if (!pi)
665                 return false;
666
667         if (pi->redirected)
668                 return true;
669
670         blobmsg_parse(hdr_policy, __HDR_MAX, tb, blob_data(cl->hdr.head), blob_len(cl->hdr.head));
671         if (tb[HDR_AUTHORIZATION])
672                 pi->auth = blobmsg_data(tb[HDR_AUTHORIZATION]);
673
674         if (!uh_auth_check(cl, pi))
675                 return true;
676
677         d = dispatch_find(url, pi);
678         if (d)
679                 d->handle_request(cl, url, pi);
680         else
681                 uh_file_request(cl, url, pi, tb);
682
683         return true;
684 }
685
686 void uh_handle_request(struct client *cl)
687 {
688         struct dispatch_handler *d;
689         const char *url = cl->request.url;
690
691         d = dispatch_find(url, NULL);
692         if (d) {
693                 d->handle_request(cl, url, NULL);
694                 return;
695         }
696
697         if (__handle_file_request(cl, url) ||
698             __handle_file_request(cl, conf.error_handler))
699                 return;
700
701         uh_client_error(cl, 404, "Not Found", "The requested URL %s was not found on this server.", cl->request.url);
702 }