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