source: MondoRescue/branches/3.0/mindi-busybox/networking/httpd.c@ 3085

Last change on this file since 3085 was 2725, checked in by Bruno Cornec, 13 years ago
  • Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3
File size: 67.4 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * httpd implementation for busybox
4 *
5 * Copyright (C) 2002,2003 Glenn Engel <glenne@engel.org>
6 * Copyright (C) 2003-2006 Vladimir Oleynik <dzo@simtreas.ru>
7 *
8 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
9 *
10 *****************************************************************************
11 *
12 * Typical usage:
13 * For non root user:
14 * httpd -p 8080 -h $HOME/public_html
15 * For daemon start from rc script with uid=0:
16 * httpd -u www
17 * which is equivalent to (assuming user www has uid 80):
18 * httpd -p 80 -u 80 -h $PWD -c /etc/httpd.conf -r "Web Server Authentication"
19 *
20 * When an url starts with "/cgi-bin/" it is assumed to be a cgi script.
21 * The server changes directory to the location of the script and executes it
22 * after setting QUERY_STRING and other environment variables.
23 *
24 * Doc:
25 * "CGI Environment Variables": http://hoohoo.ncsa.uiuc.edu/cgi/env.html
26 *
27 * The applet can also be invoked as an url arg decoder and html text encoder
28 * as follows:
29 * foo=`httpd -d $foo` # decode "Hello%20World" as "Hello World"
30 * bar=`httpd -e "<Hello World>"` # encode as "&#60Hello&#32World&#62"
31 * Note that url encoding for arguments is not the same as html encoding for
32 * presentation. -d decodes an url-encoded argument while -e encodes in html
33 * for page display.
34 *
35 * httpd.conf has the following format:
36 *
37 * H:/serverroot # define the server root. It will override -h
38 * A:172.20. # Allow address from 172.20.0.0/16
39 * A:10.0.0.0/25 # Allow any address from 10.0.0.0-10.0.0.127
40 * A:10.0.0.0/255.255.255.128 # Allow any address that previous set
41 * A:127.0.0.1 # Allow local loopback connections
42 * D:* # Deny from other IP connections
43 * E404:/path/e404.html # /path/e404.html is the 404 (not found) error page
44 * I:index.html # Show index.html when a directory is requested
45 *
46 * P:/url:[http://]hostname[:port]/new/path
47 * # When /urlXXXXXX is requested, reverse proxy
48 * # it to http://hostname[:port]/new/pathXXXXXX
49 *
50 * /cgi-bin:foo:bar # Require user foo, pwd bar on urls starting with /cgi-bin/
51 * /adm:admin:setup # Require user admin, pwd setup on urls starting with /adm/
52 * /adm:toor:PaSsWd # or user toor, pwd PaSsWd on urls starting with /adm/
53 * .au:audio/basic # additional mime type for audio.au files
54 * *.php:/path/php # run xxx.php through an interpreter
55 *
56 * A/D may be as a/d or allow/deny - only first char matters.
57 * Deny/Allow IP logic:
58 * - Default is to allow all (Allow all (A:*) is a no-op).
59 * - Deny rules take precedence over allow rules.
60 * - "Deny all" rule (D:*) is applied last.
61 *
62 * Example:
63 * 1. Allow only specified addresses
64 * A:172.20 # Allow any address that begins with 172.20.
65 * A:10.10. # Allow any address that begins with 10.10.
66 * A:127.0.0.1 # Allow local loopback connections
67 * D:* # Deny from other IP connections
68 *
69 * 2. Only deny specified addresses
70 * D:1.2.3. # deny from 1.2.3.0 - 1.2.3.255
71 * D:2.3.4. # deny from 2.3.4.0 - 2.3.4.255
72 * A:* # (optional line added for clarity)
73 *
74 * If a sub directory contains a config file it is parsed and merged with
75 * any existing settings as if it was appended to the original configuration.
76 *
77 * subdir paths are relative to the containing subdir and thus cannot
78 * affect the parent rules.
79 *
80 * Note that since the sub dir is parsed in the forked thread servicing the
81 * subdir http request, any merge is discarded when the process exits. As a
82 * result, the subdir settings only have a lifetime of a single request.
83 *
84 * Custom error pages can contain an absolute path or be relative to
85 * 'home_httpd'. Error pages are to be static files (no CGI or script). Error
86 * page can only be defined in the root configuration file and are not taken
87 * into account in local (directories) config files.
88 *
89 * If -c is not set, an attempt will be made to open the default
90 * root configuration file. If -c is set and the file is not found, the
91 * server exits with an error.
92 *
93 */
94 /* TODO: use TCP_CORK, parse_config() */
95
96#include "libbb.h"
97#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
98# include <sys/sendfile.h>
99#endif
100/* amount of buffering in a pipe */
101#ifndef PIPE_BUF
102# define PIPE_BUF 4096
103#endif
104
105#define DEBUG 0
106
107#define IOBUF_SIZE 8192
108#if PIPE_BUF >= IOBUF_SIZE
109# error "PIPE_BUF >= IOBUF_SIZE"
110#endif
111
112#define HEADER_READ_TIMEOUT 60
113
114static const char DEFAULT_PATH_HTTPD_CONF[] ALIGN1 = "/etc";
115static const char HTTPD_CONF[] ALIGN1 = "httpd.conf";
116static const char HTTP_200[] ALIGN1 = "HTTP/1.0 200 OK\r\n";
117static const char index_html[] ALIGN1 = "index.html";
118
119typedef struct has_next_ptr {
120 struct has_next_ptr *next;
121} has_next_ptr;
122
123/* Must have "next" as a first member */
124typedef struct Htaccess {
125 struct Htaccess *next;
126 char *after_colon;
127 char before_colon[1]; /* really bigger, must be last */
128} Htaccess;
129
130/* Must have "next" as a first member */
131typedef struct Htaccess_IP {
132 struct Htaccess_IP *next;
133 unsigned ip;
134 unsigned mask;
135 int allow_deny;
136} Htaccess_IP;
137
138/* Must have "next" as a first member */
139typedef struct Htaccess_Proxy {
140 struct Htaccess_Proxy *next;
141 char *url_from;
142 char *host_port;
143 char *url_to;
144} Htaccess_Proxy;
145
146enum {
147 HTTP_OK = 200,
148 HTTP_PARTIAL_CONTENT = 206,
149 HTTP_MOVED_TEMPORARILY = 302,
150 HTTP_BAD_REQUEST = 400, /* malformed syntax */
151 HTTP_UNAUTHORIZED = 401, /* authentication needed, respond with auth hdr */
152 HTTP_NOT_FOUND = 404,
153 HTTP_FORBIDDEN = 403,
154 HTTP_REQUEST_TIMEOUT = 408,
155 HTTP_NOT_IMPLEMENTED = 501, /* used for unrecognized requests */
156 HTTP_INTERNAL_SERVER_ERROR = 500,
157 HTTP_CONTINUE = 100,
158#if 0 /* future use */
159 HTTP_SWITCHING_PROTOCOLS = 101,
160 HTTP_CREATED = 201,
161 HTTP_ACCEPTED = 202,
162 HTTP_NON_AUTHORITATIVE_INFO = 203,
163 HTTP_NO_CONTENT = 204,
164 HTTP_MULTIPLE_CHOICES = 300,
165 HTTP_MOVED_PERMANENTLY = 301,
166 HTTP_NOT_MODIFIED = 304,
167 HTTP_PAYMENT_REQUIRED = 402,
168 HTTP_BAD_GATEWAY = 502,
169 HTTP_SERVICE_UNAVAILABLE = 503, /* overload, maintenance */
170#endif
171};
172
173static const uint16_t http_response_type[] ALIGN2 = {
174 HTTP_OK,
175#if ENABLE_FEATURE_HTTPD_RANGES
176 HTTP_PARTIAL_CONTENT,
177#endif
178 HTTP_MOVED_TEMPORARILY,
179 HTTP_REQUEST_TIMEOUT,
180 HTTP_NOT_IMPLEMENTED,
181#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
182 HTTP_UNAUTHORIZED,
183#endif
184 HTTP_NOT_FOUND,
185 HTTP_BAD_REQUEST,
186 HTTP_FORBIDDEN,
187 HTTP_INTERNAL_SERVER_ERROR,
188#if 0 /* not implemented */
189 HTTP_CREATED,
190 HTTP_ACCEPTED,
191 HTTP_NO_CONTENT,
192 HTTP_MULTIPLE_CHOICES,
193 HTTP_MOVED_PERMANENTLY,
194 HTTP_NOT_MODIFIED,
195 HTTP_BAD_GATEWAY,
196 HTTP_SERVICE_UNAVAILABLE,
197#endif
198};
199
200static const struct {
201 const char *name;
202 const char *info;
203} http_response[ARRAY_SIZE(http_response_type)] = {
204 { "OK", NULL },
205#if ENABLE_FEATURE_HTTPD_RANGES
206 { "Partial Content", NULL },
207#endif
208 { "Found", NULL },
209 { "Request Timeout", "No request appeared within 60 seconds" },
210 { "Not Implemented", "The requested method is not recognized" },
211#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
212 { "Unauthorized", "" },
213#endif
214 { "Not Found", "The requested URL was not found" },
215 { "Bad Request", "Unsupported method" },
216 { "Forbidden", "" },
217 { "Internal Server Error", "Internal Server Error" },
218#if 0 /* not implemented */
219 { "Created" },
220 { "Accepted" },
221 { "No Content" },
222 { "Multiple Choices" },
223 { "Moved Permanently" },
224 { "Not Modified" },
225 { "Bad Gateway", "" },
226 { "Service Unavailable", "" },
227#endif
228};
229
230struct globals {
231 int verbose; /* must be int (used by getopt32) */
232 smallint flg_deny_all;
233
234 unsigned rmt_ip; /* used for IP-based allow/deny rules */
235 time_t last_mod;
236 char *rmt_ip_str; /* for $REMOTE_ADDR and $REMOTE_PORT */
237 const char *bind_addr_or_port;
238
239 const char *g_query;
240 const char *opt_c_configFile;
241 const char *home_httpd;
242 const char *index_page;
243
244 const char *found_mime_type;
245 const char *found_moved_temporarily;
246 Htaccess_IP *ip_a_d; /* config allow/deny lines */
247
248 IF_FEATURE_HTTPD_BASIC_AUTH(const char *g_realm;)
249 IF_FEATURE_HTTPD_BASIC_AUTH(char *remoteuser;)
250 IF_FEATURE_HTTPD_CGI(char *referer;)
251 IF_FEATURE_HTTPD_CGI(char *user_agent;)
252 IF_FEATURE_HTTPD_CGI(char *host;)
253 IF_FEATURE_HTTPD_CGI(char *http_accept;)
254 IF_FEATURE_HTTPD_CGI(char *http_accept_language;)
255
256 off_t file_size; /* -1 - unknown */
257#if ENABLE_FEATURE_HTTPD_RANGES
258 off_t range_start;
259 off_t range_end;
260 off_t range_len;
261#endif
262
263#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
264 Htaccess *g_auth; /* config user:password lines */
265#endif
266 Htaccess *mime_a; /* config mime types */
267#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
268 Htaccess *script_i; /* config script interpreters */
269#endif
270 char *iobuf; /* [IOBUF_SIZE] */
271#define hdr_buf bb_common_bufsiz1
272 char *hdr_ptr;
273 int hdr_cnt;
274#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
275 const char *http_error_page[ARRAY_SIZE(http_response_type)];
276#endif
277#if ENABLE_FEATURE_HTTPD_PROXY
278 Htaccess_Proxy *proxy;
279#endif
280#if ENABLE_FEATURE_HTTPD_GZIP
281 /* client can handle gzip / we are going to send gzip */
282 smallint content_gzip;
283#endif
284};
285#define G (*ptr_to_globals)
286#define verbose (G.verbose )
287#define flg_deny_all (G.flg_deny_all )
288#define rmt_ip (G.rmt_ip )
289#define bind_addr_or_port (G.bind_addr_or_port)
290#define g_query (G.g_query )
291#define opt_c_configFile (G.opt_c_configFile )
292#define home_httpd (G.home_httpd )
293#define index_page (G.index_page )
294#define found_mime_type (G.found_mime_type )
295#define found_moved_temporarily (G.found_moved_temporarily)
296#define last_mod (G.last_mod )
297#define ip_a_d (G.ip_a_d )
298#define g_realm (G.g_realm )
299#define remoteuser (G.remoteuser )
300#define referer (G.referer )
301#define user_agent (G.user_agent )
302#define host (G.host )
303#define http_accept (G.http_accept )
304#define http_accept_language (G.http_accept_language)
305#define file_size (G.file_size )
306#if ENABLE_FEATURE_HTTPD_RANGES
307#define range_start (G.range_start )
308#define range_end (G.range_end )
309#define range_len (G.range_len )
310#else
311enum {
312 range_start = 0,
313 range_end = MAXINT(off_t) - 1,
314 range_len = MAXINT(off_t),
315};
316#endif
317#define rmt_ip_str (G.rmt_ip_str )
318#define g_auth (G.g_auth )
319#define mime_a (G.mime_a )
320#define script_i (G.script_i )
321#define iobuf (G.iobuf )
322#define hdr_ptr (G.hdr_ptr )
323#define hdr_cnt (G.hdr_cnt )
324#define http_error_page (G.http_error_page )
325#define proxy (G.proxy )
326#if ENABLE_FEATURE_HTTPD_GZIP
327# define content_gzip (G.content_gzip )
328#else
329# define content_gzip 0
330#endif
331#define INIT_G() do { \
332 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
333 IF_FEATURE_HTTPD_BASIC_AUTH(g_realm = "Web Server Authentication";) \
334 bind_addr_or_port = "80"; \
335 index_page = index_html; \
336 file_size = -1; \
337} while (0)
338
339
340#define STRNCASECMP(a, str) strncasecmp((a), (str), sizeof(str)-1)
341
342/* Prototypes */
343enum {
344 SEND_HEADERS = (1 << 0),
345 SEND_BODY = (1 << 1),
346 SEND_HEADERS_AND_BODY = SEND_HEADERS + SEND_BODY,
347};
348static void send_file_and_exit(const char *url, int what) NORETURN;
349
350static void free_llist(has_next_ptr **pptr)
351{
352 has_next_ptr *cur = *pptr;
353 while (cur) {
354 has_next_ptr *t = cur;
355 cur = cur->next;
356 free(t);
357 }
358 *pptr = NULL;
359}
360
361static ALWAYS_INLINE void free_Htaccess_list(Htaccess **pptr)
362{
363 free_llist((has_next_ptr**)pptr);
364}
365
366static ALWAYS_INLINE void free_Htaccess_IP_list(Htaccess_IP **pptr)
367{
368 free_llist((has_next_ptr**)pptr);
369}
370
371/* Returns presumed mask width in bits or < 0 on error.
372 * Updates strp, stores IP at provided pointer */
373static int scan_ip(const char **strp, unsigned *ipp, unsigned char endc)
374{
375 const char *p = *strp;
376 int auto_mask = 8;
377 unsigned ip = 0;
378 int j;
379
380 if (*p == '/')
381 return -auto_mask;
382
383 for (j = 0; j < 4; j++) {
384 unsigned octet;
385
386 if ((*p < '0' || *p > '9') && *p != '/' && *p)
387 return -auto_mask;
388 octet = 0;
389 while (*p >= '0' && *p <= '9') {
390 octet *= 10;
391 octet += *p - '0';
392 if (octet > 255)
393 return -auto_mask;
394 p++;
395 }
396 if (*p == '.')
397 p++;
398 if (*p != '/' && *p)
399 auto_mask += 8;
400 ip = (ip << 8) | octet;
401 }
402 if (*p) {
403 if (*p != endc)
404 return -auto_mask;
405 p++;
406 if (*p == '\0')
407 return -auto_mask;
408 }
409 *ipp = ip;
410 *strp = p;
411 return auto_mask;
412}
413
414/* Returns 0 on success. Stores IP and mask at provided pointers */
415static int scan_ip_mask(const char *str, unsigned *ipp, unsigned *maskp)
416{
417 int i;
418 unsigned mask;
419 char *p;
420
421 i = scan_ip(&str, ipp, '/');
422 if (i < 0)
423 return i;
424
425 if (*str) {
426 /* there is /xxx after dotted-IP address */
427 i = bb_strtou(str, &p, 10);
428 if (*p == '.') {
429 /* 'xxx' itself is dotted-IP mask, parse it */
430 /* (return 0 (success) only if it has N.N.N.N form) */
431 return scan_ip(&str, maskp, '\0') - 32;
432 }
433 if (*p)
434 return -1;
435 }
436
437 if (i > 32)
438 return -1;
439
440 if (sizeof(unsigned) == 4 && i == 32) {
441 /* mask >>= 32 below may not work */
442 mask = 0;
443 } else {
444 mask = 0xffffffff;
445 mask >>= i;
446 }
447 /* i == 0 -> *maskp = 0x00000000
448 * i == 1 -> *maskp = 0x80000000
449 * i == 4 -> *maskp = 0xf0000000
450 * i == 31 -> *maskp = 0xfffffffe
451 * i == 32 -> *maskp = 0xffffffff */
452 *maskp = (uint32_t)(~mask);
453 return 0;
454}
455
456/*
457 * Parse configuration file into in-memory linked list.
458 *
459 * Any previous IP rules are discarded.
460 * If the flag argument is not SUBDIR_PARSE then all /path and mime rules
461 * are also discarded. That is, previous settings are retained if flag is
462 * SUBDIR_PARSE.
463 * Error pages are only parsed on the main config file.
464 *
465 * path Path where to look for httpd.conf (without filename).
466 * flag Type of the parse request.
467 */
468/* flag param: */
469enum {
470 FIRST_PARSE = 0, /* path will be "/etc" */
471 SIGNALED_PARSE = 1, /* path will be "/etc" */
472 SUBDIR_PARSE = 2, /* path will be derived from URL */
473};
474static void parse_conf(const char *path, int flag)
475{
476 /* internally used extra flag state */
477 enum { TRY_CURDIR_PARSE = 3 };
478
479 FILE *f;
480 const char *filename;
481 char buf[160];
482
483 /* discard old rules */
484 free_Htaccess_IP_list(&ip_a_d);
485 flg_deny_all = 0;
486 /* retain previous auth and mime config only for subdir parse */
487 if (flag != SUBDIR_PARSE) {
488 free_Htaccess_list(&mime_a);
489#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
490 free_Htaccess_list(&g_auth);
491#endif
492#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
493 free_Htaccess_list(&script_i);
494#endif
495 }
496
497 filename = opt_c_configFile;
498 if (flag == SUBDIR_PARSE || filename == NULL) {
499 filename = alloca(strlen(path) + sizeof(HTTPD_CONF) + 2);
500 sprintf((char *)filename, "%s/%s", path, HTTPD_CONF);
501 }
502
503 while ((f = fopen_for_read(filename)) == NULL) {
504 if (flag >= SUBDIR_PARSE) { /* SUBDIR or TRY_CURDIR */
505 /* config file not found, no changes to config */
506 return;
507 }
508 if (flag == FIRST_PARSE) {
509 /* -c CONFFILE given, but CONFFILE doesn't exist? */
510 if (opt_c_configFile)
511 bb_simple_perror_msg_and_die(opt_c_configFile);
512 /* else: no -c, thus we looked at /etc/httpd.conf,
513 * and it's not there. try ./httpd.conf: */
514 }
515 flag = TRY_CURDIR_PARSE;
516 filename = HTTPD_CONF;
517 }
518
519#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
520 /* in "/file:user:pass" lines, we prepend path in subdirs */
521 if (flag != SUBDIR_PARSE)
522 path = "";
523#endif
524 /* The lines can be:
525 *
526 * I:default_index_file
527 * H:http_home
528 * [AD]:IP[/mask] # allow/deny, * for wildcard
529 * Ennn:error.html # error page for status nnn
530 * P:/url:[http://]hostname[:port]/new/path # reverse proxy
531 * .ext:mime/type # mime type
532 * *.php:/path/php # run xxx.php through an interpreter
533 * /file:user:pass # username and password
534 */
535 while (fgets(buf, sizeof(buf), f) != NULL) {
536 unsigned strlen_buf;
537 unsigned char ch;
538 char *after_colon;
539
540 { /* remove all whitespace, and # comments */
541 char *p, *p0;
542
543 p0 = buf;
544 /* skip non-whitespace beginning. Often the whole line
545 * is non-whitespace. We want this case to work fast,
546 * without needless copying, therefore we don't merge
547 * this operation into next while loop. */
548 while ((ch = *p0) != '\0' && ch != '\n' && ch != '#'
549 && ch != ' ' && ch != '\t'
550 ) {
551 p0++;
552 }
553 p = p0;
554 /* if we enter this loop, we have some whitespace.
555 * discard it */
556 while (ch != '\0' && ch != '\n' && ch != '#') {
557 if (ch != ' ' && ch != '\t') {
558 *p++ = ch;
559 }
560 ch = *++p0;
561 }
562 *p = '\0';
563 strlen_buf = p - buf;
564 if (strlen_buf == 0)
565 continue; /* empty line */
566 }
567
568 after_colon = strchr(buf, ':');
569 /* strange line? */
570 if (after_colon == NULL || *++after_colon == '\0')
571 goto config_error;
572
573 ch = (buf[0] & ~0x20); /* toupper if it's a letter */
574
575 if (ch == 'I') {
576 if (index_page != index_html)
577 free((char*)index_page);
578 index_page = xstrdup(after_colon);
579 continue;
580 }
581
582 /* do not allow jumping around using H in subdir's configs */
583 if (flag == FIRST_PARSE && ch == 'H') {
584 home_httpd = xstrdup(after_colon);
585 xchdir(home_httpd);
586 continue;
587 }
588
589 if (ch == 'A' || ch == 'D') {
590 Htaccess_IP *pip;
591
592 if (*after_colon == '*') {
593 if (ch == 'D') {
594 /* memorize "deny all" */
595 flg_deny_all = 1;
596 }
597 /* skip assumed "A:*", it is a default anyway */
598 continue;
599 }
600 /* store "allow/deny IP/mask" line */
601 pip = xzalloc(sizeof(*pip));
602 if (scan_ip_mask(after_colon, &pip->ip, &pip->mask)) {
603 /* IP{/mask} syntax error detected, protect all */
604 ch = 'D';
605 pip->mask = 0;
606 }
607 pip->allow_deny = ch;
608 if (ch == 'D') {
609 /* Deny:from_IP - prepend */
610 pip->next = ip_a_d;
611 ip_a_d = pip;
612 } else {
613 /* A:from_IP - append (thus all D's precedes A's) */
614 Htaccess_IP *prev_IP = ip_a_d;
615 if (prev_IP == NULL) {
616 ip_a_d = pip;
617 } else {
618 while (prev_IP->next)
619 prev_IP = prev_IP->next;
620 prev_IP->next = pip;
621 }
622 }
623 continue;
624 }
625
626#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
627 if (flag == FIRST_PARSE && ch == 'E') {
628 unsigned i;
629 int status = atoi(buf + 1); /* error status code */
630
631 if (status < HTTP_CONTINUE) {
632 goto config_error;
633 }
634 /* then error page; find matching status */
635 for (i = 0; i < ARRAY_SIZE(http_response_type); i++) {
636 if (http_response_type[i] == status) {
637 /* We chdir to home_httpd, thus no need to
638 * concat_path_file(home_httpd, after_colon)
639 * here */
640 http_error_page[i] = xstrdup(after_colon);
641 break;
642 }
643 }
644 continue;
645 }
646#endif
647
648#if ENABLE_FEATURE_HTTPD_PROXY
649 if (flag == FIRST_PARSE && ch == 'P') {
650 /* P:/url:[http://]hostname[:port]/new/path */
651 char *url_from, *host_port, *url_to;
652 Htaccess_Proxy *proxy_entry;
653
654 url_from = after_colon;
655 host_port = strchr(after_colon, ':');
656 if (host_port == NULL) {
657 goto config_error;
658 }
659 *host_port++ = '\0';
660 if (strncmp(host_port, "http://", 7) == 0)
661 host_port += 7;
662 if (*host_port == '\0') {
663 goto config_error;
664 }
665 url_to = strchr(host_port, '/');
666 if (url_to == NULL) {
667 goto config_error;
668 }
669 *url_to = '\0';
670 proxy_entry = xzalloc(sizeof(*proxy_entry));
671 proxy_entry->url_from = xstrdup(url_from);
672 proxy_entry->host_port = xstrdup(host_port);
673 *url_to = '/';
674 proxy_entry->url_to = xstrdup(url_to);
675 proxy_entry->next = proxy;
676 proxy = proxy_entry;
677 continue;
678 }
679#endif
680 /* the rest of directives are non-alphabetic,
681 * must avoid using "toupper'ed" ch */
682 ch = buf[0];
683
684 if (ch == '.' /* ".ext:mime/type" */
685#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
686 || (ch == '*' && buf[1] == '.') /* "*.php:/path/php" */
687#endif
688 ) {
689 char *p;
690 Htaccess *cur;
691
692 cur = xzalloc(sizeof(*cur) /* includes space for NUL */ + strlen_buf);
693 strcpy(cur->before_colon, buf);
694 p = cur->before_colon + (after_colon - buf);
695 p[-1] = '\0';
696 cur->after_colon = p;
697 if (ch == '.') {
698 /* .mime line: prepend to mime_a list */
699 cur->next = mime_a;
700 mime_a = cur;
701 }
702#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
703 else {
704 /* script interpreter line: prepend to script_i list */
705 cur->next = script_i;
706 script_i = cur;
707 }
708#endif
709 continue;
710 }
711
712#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
713 if (ch == '/') { /* "/file:user:pass" */
714 char *p;
715 Htaccess *cur;
716 unsigned file_len;
717
718 /* note: path is "" unless we are in SUBDIR parse,
719 * otherwise it does NOT start with "/" */
720 cur = xzalloc(sizeof(*cur) /* includes space for NUL */
721 + 1 + strlen(path)
722 + strlen_buf
723 );
724 /* form "/path/file" */
725 sprintf(cur->before_colon, "/%s%.*s",
726 path,
727 (int) (after_colon - buf - 1), /* includes "/", but not ":" */
728 buf);
729 /* canonicalize it */
730 p = bb_simplify_abs_path_inplace(cur->before_colon);
731 file_len = p - cur->before_colon;
732 /* add "user:pass" after NUL */
733 strcpy(++p, after_colon);
734 cur->after_colon = p;
735
736 /* insert cur into g_auth */
737 /* g_auth is sorted by decreased filename length */
738 {
739 Htaccess *auth, **authp;
740
741 authp = &g_auth;
742 while ((auth = *authp) != NULL) {
743 if (file_len >= strlen(auth->before_colon)) {
744 /* insert cur before auth */
745 cur->next = auth;
746 break;
747 }
748 authp = &auth->next;
749 }
750 *authp = cur;
751 }
752 continue;
753 }
754#endif /* BASIC_AUTH */
755
756 /* the line is not recognized */
757 config_error:
758 bb_error_msg("config error '%s' in '%s'", buf, filename);
759 } /* while (fgets) */
760
761 fclose(f);
762}
763
764#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
765/*
766 * Given a string, html-encode special characters.
767 * This is used for the -e command line option to provide an easy way
768 * for scripts to encode result data without confusing browsers. The
769 * returned string pointer is memory allocated by malloc().
770 *
771 * Returns a pointer to the encoded string (malloced).
772 */
773static char *encodeString(const char *string)
774{
775 /* take the simple route and encode everything */
776 /* could possibly scan once to get length. */
777 int len = strlen(string);
778 char *out = xmalloc(len * 6 + 1);
779 char *p = out;
780 char ch;
781
782 while ((ch = *string++) != '\0') {
783 /* very simple check for what to encode */
784 if (isalnum(ch))
785 *p++ = ch;
786 else
787 p += sprintf(p, "&#%d;", (unsigned char) ch);
788 }
789 *p = '\0';
790 return out;
791}
792#endif
793
794/*
795 * Given a URL encoded string, convert it to plain ascii.
796 * Since decoding always makes strings smaller, the decode is done in-place.
797 * Thus, callers should xstrdup() the argument if they do not want the
798 * argument modified. The return is the original pointer, allowing this
799 * function to be easily used as arguments to other functions.
800 *
801 * string The first string to decode.
802 * option_d 1 if called for httpd -d
803 *
804 * Returns a pointer to the decoded string (same as input).
805 */
806static unsigned hex_to_bin(unsigned char c)
807{
808 unsigned v;
809
810 v = c - '0';
811 if (v <= 9)
812 return v;
813 /* c | 0x20: letters to lower case, non-letters
814 * to (potentially different) non-letters */
815 v = (unsigned)(c | 0x20) - 'a';
816 if (v <= 5)
817 return v + 10;
818 return ~0;
819/* For testing:
820void t(char c) { printf("'%c'(%u) %u\n", c, c, hex_to_bin(c)); }
821int main() { t(0x10); t(0x20); t('0'); t('9'); t('A'); t('F'); t('a'); t('f');
822t('0'-1); t('9'+1); t('A'-1); t('F'+1); t('a'-1); t('f'+1); return 0; }
823*/
824}
825static char *decodeString(char *orig, int option_d)
826{
827 /* note that decoded string is always shorter than original */
828 char *string = orig;
829 char *ptr = string;
830 char c;
831
832 while ((c = *ptr++) != '\0') {
833 unsigned v;
834
835 if (option_d && c == '+') {
836 *string++ = ' ';
837 continue;
838 }
839 if (c != '%') {
840 *string++ = c;
841 continue;
842 }
843 v = hex_to_bin(ptr[0]);
844 if (v > 15) {
845 bad_hex:
846 if (!option_d)
847 return NULL;
848 *string++ = '%';
849 continue;
850 }
851 v = (v * 16) | hex_to_bin(ptr[1]);
852 if (v > 255)
853 goto bad_hex;
854 if (!option_d && (v == '/' || v == '\0')) {
855 /* caller takes it as indication of invalid
856 * (dangerous wrt exploits) chars */
857 return orig + 1;
858 }
859 *string++ = v;
860 ptr += 2;
861 }
862 *string = '\0';
863 return orig;
864}
865
866#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
867/*
868 * Decode a base64 data stream as per rfc1521.
869 * Note that the rfc states that non base64 chars are to be ignored.
870 * Since the decode always results in a shorter size than the input,
871 * it is OK to pass the input arg as an output arg.
872 * Parameter: a pointer to a base64 encoded string.
873 * Decoded data is stored in-place.
874 */
875static void decodeBase64(char *Data)
876{
877 const unsigned char *in = (const unsigned char *)Data;
878 /* The decoded size will be at most 3/4 the size of the encoded */
879 unsigned ch = 0;
880 int i = 0;
881
882 while (*in) {
883 int t = *in++;
884
885 if (t >= '0' && t <= '9')
886 t = t - '0' + 52;
887 else if (t >= 'A' && t <= 'Z')
888 t = t - 'A';
889 else if (t >= 'a' && t <= 'z')
890 t = t - 'a' + 26;
891 else if (t == '+')
892 t = 62;
893 else if (t == '/')
894 t = 63;
895 else if (t == '=')
896 t = 0;
897 else
898 continue;
899
900 ch = (ch << 6) | t;
901 i++;
902 if (i == 4) {
903 *Data++ = (char) (ch >> 16);
904 *Data++ = (char) (ch >> 8);
905 *Data++ = (char) ch;
906 i = 0;
907 }
908 }
909 *Data = '\0';
910}
911#endif
912
913/*
914 * Create a listen server socket on the designated port.
915 */
916static int openServer(void)
917{
918 unsigned n = bb_strtou(bind_addr_or_port, NULL, 10);
919 if (!errno && n && n <= 0xffff)
920 n = create_and_bind_stream_or_die(NULL, n);
921 else
922 n = create_and_bind_stream_or_die(bind_addr_or_port, 80);
923 xlisten(n, 9);
924 return n;
925}
926
927/*
928 * Log the connection closure and exit.
929 */
930static void log_and_exit(void) NORETURN;
931static void log_and_exit(void)
932{
933 /* Paranoia. IE said to be buggy. It may send some extra data
934 * or be confused by us just exiting without SHUT_WR. Oh well. */
935 shutdown(1, SHUT_WR);
936 /* Why??
937 (this also messes up stdin when user runs httpd -i from terminal)
938 ndelay_on(0);
939 while (read(STDIN_FILENO, iobuf, IOBUF_SIZE) > 0)
940 continue;
941 */
942
943 if (verbose > 2)
944 bb_error_msg("closed");
945 _exit(xfunc_error_retval);
946}
947
948/*
949 * Create and send HTTP response headers.
950 * The arguments are combined and sent as one write operation. Note that
951 * IE will puke big-time if the headers are not sent in one packet and the
952 * second packet is delayed for any reason.
953 * responseNum - the result code to send.
954 */
955static void send_headers(int responseNum)
956{
957 static const char RFC1123FMT[] ALIGN1 = "%a, %d %b %Y %H:%M:%S GMT";
958
959 const char *responseString = "";
960 const char *infoString = NULL;
961 const char *mime_type;
962#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
963 const char *error_page = NULL;
964#endif
965 unsigned i;
966 time_t timer = time(NULL);
967 char tmp_str[80];
968 int len;
969
970 for (i = 0; i < ARRAY_SIZE(http_response_type); i++) {
971 if (http_response_type[i] == responseNum) {
972 responseString = http_response[i].name;
973 infoString = http_response[i].info;
974#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
975 error_page = http_error_page[i];
976#endif
977 break;
978 }
979 }
980 /* error message is HTML */
981 mime_type = responseNum == HTTP_OK ?
982 found_mime_type : "text/html";
983
984 if (verbose)
985 bb_error_msg("response:%u", responseNum);
986
987 /* emit the current date */
988 strftime(tmp_str, sizeof(tmp_str), RFC1123FMT, gmtime(&timer));
989 len = sprintf(iobuf,
990 "HTTP/1.0 %d %s\r\nContent-type: %s\r\n"
991 "Date: %s\r\nConnection: close\r\n",
992 responseNum, responseString, mime_type, tmp_str);
993
994#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
995 if (responseNum == HTTP_UNAUTHORIZED) {
996 len += sprintf(iobuf + len,
997 "WWW-Authenticate: Basic realm=\"%s\"\r\n",
998 g_realm);
999 }
1000#endif
1001 if (responseNum == HTTP_MOVED_TEMPORARILY) {
1002 len += sprintf(iobuf + len, "Location: %s/%s%s\r\n",
1003 found_moved_temporarily,
1004 (g_query ? "?" : ""),
1005 (g_query ? g_query : ""));
1006 }
1007
1008#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
1009 if (error_page && access(error_page, R_OK) == 0) {
1010 strcat(iobuf, "\r\n");
1011 len += 2;
1012
1013 if (DEBUG)
1014 fprintf(stderr, "headers: '%s'\n", iobuf);
1015 full_write(STDOUT_FILENO, iobuf, len);
1016 if (DEBUG)
1017 fprintf(stderr, "writing error page: '%s'\n", error_page);
1018 return send_file_and_exit(error_page, SEND_BODY);
1019 }
1020#endif
1021
1022 if (file_size != -1) { /* file */
1023 strftime(tmp_str, sizeof(tmp_str), RFC1123FMT, gmtime(&last_mod));
1024#if ENABLE_FEATURE_HTTPD_RANGES
1025 if (responseNum == HTTP_PARTIAL_CONTENT) {
1026 len += sprintf(iobuf + len, "Content-Range: bytes %"OFF_FMT"u-%"OFF_FMT"u/%"OFF_FMT"u\r\n",
1027 range_start,
1028 range_end,
1029 file_size);
1030 file_size = range_end - range_start + 1;
1031 }
1032#endif
1033 len += sprintf(iobuf + len,
1034#if ENABLE_FEATURE_HTTPD_RANGES
1035 "Accept-Ranges: bytes\r\n"
1036#endif
1037 "Last-Modified: %s\r\n%s %"OFF_FMT"u\r\n",
1038 tmp_str,
1039 content_gzip ? "Transfer-length:" : "Content-length:",
1040 file_size
1041 );
1042 }
1043
1044 if (content_gzip)
1045 len += sprintf(iobuf + len, "Content-Encoding: gzip\r\n");
1046
1047 iobuf[len++] = '\r';
1048 iobuf[len++] = '\n';
1049 if (infoString) {
1050 len += sprintf(iobuf + len,
1051 "<HTML><HEAD><TITLE>%d %s</TITLE></HEAD>\n"
1052 "<BODY><H1>%d %s</H1>\n%s\n</BODY></HTML>\n",
1053 responseNum, responseString,
1054 responseNum, responseString, infoString);
1055 }
1056 if (DEBUG)
1057 fprintf(stderr, "headers: '%s'\n", iobuf);
1058 if (full_write(STDOUT_FILENO, iobuf, len) != len) {
1059 if (verbose > 1)
1060 bb_perror_msg("error");
1061 log_and_exit();
1062 }
1063}
1064
1065static void send_headers_and_exit(int responseNum) NORETURN;
1066static void send_headers_and_exit(int responseNum)
1067{
1068 send_headers(responseNum);
1069 log_and_exit();
1070}
1071
1072/*
1073 * Read from the socket until '\n' or EOF. '\r' chars are removed.
1074 * '\n' is replaced with NUL.
1075 * Return number of characters read or 0 if nothing is read
1076 * ('\r' and '\n' are not counted).
1077 * Data is returned in iobuf.
1078 */
1079static int get_line(void)
1080{
1081 int count = 0;
1082 char c;
1083
1084 alarm(HEADER_READ_TIMEOUT);
1085 while (1) {
1086 if (hdr_cnt <= 0) {
1087 hdr_cnt = safe_read(STDIN_FILENO, hdr_buf, sizeof(hdr_buf));
1088 if (hdr_cnt <= 0)
1089 break;
1090 hdr_ptr = hdr_buf;
1091 }
1092 iobuf[count] = c = *hdr_ptr++;
1093 hdr_cnt--;
1094
1095 if (c == '\r')
1096 continue;
1097 if (c == '\n') {
1098 iobuf[count] = '\0';
1099 break;
1100 }
1101 if (count < (IOBUF_SIZE - 1)) /* check overflow */
1102 count++;
1103 }
1104 return count;
1105}
1106
1107#if ENABLE_FEATURE_HTTPD_CGI || ENABLE_FEATURE_HTTPD_PROXY
1108
1109/* gcc 4.2.1 fares better with NOINLINE */
1110static NOINLINE void cgi_io_loop_and_exit(int fromCgi_rd, int toCgi_wr, int post_len) NORETURN;
1111static NOINLINE void cgi_io_loop_and_exit(int fromCgi_rd, int toCgi_wr, int post_len)
1112{
1113 enum { FROM_CGI = 1, TO_CGI = 2 }; /* indexes in pfd[] */
1114 struct pollfd pfd[3];
1115 int out_cnt; /* we buffer a bit of initial CGI output */
1116 int count;
1117
1118 /* iobuf is used for CGI -> network data,
1119 * hdr_buf is for network -> CGI data (POSTDATA) */
1120
1121 /* If CGI dies, we still want to correctly finish reading its output
1122 * and send it to the peer. So please no SIGPIPEs! */
1123 signal(SIGPIPE, SIG_IGN);
1124
1125 // We inconsistently handle a case when more POSTDATA from network
1126 // is coming than we expected. We may give *some part* of that
1127 // extra data to CGI.
1128
1129 //if (hdr_cnt > post_len) {
1130 // /* We got more POSTDATA from network than we expected */
1131 // hdr_cnt = post_len;
1132 //}
1133 post_len -= hdr_cnt;
1134 /* post_len - number of POST bytes not yet read from network */
1135
1136 /* NB: breaking out of this loop jumps to log_and_exit() */
1137 out_cnt = 0;
1138 while (1) {
1139 memset(pfd, 0, sizeof(pfd));
1140
1141 pfd[FROM_CGI].fd = fromCgi_rd;
1142 pfd[FROM_CGI].events = POLLIN;
1143
1144 if (toCgi_wr) {
1145 pfd[TO_CGI].fd = toCgi_wr;
1146 if (hdr_cnt > 0) {
1147 pfd[TO_CGI].events = POLLOUT;
1148 } else if (post_len > 0) {
1149 pfd[0].events = POLLIN;
1150 } else {
1151 /* post_len <= 0 && hdr_cnt <= 0:
1152 * no more POST data to CGI,
1153 * let CGI see EOF on CGI's stdin */
1154 if (toCgi_wr != fromCgi_rd)
1155 close(toCgi_wr);
1156 toCgi_wr = 0;
1157 }
1158 }
1159
1160 /* Now wait on the set of sockets */
1161 count = safe_poll(pfd, toCgi_wr ? TO_CGI+1 : FROM_CGI+1, -1);
1162 if (count <= 0) {
1163#if 0
1164 if (safe_waitpid(pid, &status, WNOHANG) <= 0) {
1165 /* Weird. CGI didn't exit and no fd's
1166 * are ready, yet poll returned?! */
1167 continue;
1168 }
1169 if (DEBUG && WIFEXITED(status))
1170 bb_error_msg("CGI exited, status=%d", WEXITSTATUS(status));
1171 if (DEBUG && WIFSIGNALED(status))
1172 bb_error_msg("CGI killed, signal=%d", WTERMSIG(status));
1173#endif
1174 break;
1175 }
1176
1177 if (pfd[TO_CGI].revents) {
1178 /* hdr_cnt > 0 here due to the way pfd[TO_CGI].events set */
1179 /* Have data from peer and can write to CGI */
1180 count = safe_write(toCgi_wr, hdr_ptr, hdr_cnt);
1181 /* Doesn't happen, we dont use nonblocking IO here
1182 *if (count < 0 && errno == EAGAIN) {
1183 * ...
1184 *} else */
1185 if (count > 0) {
1186 hdr_ptr += count;
1187 hdr_cnt -= count;
1188 } else {
1189 /* EOF/broken pipe to CGI, stop piping POST data */
1190 hdr_cnt = post_len = 0;
1191 }
1192 }
1193
1194 if (pfd[0].revents) {
1195 /* post_len > 0 && hdr_cnt == 0 here */
1196 /* We expect data, prev data portion is eaten by CGI
1197 * and there *is* data to read from the peer
1198 * (POSTDATA) */
1199 //count = post_len > (int)sizeof(hdr_buf) ? (int)sizeof(hdr_buf) : post_len;
1200 //count = safe_read(STDIN_FILENO, hdr_buf, count);
1201 count = safe_read(STDIN_FILENO, hdr_buf, sizeof(hdr_buf));
1202 if (count > 0) {
1203 hdr_cnt = count;
1204 hdr_ptr = hdr_buf;
1205 post_len -= count;
1206 } else {
1207 /* no more POST data can be read */
1208 post_len = 0;
1209 }
1210 }
1211
1212 if (pfd[FROM_CGI].revents) {
1213 /* There is something to read from CGI */
1214 char *rbuf = iobuf;
1215
1216 /* Are we still buffering CGI output? */
1217 if (out_cnt >= 0) {
1218 /* HTTP_200[] has single "\r\n" at the end.
1219 * According to http://hoohoo.ncsa.uiuc.edu/cgi/out.html,
1220 * CGI scripts MUST send their own header terminated by
1221 * empty line, then data. That's why we have only one
1222 * <cr><lf> pair here. We will output "200 OK" line
1223 * if needed, but CGI still has to provide blank line
1224 * between header and body */
1225
1226 /* Must use safe_read, not full_read, because
1227 * CGI may output a few first bytes and then wait
1228 * for POSTDATA without closing stdout.
1229 * With full_read we may wait here forever. */
1230 count = safe_read(fromCgi_rd, rbuf + out_cnt, PIPE_BUF - 8);
1231 if (count <= 0) {
1232 /* eof (or error) and there was no "HTTP",
1233 * so write it, then write received data */
1234 if (out_cnt) {
1235 full_write(STDOUT_FILENO, HTTP_200, sizeof(HTTP_200)-1);
1236 full_write(STDOUT_FILENO, rbuf, out_cnt);
1237 }
1238 break; /* CGI stdout is closed, exiting */
1239 }
1240 out_cnt += count;
1241 count = 0;
1242 /* "Status" header format is: "Status: 302 Redirected\r\n" */
1243 if (out_cnt >= 8 && memcmp(rbuf, "Status: ", 8) == 0) {
1244 /* send "HTTP/1.0 " */
1245 if (full_write(STDOUT_FILENO, HTTP_200, 9) != 9)
1246 break;
1247 rbuf += 8; /* skip "Status: " */
1248 count = out_cnt - 8;
1249 out_cnt = -1; /* buffering off */
1250 } else if (out_cnt >= 4) {
1251 /* Did CGI add "HTTP"? */
1252 if (memcmp(rbuf, HTTP_200, 4) != 0) {
1253 /* there is no "HTTP", do it ourself */
1254 if (full_write(STDOUT_FILENO, HTTP_200, sizeof(HTTP_200)-1) != sizeof(HTTP_200)-1)
1255 break;
1256 }
1257 /* Commented out:
1258 if (!strstr(rbuf, "ontent-")) {
1259 full_write(s, "Content-type: text/plain\r\n\r\n", 28);
1260 }
1261 * Counter-example of valid CGI without Content-type:
1262 * echo -en "HTTP/1.0 302 Found\r\n"
1263 * echo -en "Location: http://www.busybox.net\r\n"
1264 * echo -en "\r\n"
1265 */
1266 count = out_cnt;
1267 out_cnt = -1; /* buffering off */
1268 }
1269 } else {
1270 count = safe_read(fromCgi_rd, rbuf, PIPE_BUF);
1271 if (count <= 0)
1272 break; /* eof (or error) */
1273 }
1274 if (full_write(STDOUT_FILENO, rbuf, count) != count)
1275 break;
1276 if (DEBUG)
1277 fprintf(stderr, "cgi read %d bytes: '%.*s'\n", count, count, rbuf);
1278 } /* if (pfd[FROM_CGI].revents) */
1279 } /* while (1) */
1280 log_and_exit();
1281}
1282#endif
1283
1284#if ENABLE_FEATURE_HTTPD_CGI
1285
1286static void setenv1(const char *name, const char *value)
1287{
1288 setenv(name, value ? value : "", 1);
1289}
1290
1291/*
1292 * Spawn CGI script, forward CGI's stdin/out <=> network
1293 *
1294 * Environment variables are set up and the script is invoked with pipes
1295 * for stdin/stdout. If a POST is being done the script is fed the POST
1296 * data in addition to setting the QUERY_STRING variable (for GETs or POSTs).
1297 *
1298 * Parameters:
1299 * const char *url The requested URL (with leading /).
1300 * int post_len Length of the POST body.
1301 * const char *cookie For set HTTP_COOKIE.
1302 * const char *content_type For set CONTENT_TYPE.
1303 */
1304static void send_cgi_and_exit(
1305 const char *url,
1306 const char *request,
1307 int post_len,
1308 const char *cookie,
1309 const char *content_type) NORETURN;
1310static void send_cgi_and_exit(
1311 const char *url,
1312 const char *request,
1313 int post_len,
1314 const char *cookie,
1315 const char *content_type)
1316{
1317 struct fd_pair fromCgi; /* CGI -> httpd pipe */
1318 struct fd_pair toCgi; /* httpd -> CGI pipe */
1319 char *script;
1320 int pid;
1321
1322 /* Make a copy. NB: caller guarantees:
1323 * url[0] == '/', url[1] != '/' */
1324 url = xstrdup(url);
1325
1326 /*
1327 * We are mucking with environment _first_ and then vfork/exec,
1328 * this allows us to use vfork safely. Parent doesn't care about
1329 * these environment changes anyway.
1330 */
1331
1332 /* Check for [dirs/]script.cgi/PATH_INFO */
1333 script = (char*)url;
1334 while ((script = strchr(script + 1, '/')) != NULL) {
1335 *script = '\0';
1336 if (!is_directory(url + 1, 1, NULL)) {
1337 /* not directory, found script.cgi/PATH_INFO */
1338 *script = '/';
1339 break;
1340 }
1341 *script = '/'; /* is directory, find next '/' */
1342 }
1343 setenv1("PATH_INFO", script); /* set to /PATH_INFO or "" */
1344 setenv1("REQUEST_METHOD", request);
1345 if (g_query) {
1346 putenv(xasprintf("%s=%s?%s", "REQUEST_URI", url, g_query));
1347 } else {
1348 setenv1("REQUEST_URI", url);
1349 }
1350 if (script != NULL)
1351 *script = '\0'; /* cut off /PATH_INFO */
1352
1353 /* SCRIPT_FILENAME is required by PHP in CGI mode */
1354 if (home_httpd[0] == '/') {
1355 char *fullpath = concat_path_file(home_httpd, url);
1356 setenv1("SCRIPT_FILENAME", fullpath);
1357 }
1358 /* set SCRIPT_NAME as full path: /cgi-bin/dirs/script.cgi */
1359 setenv1("SCRIPT_NAME", url);
1360 /* http://hoohoo.ncsa.uiuc.edu/cgi/env.html:
1361 * QUERY_STRING: The information which follows the ? in the URL
1362 * which referenced this script. This is the query information.
1363 * It should not be decoded in any fashion. This variable
1364 * should always be set when there is query information,
1365 * regardless of command line decoding. */
1366 /* (Older versions of bbox seem to do some decoding) */
1367 setenv1("QUERY_STRING", g_query);
1368 putenv((char*)"SERVER_SOFTWARE=busybox httpd/"BB_VER);
1369 putenv((char*)"SERVER_PROTOCOL=HTTP/1.0");
1370 putenv((char*)"GATEWAY_INTERFACE=CGI/1.1");
1371 /* Having _separate_ variables for IP and port defeats
1372 * the purpose of having socket abstraction. Which "port"
1373 * are you using on Unix domain socket?
1374 * IOW - REMOTE_PEER="1.2.3.4:56" makes much more sense.
1375 * Oh well... */
1376 {
1377 char *p = rmt_ip_str ? rmt_ip_str : (char*)"";
1378 char *cp = strrchr(p, ':');
1379 if (ENABLE_FEATURE_IPV6 && cp && strchr(cp, ']'))
1380 cp = NULL;
1381 if (cp) *cp = '\0'; /* delete :PORT */
1382 setenv1("REMOTE_ADDR", p);
1383 if (cp) {
1384 *cp = ':';
1385#if ENABLE_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
1386 setenv1("REMOTE_PORT", cp + 1);
1387#endif
1388 }
1389 }
1390 setenv1("HTTP_USER_AGENT", user_agent);
1391 if (http_accept)
1392 setenv1("HTTP_ACCEPT", http_accept);
1393 if (http_accept_language)
1394 setenv1("HTTP_ACCEPT_LANGUAGE", http_accept_language);
1395 if (post_len)
1396 putenv(xasprintf("CONTENT_LENGTH=%d", post_len));
1397 if (cookie)
1398 setenv1("HTTP_COOKIE", cookie);
1399 if (content_type)
1400 setenv1("CONTENT_TYPE", content_type);
1401#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
1402 if (remoteuser) {
1403 setenv1("REMOTE_USER", remoteuser);
1404 putenv((char*)"AUTH_TYPE=Basic");
1405 }
1406#endif
1407 if (referer)
1408 setenv1("HTTP_REFERER", referer);
1409 setenv1("HTTP_HOST", host); /* set to "" if NULL */
1410 /* setenv1("SERVER_NAME", safe_gethostname()); - don't do this,
1411 * just run "env SERVER_NAME=xyz httpd ..." instead */
1412
1413 xpiped_pair(fromCgi);
1414 xpiped_pair(toCgi);
1415
1416 pid = vfork();
1417 if (pid < 0) {
1418 /* TODO: log perror? */
1419 log_and_exit();
1420 }
1421
1422 if (!pid) {
1423 /* Child process */
1424 char *argv[3];
1425
1426 xfunc_error_retval = 242;
1427
1428 /* NB: close _first_, then move fds! */
1429 close(toCgi.wr);
1430 close(fromCgi.rd);
1431 xmove_fd(toCgi.rd, 0); /* replace stdin with the pipe */
1432 xmove_fd(fromCgi.wr, 1); /* replace stdout with the pipe */
1433 /* User seeing stderr output can be a security problem.
1434 * If CGI really wants that, it can always do dup itself. */
1435 /* dup2(1, 2); */
1436
1437 /* Chdiring to script's dir */
1438 script = strrchr(url, '/');
1439 if (script != url) { /* paranoia */
1440 *script = '\0';
1441 if (chdir(url + 1) != 0) {
1442 bb_perror_msg("chdir(%s)", url + 1);
1443 goto error_execing_cgi;
1444 }
1445 // not needed: *script = '/';
1446 }
1447 script++;
1448
1449 /* set argv[0] to name without path */
1450 argv[0] = script;
1451 argv[1] = NULL;
1452
1453#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
1454 {
1455 char *suffix = strrchr(script, '.');
1456
1457 if (suffix) {
1458 Htaccess *cur;
1459 for (cur = script_i; cur; cur = cur->next) {
1460 if (strcmp(cur->before_colon + 1, suffix) == 0) {
1461 /* found interpreter name */
1462 argv[0] = cur->after_colon;
1463 argv[1] = script;
1464 argv[2] = NULL;
1465 break;
1466 }
1467 }
1468 }
1469 }
1470#endif
1471 /* restore default signal dispositions for CGI process */
1472 bb_signals(0
1473 | (1 << SIGCHLD)
1474 | (1 << SIGPIPE)
1475 | (1 << SIGHUP)
1476 , SIG_DFL);
1477
1478 /* _NOT_ execvp. We do not search PATH. argv[0] is a filename
1479 * without any dir components and will only match a file
1480 * in the current directory */
1481 execv(argv[0], argv);
1482 if (verbose)
1483 bb_perror_msg("can't execute '%s'", argv[0]);
1484 error_execing_cgi:
1485 /* send to stdout
1486 * (we are CGI here, our stdout is pumped to the net) */
1487 send_headers_and_exit(HTTP_NOT_FOUND);
1488 } /* end child */
1489
1490 /* Parent process */
1491
1492 /* Restore variables possibly changed by child */
1493 xfunc_error_retval = 0;
1494
1495 /* Pump data */
1496 close(fromCgi.wr);
1497 close(toCgi.rd);
1498 cgi_io_loop_and_exit(fromCgi.rd, toCgi.wr, post_len);
1499}
1500
1501#endif /* FEATURE_HTTPD_CGI */
1502
1503/*
1504 * Send a file response to a HTTP request, and exit
1505 *
1506 * Parameters:
1507 * const char *url The requested URL (with leading /).
1508 * what What to send (headers/body/both).
1509 */
1510static NOINLINE void send_file_and_exit(const char *url, int what)
1511{
1512 char *suffix;
1513 int fd;
1514 ssize_t count;
1515
1516 if (content_gzip) {
1517 /* does <url>.gz exist? Then use it instead */
1518 char *gzurl = xasprintf("%s.gz", url);
1519 fd = open(gzurl, O_RDONLY);
1520 free(gzurl);
1521 if (fd != -1) {
1522 struct stat sb;
1523 fstat(fd, &sb);
1524 file_size = sb.st_size;
1525 last_mod = sb.st_mtime;
1526 } else {
1527 IF_FEATURE_HTTPD_GZIP(content_gzip = 0;)
1528 fd = open(url, O_RDONLY);
1529 }
1530 } else {
1531 fd = open(url, O_RDONLY);
1532 }
1533 if (fd < 0) {
1534 if (DEBUG)
1535 bb_perror_msg("can't open '%s'", url);
1536 /* Error pages are sent by using send_file_and_exit(SEND_BODY).
1537 * IOW: it is unsafe to call send_headers_and_exit
1538 * if what is SEND_BODY! Can recurse! */
1539 if (what != SEND_BODY)
1540 send_headers_and_exit(HTTP_NOT_FOUND);
1541 log_and_exit();
1542 }
1543 /* If you want to know about EPIPE below
1544 * (happens if you abort downloads from local httpd): */
1545 signal(SIGPIPE, SIG_IGN);
1546
1547 /* If not found, default is "application/octet-stream" */
1548 found_mime_type = "application/octet-stream";
1549 suffix = strrchr(url, '.');
1550 if (suffix) {
1551 static const char suffixTable[] ALIGN1 =
1552 /* Shorter suffix must be first:
1553 * ".html.htm" will fail for ".htm"
1554 */
1555 ".txt.h.c.cc.cpp\0" "text/plain\0"
1556 /* .htm line must be after .h line */
1557 ".htm.html\0" "text/html\0"
1558 ".jpg.jpeg\0" "image/jpeg\0"
1559 ".gif\0" "image/gif\0"
1560 ".png\0" "image/png\0"
1561 /* .css line must be after .c line */
1562 ".css\0" "text/css\0"
1563 ".wav\0" "audio/wav\0"
1564 ".avi\0" "video/x-msvideo\0"
1565 ".qt.mov\0" "video/quicktime\0"
1566 ".mpe.mpeg\0" "video/mpeg\0"
1567 ".mid.midi\0" "audio/midi\0"
1568 ".mp3\0" "audio/mpeg\0"
1569#if 0 /* unpopular */
1570 ".au\0" "audio/basic\0"
1571 ".pac\0" "application/x-ns-proxy-autoconfig\0"
1572 ".vrml.wrl\0" "model/vrml\0"
1573#endif
1574 /* compiler adds another "\0" here */
1575 ;
1576 Htaccess *cur;
1577
1578 /* Examine built-in table */
1579 const char *table = suffixTable;
1580 const char *table_next;
1581 for (; *table; table = table_next) {
1582 const char *try_suffix;
1583 const char *mime_type;
1584 mime_type = table + strlen(table) + 1;
1585 table_next = mime_type + strlen(mime_type) + 1;
1586 try_suffix = strstr(table, suffix);
1587 if (!try_suffix)
1588 continue;
1589 try_suffix += strlen(suffix);
1590 if (*try_suffix == '\0' || *try_suffix == '.') {
1591 found_mime_type = mime_type;
1592 break;
1593 }
1594 /* Example: strstr(table, ".av") != NULL, but it
1595 * does not match ".avi" after all and we end up here.
1596 * The table is arranged so that in this case we know
1597 * that it can't match anything in the following lines,
1598 * and we stop the search: */
1599 break;
1600 }
1601 /* ...then user's table */
1602 for (cur = mime_a; cur; cur = cur->next) {
1603 if (strcmp(cur->before_colon, suffix) == 0) {
1604 found_mime_type = cur->after_colon;
1605 break;
1606 }
1607 }
1608 }
1609
1610 if (DEBUG)
1611 bb_error_msg("sending file '%s' content-type: %s",
1612 url, found_mime_type);
1613
1614#if ENABLE_FEATURE_HTTPD_RANGES
1615 if (what == SEND_BODY /* err pages and ranges don't mix */
1616 || content_gzip /* we are sending compressed page: can't do ranges */ ///why?
1617 ) {
1618 range_start = 0;
1619 }
1620 range_len = MAXINT(off_t);
1621 if (range_start) {
1622 if (!range_end) {
1623 range_end = file_size - 1;
1624 }
1625 if (range_end < range_start
1626 || lseek(fd, range_start, SEEK_SET) != range_start
1627 ) {
1628 lseek(fd, 0, SEEK_SET);
1629 range_start = 0;
1630 } else {
1631 range_len = range_end - range_start + 1;
1632 send_headers(HTTP_PARTIAL_CONTENT);
1633 what = SEND_BODY;
1634 }
1635 }
1636#endif
1637 if (what & SEND_HEADERS)
1638 send_headers(HTTP_OK);
1639#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
1640 {
1641 off_t offset = range_start;
1642 while (1) {
1643 /* sz is rounded down to 64k */
1644 ssize_t sz = MAXINT(ssize_t) - 0xffff;
1645 IF_FEATURE_HTTPD_RANGES(if (sz > range_len) sz = range_len;)
1646 count = sendfile(STDOUT_FILENO, fd, &offset, sz);
1647 if (count < 0) {
1648 if (offset == range_start)
1649 break; /* fall back to read/write loop */
1650 goto fin;
1651 }
1652 IF_FEATURE_HTTPD_RANGES(range_len -= sz;)
1653 if (count == 0 || range_len == 0)
1654 log_and_exit();
1655 }
1656 }
1657#endif
1658 while ((count = safe_read(fd, iobuf, IOBUF_SIZE)) > 0) {
1659 ssize_t n;
1660 IF_FEATURE_HTTPD_RANGES(if (count > range_len) count = range_len;)
1661 n = full_write(STDOUT_FILENO, iobuf, count);
1662 if (count != n)
1663 break;
1664 IF_FEATURE_HTTPD_RANGES(range_len -= count;)
1665 if (range_len == 0)
1666 break;
1667 }
1668 if (count < 0) {
1669 IF_FEATURE_HTTPD_USE_SENDFILE(fin:)
1670 if (verbose > 1)
1671 bb_perror_msg("error");
1672 }
1673 log_and_exit();
1674}
1675
1676static int checkPermIP(void)
1677{
1678 Htaccess_IP *cur;
1679
1680 for (cur = ip_a_d; cur; cur = cur->next) {
1681#if DEBUG
1682 fprintf(stderr,
1683 "checkPermIP: '%s' ? '%u.%u.%u.%u/%u.%u.%u.%u'\n",
1684 rmt_ip_str,
1685 (unsigned char)(cur->ip >> 24),
1686 (unsigned char)(cur->ip >> 16),
1687 (unsigned char)(cur->ip >> 8),
1688 (unsigned char)(cur->ip),
1689 (unsigned char)(cur->mask >> 24),
1690 (unsigned char)(cur->mask >> 16),
1691 (unsigned char)(cur->mask >> 8),
1692 (unsigned char)(cur->mask)
1693 );
1694#endif
1695 if ((rmt_ip & cur->mask) == cur->ip)
1696 return (cur->allow_deny == 'A'); /* A -> 1 */
1697 }
1698
1699 return !flg_deny_all; /* depends on whether we saw "D:*" */
1700}
1701
1702#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
1703/*
1704 * Config file entries are of the form "/<path>:<user>:<passwd>".
1705 * If config file has no prefix match for path, access is allowed.
1706 *
1707 * path The file path
1708 * user_and_passwd "user:passwd" to validate
1709 *
1710 * Returns 1 if user_and_passwd is OK.
1711 */
1712static int check_user_passwd(const char *path, const char *user_and_passwd)
1713{
1714 Htaccess *cur;
1715 const char *prev = NULL;
1716
1717 for (cur = g_auth; cur; cur = cur->next) {
1718 const char *dir_prefix;
1719 size_t len;
1720
1721 dir_prefix = cur->before_colon;
1722
1723 /* WHY? */
1724 /* If already saw a match, don't accept other different matches */
1725 if (prev && strcmp(prev, dir_prefix) != 0)
1726 continue;
1727
1728 if (DEBUG)
1729 fprintf(stderr, "checkPerm: '%s' ? '%s'\n", dir_prefix, user_and_passwd);
1730
1731 /* If it's not a prefix match, continue searching */
1732 len = strlen(dir_prefix);
1733 if (len != 1 /* dir_prefix "/" matches all, don't need to check */
1734 && (strncmp(dir_prefix, path, len) != 0
1735 || (path[len] != '/' && path[len] != '\0'))
1736 ) {
1737 continue;
1738 }
1739
1740 /* Path match found */
1741 prev = dir_prefix;
1742
1743 if (ENABLE_FEATURE_HTTPD_AUTH_MD5) {
1744 char *md5_passwd;
1745
1746 md5_passwd = strchr(cur->after_colon, ':');
1747 if (md5_passwd && md5_passwd[1] == '$' && md5_passwd[2] == '1'
1748 && md5_passwd[3] == '$' && md5_passwd[4]
1749 ) {
1750 char *encrypted;
1751 int r, user_len_p1;
1752
1753 md5_passwd++;
1754 user_len_p1 = md5_passwd - cur->after_colon;
1755 /* comparing "user:" */
1756 if (strncmp(cur->after_colon, user_and_passwd, user_len_p1) != 0) {
1757 continue;
1758 }
1759
1760 encrypted = pw_encrypt(
1761 user_and_passwd + user_len_p1 /* cleartext pwd from user */,
1762 md5_passwd /*salt */, 1 /* cleanup */);
1763 r = strcmp(encrypted, md5_passwd);
1764 free(encrypted);
1765 if (r == 0)
1766 goto set_remoteuser_var; /* Ok */
1767 continue;
1768 }
1769 }
1770
1771 /* Comparing plaintext "user:pass" in one go */
1772 if (strcmp(cur->after_colon, user_and_passwd) == 0) {
1773 set_remoteuser_var:
1774 remoteuser = xstrndup(user_and_passwd,
1775 strchrnul(user_and_passwd, ':') - user_and_passwd);
1776 return 1; /* Ok */
1777 }
1778 } /* for */
1779
1780 /* 0(bad) if prev is set: matches were found but passwd was wrong */
1781 return (prev == NULL);
1782}
1783#endif /* FEATURE_HTTPD_BASIC_AUTH */
1784
1785#if ENABLE_FEATURE_HTTPD_PROXY
1786static Htaccess_Proxy *find_proxy_entry(const char *url)
1787{
1788 Htaccess_Proxy *p;
1789 for (p = proxy; p; p = p->next) {
1790 if (strncmp(url, p->url_from, strlen(p->url_from)) == 0)
1791 return p;
1792 }
1793 return NULL;
1794}
1795#endif
1796
1797/*
1798 * Handle timeouts
1799 */
1800static void send_REQUEST_TIMEOUT_and_exit(int sig) NORETURN;
1801static void send_REQUEST_TIMEOUT_and_exit(int sig UNUSED_PARAM)
1802{
1803 send_headers_and_exit(HTTP_REQUEST_TIMEOUT);
1804}
1805
1806/*
1807 * Handle an incoming http request and exit.
1808 */
1809static void handle_incoming_and_exit(const len_and_sockaddr *fromAddr) NORETURN;
1810static void handle_incoming_and_exit(const len_and_sockaddr *fromAddr)
1811{
1812 static const char request_GET[] ALIGN1 = "GET";
1813 struct stat sb;
1814 char *urlcopy;
1815 char *urlp;
1816 char *tptr;
1817#if ENABLE_FEATURE_HTTPD_CGI
1818 static const char request_HEAD[] ALIGN1 = "HEAD";
1819 const char *prequest;
1820 char *cookie = NULL;
1821 char *content_type = NULL;
1822 unsigned long length = 0;
1823#elif ENABLE_FEATURE_HTTPD_PROXY
1824#define prequest request_GET
1825 unsigned long length = 0;
1826#endif
1827#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
1828 smallint authorized = -1;
1829#endif
1830 smallint ip_allowed;
1831 char http_major_version;
1832#if ENABLE_FEATURE_HTTPD_PROXY
1833 char http_minor_version;
1834 char *header_buf = header_buf; /* for gcc */
1835 char *header_ptr = header_ptr;
1836 Htaccess_Proxy *proxy_entry;
1837#endif
1838
1839 /* Allocation of iobuf is postponed until now
1840 * (IOW, server process doesn't need to waste 8k) */
1841 iobuf = xmalloc(IOBUF_SIZE);
1842
1843 rmt_ip = 0;
1844 if (fromAddr->u.sa.sa_family == AF_INET) {
1845 rmt_ip = ntohl(fromAddr->u.sin.sin_addr.s_addr);
1846 }
1847#if ENABLE_FEATURE_IPV6
1848 if (fromAddr->u.sa.sa_family == AF_INET6
1849 && fromAddr->u.sin6.sin6_addr.s6_addr32[0] == 0
1850 && fromAddr->u.sin6.sin6_addr.s6_addr32[1] == 0
1851 && ntohl(fromAddr->u.sin6.sin6_addr.s6_addr32[2]) == 0xffff)
1852 rmt_ip = ntohl(fromAddr->u.sin6.sin6_addr.s6_addr32[3]);
1853#endif
1854 if (ENABLE_FEATURE_HTTPD_CGI || DEBUG || verbose) {
1855 /* NB: can be NULL (user runs httpd -i by hand?) */
1856 rmt_ip_str = xmalloc_sockaddr2dotted(&fromAddr->u.sa);
1857 }
1858 if (verbose) {
1859 /* this trick makes -v logging much simpler */
1860 if (rmt_ip_str)
1861 applet_name = rmt_ip_str;
1862 if (verbose > 2)
1863 bb_error_msg("connected");
1864 }
1865
1866 /* Install timeout handler. get_line() needs it. */
1867 signal(SIGALRM, send_REQUEST_TIMEOUT_and_exit);
1868
1869 if (!get_line()) /* EOF or error or empty line */
1870 send_headers_and_exit(HTTP_BAD_REQUEST);
1871
1872 /* Determine type of request (GET/POST) */
1873 urlp = strpbrk(iobuf, " \t");
1874 if (urlp == NULL)
1875 send_headers_and_exit(HTTP_BAD_REQUEST);
1876 *urlp++ = '\0';
1877#if ENABLE_FEATURE_HTTPD_CGI
1878 prequest = request_GET;
1879 if (strcasecmp(iobuf, prequest) != 0) {
1880 prequest = request_HEAD;
1881 if (strcasecmp(iobuf, prequest) != 0) {
1882 prequest = "POST";
1883 if (strcasecmp(iobuf, prequest) != 0)
1884 send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
1885 }
1886 }
1887#else
1888 if (strcasecmp(iobuf, request_GET) != 0)
1889 send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
1890#endif
1891 urlp = skip_whitespace(urlp);
1892 if (urlp[0] != '/')
1893 send_headers_and_exit(HTTP_BAD_REQUEST);
1894
1895 /* Find end of URL and parse HTTP version, if any */
1896 http_major_version = '0';
1897 IF_FEATURE_HTTPD_PROXY(http_minor_version = '0';)
1898 tptr = strchrnul(urlp, ' ');
1899 /* Is it " HTTP/"? */
1900 if (tptr[0] && strncmp(tptr + 1, HTTP_200, 5) == 0) {
1901 http_major_version = tptr[6];
1902 IF_FEATURE_HTTPD_PROXY(http_minor_version = tptr[8];)
1903 }
1904 *tptr = '\0';
1905
1906 /* Copy URL from after "GET "/"POST " to stack-allocated char[] */
1907 urlcopy = alloca((tptr - urlp) + 2 + strlen(index_page));
1908 /*if (urlcopy == NULL)
1909 * send_headers_and_exit(HTTP_INTERNAL_SERVER_ERROR);*/
1910 strcpy(urlcopy, urlp);
1911 /* NB: urlcopy ptr is never changed after this */
1912
1913 /* Extract url args if present */
1914 g_query = NULL;
1915 tptr = strchr(urlcopy, '?');
1916 if (tptr) {
1917 *tptr++ = '\0';
1918 g_query = tptr;
1919 }
1920
1921 /* Decode URL escape sequences */
1922 tptr = decodeString(urlcopy, 0);
1923 if (tptr == NULL)
1924 send_headers_and_exit(HTTP_BAD_REQUEST);
1925 if (tptr == urlcopy + 1) {
1926 /* '/' or NUL is encoded */
1927 send_headers_and_exit(HTTP_NOT_FOUND);
1928 }
1929
1930 /* Canonicalize path */
1931 /* Algorithm stolen from libbb bb_simplify_path(),
1932 * but don't strdup, retain trailing slash, protect root */
1933 urlp = tptr = urlcopy;
1934 do {
1935 if (*urlp == '/') {
1936 /* skip duplicate (or initial) slash */
1937 if (*tptr == '/') {
1938 continue;
1939 }
1940 if (*tptr == '.') {
1941 /* skip extra "/./" */
1942 if (tptr[1] == '/' || !tptr[1]) {
1943 continue;
1944 }
1945 /* "..": be careful */
1946 if (tptr[1] == '.' && (tptr[2] == '/' || !tptr[2])) {
1947 ++tptr;
1948 if (urlp == urlcopy) /* protect root */
1949 send_headers_and_exit(HTTP_BAD_REQUEST);
1950 while (*--urlp != '/') /* omit previous dir */;
1951 continue;
1952 }
1953 }
1954 }
1955 *++urlp = *tptr;
1956 } while (*++tptr);
1957 *++urlp = '\0'; /* terminate after last character */
1958
1959 /* If URL is a directory, add '/' */
1960 if (urlp[-1] != '/') {
1961 if (is_directory(urlcopy + 1, 1, NULL)) {
1962 found_moved_temporarily = urlcopy;
1963 }
1964 }
1965
1966 /* Log it */
1967 if (verbose > 1)
1968 bb_error_msg("url:%s", urlcopy);
1969
1970 tptr = urlcopy;
1971 ip_allowed = checkPermIP();
1972 while (ip_allowed && (tptr = strchr(tptr + 1, '/')) != NULL) {
1973 /* have path1/path2 */
1974 *tptr = '\0';
1975 if (is_directory(urlcopy + 1, 1, NULL)) {
1976 /* may have subdir config */
1977 parse_conf(urlcopy + 1, SUBDIR_PARSE);
1978 ip_allowed = checkPermIP();
1979 }
1980 *tptr = '/';
1981 }
1982
1983#if ENABLE_FEATURE_HTTPD_PROXY
1984 proxy_entry = find_proxy_entry(urlcopy);
1985 if (proxy_entry)
1986 header_buf = header_ptr = xmalloc(IOBUF_SIZE);
1987#endif
1988
1989 if (http_major_version >= '0') {
1990 /* Request was with "... HTTP/nXXX", and n >= 0 */
1991
1992 /* Read until blank line */
1993 while (1) {
1994 if (!get_line())
1995 break; /* EOF or error or empty line */
1996 if (DEBUG)
1997 bb_error_msg("header: '%s'", iobuf);
1998
1999#if ENABLE_FEATURE_HTTPD_PROXY
2000 /* We need 2 more bytes for yet another "\r\n" -
2001 * see near fdprintf(proxy_fd...) further below */
2002 if (proxy_entry && (header_ptr - header_buf) < IOBUF_SIZE - 2) {
2003 int len = strlen(iobuf);
2004 if (len > IOBUF_SIZE - (header_ptr - header_buf) - 4)
2005 len = IOBUF_SIZE - (header_ptr - header_buf) - 4;
2006 memcpy(header_ptr, iobuf, len);
2007 header_ptr += len;
2008 header_ptr[0] = '\r';
2009 header_ptr[1] = '\n';
2010 header_ptr += 2;
2011 }
2012#endif
2013
2014#if ENABLE_FEATURE_HTTPD_CGI || ENABLE_FEATURE_HTTPD_PROXY
2015 /* Try and do our best to parse more lines */
2016 if ((STRNCASECMP(iobuf, "Content-length:") == 0)) {
2017 /* extra read only for POST */
2018 if (prequest != request_GET
2019# if ENABLE_FEATURE_HTTPD_CGI
2020 && prequest != request_HEAD
2021# endif
2022 ) {
2023 tptr = skip_whitespace(iobuf + sizeof("Content-length:") - 1);
2024 if (!tptr[0])
2025 send_headers_and_exit(HTTP_BAD_REQUEST);
2026 /* not using strtoul: it ignores leading minus! */
2027 length = bb_strtou(tptr, NULL, 10);
2028 /* length is "ulong", but we need to pass it to int later */
2029 if (errno || length > INT_MAX)
2030 send_headers_and_exit(HTTP_BAD_REQUEST);
2031 }
2032 }
2033#endif
2034#if ENABLE_FEATURE_HTTPD_CGI
2035 else if (STRNCASECMP(iobuf, "Cookie:") == 0) {
2036 cookie = xstrdup(skip_whitespace(iobuf + sizeof("Cookie:")-1));
2037 } else if (STRNCASECMP(iobuf, "Content-Type:") == 0) {
2038 content_type = xstrdup(skip_whitespace(iobuf + sizeof("Content-Type:")-1));
2039 } else if (STRNCASECMP(iobuf, "Referer:") == 0) {
2040 referer = xstrdup(skip_whitespace(iobuf + sizeof("Referer:")-1));
2041 } else if (STRNCASECMP(iobuf, "User-Agent:") == 0) {
2042 user_agent = xstrdup(skip_whitespace(iobuf + sizeof("User-Agent:")-1));
2043 } else if (STRNCASECMP(iobuf, "Host:") == 0) {
2044 host = xstrdup(skip_whitespace(iobuf + sizeof("Host:")-1));
2045 } else if (STRNCASECMP(iobuf, "Accept:") == 0) {
2046 http_accept = xstrdup(skip_whitespace(iobuf + sizeof("Accept:")-1));
2047 } else if (STRNCASECMP(iobuf, "Accept-Language:") == 0) {
2048 http_accept_language = xstrdup(skip_whitespace(iobuf + sizeof("Accept-Language:")-1));
2049 }
2050#endif
2051#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
2052 if (STRNCASECMP(iobuf, "Authorization:") == 0) {
2053 /* We only allow Basic credentials.
2054 * It shows up as "Authorization: Basic <user>:<passwd>" where
2055 * "<user>:<passwd>" is base64 encoded.
2056 */
2057 tptr = skip_whitespace(iobuf + sizeof("Authorization:")-1);
2058 if (STRNCASECMP(tptr, "Basic") != 0)
2059 continue;
2060 tptr += sizeof("Basic")-1;
2061 /* decodeBase64() skips whitespace itself */
2062 decodeBase64(tptr);
2063 authorized = check_user_passwd(urlcopy, tptr);
2064 }
2065#endif
2066#if ENABLE_FEATURE_HTTPD_RANGES
2067 if (STRNCASECMP(iobuf, "Range:") == 0) {
2068 /* We know only bytes=NNN-[MMM] */
2069 char *s = skip_whitespace(iobuf + sizeof("Range:")-1);
2070 if (strncmp(s, "bytes=", 6) == 0) {
2071 s += sizeof("bytes=")-1;
2072 range_start = BB_STRTOOFF(s, &s, 10);
2073 if (s[0] != '-' || range_start < 0) {
2074 range_start = 0;
2075 } else if (s[1]) {
2076 range_end = BB_STRTOOFF(s+1, NULL, 10);
2077 if (errno || range_end < range_start)
2078 range_start = 0;
2079 }
2080 }
2081 }
2082#endif
2083#if ENABLE_FEATURE_HTTPD_GZIP
2084 if (STRNCASECMP(iobuf, "Accept-Encoding:") == 0) {
2085 /* Note: we do not support "gzip;q=0"
2086 * method of _disabling_ gzip
2087 * delivery. No one uses that, though */
2088 const char *s = strstr(iobuf, "gzip");
2089 if (s) {
2090 // want more thorough checks?
2091 //if (s[-1] == ' '
2092 // || s[-1] == ','
2093 // || s[-1] == ':'
2094 //) {
2095 content_gzip = 1;
2096 //}
2097 }
2098 }
2099#endif
2100 } /* while extra header reading */
2101 }
2102
2103 /* We are done reading headers, disable peer timeout */
2104 alarm(0);
2105
2106 if (strcmp(bb_basename(urlcopy), HTTPD_CONF) == 0 || !ip_allowed) {
2107 /* protect listing [/path]/httpd.conf or IP deny */
2108 send_headers_and_exit(HTTP_FORBIDDEN);
2109 }
2110
2111#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
2112 /* Case: no "Authorization:" was seen, but page does require passwd.
2113 * Check that with dummy user:pass */
2114 if (authorized < 0)
2115 authorized = check_user_passwd(urlcopy, ":");
2116 if (!authorized)
2117 send_headers_and_exit(HTTP_UNAUTHORIZED);
2118#endif
2119
2120 if (found_moved_temporarily) {
2121 send_headers_and_exit(HTTP_MOVED_TEMPORARILY);
2122 }
2123
2124#if ENABLE_FEATURE_HTTPD_PROXY
2125 if (proxy_entry != NULL) {
2126 int proxy_fd;
2127 len_and_sockaddr *lsa;
2128
2129 proxy_fd = socket(AF_INET, SOCK_STREAM, 0);
2130 if (proxy_fd < 0)
2131 send_headers_and_exit(HTTP_INTERNAL_SERVER_ERROR);
2132 lsa = host2sockaddr(proxy_entry->host_port, 80);
2133 if (lsa == NULL)
2134 send_headers_and_exit(HTTP_INTERNAL_SERVER_ERROR);
2135 if (connect(proxy_fd, &lsa->u.sa, lsa->len) < 0)
2136 send_headers_and_exit(HTTP_INTERNAL_SERVER_ERROR);
2137 fdprintf(proxy_fd, "%s %s%s%s%s HTTP/%c.%c\r\n",
2138 prequest, /* GET or POST */
2139 proxy_entry->url_to, /* url part 1 */
2140 urlcopy + strlen(proxy_entry->url_from), /* url part 2 */
2141 (g_query ? "?" : ""), /* "?" (maybe) */
2142 (g_query ? g_query : ""), /* query string (maybe) */
2143 http_major_version, http_minor_version);
2144 header_ptr[0] = '\r';
2145 header_ptr[1] = '\n';
2146 header_ptr += 2;
2147 write(proxy_fd, header_buf, header_ptr - header_buf);
2148 free(header_buf); /* on the order of 8k, free it */
2149 cgi_io_loop_and_exit(proxy_fd, proxy_fd, length);
2150 }
2151#endif
2152
2153 tptr = urlcopy + 1; /* skip first '/' */
2154
2155#if ENABLE_FEATURE_HTTPD_CGI
2156 if (strncmp(tptr, "cgi-bin/", 8) == 0) {
2157 if (tptr[8] == '\0') {
2158 /* protect listing "cgi-bin/" */
2159 send_headers_and_exit(HTTP_FORBIDDEN);
2160 }
2161 send_cgi_and_exit(urlcopy, prequest, length, cookie, content_type);
2162 }
2163#endif
2164
2165 if (urlp[-1] == '/')
2166 strcpy(urlp, index_page);
2167 if (stat(tptr, &sb) == 0) {
2168#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
2169 char *suffix = strrchr(tptr, '.');
2170 if (suffix) {
2171 Htaccess *cur;
2172 for (cur = script_i; cur; cur = cur->next) {
2173 if (strcmp(cur->before_colon + 1, suffix) == 0) {
2174 send_cgi_and_exit(urlcopy, prequest, length, cookie, content_type);
2175 }
2176 }
2177 }
2178#endif
2179 file_size = sb.st_size;
2180 last_mod = sb.st_mtime;
2181 }
2182#if ENABLE_FEATURE_HTTPD_CGI
2183 else if (urlp[-1] == '/') {
2184 /* It's a dir URL and there is no index.html
2185 * Try cgi-bin/index.cgi */
2186 if (access("/cgi-bin/index.cgi"+1, X_OK) == 0) {
2187 urlp[0] = '\0';
2188 g_query = urlcopy;
2189 send_cgi_and_exit("/cgi-bin/index.cgi", prequest, length, cookie, content_type);
2190 }
2191 }
2192 /* else fall through to send_file, it errors out if open fails: */
2193
2194 if (prequest != request_GET && prequest != request_HEAD) {
2195 /* POST for files does not make sense */
2196 send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
2197 }
2198 send_file_and_exit(tptr,
2199 (prequest != request_HEAD ? SEND_HEADERS_AND_BODY : SEND_HEADERS)
2200 );
2201#else
2202 send_file_and_exit(tptr, SEND_HEADERS_AND_BODY);
2203#endif
2204}
2205
2206/*
2207 * The main http server function.
2208 * Given a socket, listen for new connections and farm out
2209 * the processing as a [v]forked process.
2210 * Never returns.
2211 */
2212#if BB_MMU
2213static void mini_httpd(int server_socket) NORETURN;
2214static void mini_httpd(int server_socket)
2215{
2216 /* NB: it's best to not use xfuncs in this loop before fork().
2217 * Otherwise server may die on transient errors (temporary
2218 * out-of-memory condition, etc), which is Bad(tm).
2219 * Try to do any dangerous calls after fork.
2220 */
2221 while (1) {
2222 int n;
2223 len_and_sockaddr fromAddr;
2224
2225 /* Wait for connections... */
2226 fromAddr.len = LSA_SIZEOF_SA;
2227 n = accept(server_socket, &fromAddr.u.sa, &fromAddr.len);
2228 if (n < 0)
2229 continue;
2230
2231 /* set the KEEPALIVE option to cull dead connections */
2232 setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
2233
2234 if (fork() == 0) {
2235 /* child */
2236 /* Do not reload config on HUP */
2237 signal(SIGHUP, SIG_IGN);
2238 close(server_socket);
2239 xmove_fd(n, 0);
2240 xdup2(0, 1);
2241
2242 handle_incoming_and_exit(&fromAddr);
2243 }
2244 /* parent, or fork failed */
2245 close(n);
2246 } /* while (1) */
2247 /* never reached */
2248}
2249#else
2250static void mini_httpd_nommu(int server_socket, int argc, char **argv) NORETURN;
2251static void mini_httpd_nommu(int server_socket, int argc, char **argv)
2252{
2253 char *argv_copy[argc + 2];
2254
2255 argv_copy[0] = argv[0];
2256 argv_copy[1] = (char*)"-i";
2257 memcpy(&argv_copy[2], &argv[1], argc * sizeof(argv[0]));
2258
2259 /* NB: it's best to not use xfuncs in this loop before vfork().
2260 * Otherwise server may die on transient errors (temporary
2261 * out-of-memory condition, etc), which is Bad(tm).
2262 * Try to do any dangerous calls after fork.
2263 */
2264 while (1) {
2265 int n;
2266 len_and_sockaddr fromAddr;
2267
2268 /* Wait for connections... */
2269 fromAddr.len = LSA_SIZEOF_SA;
2270 n = accept(server_socket, &fromAddr.u.sa, &fromAddr.len);
2271 if (n < 0)
2272 continue;
2273
2274 /* set the KEEPALIVE option to cull dead connections */
2275 setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
2276
2277 if (vfork() == 0) {
2278 /* child */
2279 /* Do not reload config on HUP */
2280 signal(SIGHUP, SIG_IGN);
2281 close(server_socket);
2282 xmove_fd(n, 0);
2283 xdup2(0, 1);
2284
2285 /* Run a copy of ourself in inetd mode */
2286 re_exec(argv_copy);
2287 }
2288 /* parent, or vfork failed */
2289 close(n);
2290 } /* while (1) */
2291 /* never reached */
2292}
2293#endif
2294
2295/*
2296 * Process a HTTP connection on stdin/out.
2297 * Never returns.
2298 */
2299static void mini_httpd_inetd(void) NORETURN;
2300static void mini_httpd_inetd(void)
2301{
2302 len_and_sockaddr fromAddr;
2303
2304 memset(&fromAddr, 0, sizeof(fromAddr));
2305 fromAddr.len = LSA_SIZEOF_SA;
2306 /* NB: can fail if user runs it by hand and types in http cmds */
2307 getpeername(0, &fromAddr.u.sa, &fromAddr.len);
2308 handle_incoming_and_exit(&fromAddr);
2309}
2310
2311static void sighup_handler(int sig UNUSED_PARAM)
2312{
2313 parse_conf(DEFAULT_PATH_HTTPD_CONF, SIGNALED_PARSE);
2314}
2315
2316enum {
2317 c_opt_config_file = 0,
2318 d_opt_decode_url,
2319 h_opt_home_httpd,
2320 IF_FEATURE_HTTPD_ENCODE_URL_STR(e_opt_encode_url,)
2321 IF_FEATURE_HTTPD_BASIC_AUTH( r_opt_realm ,)
2322 IF_FEATURE_HTTPD_AUTH_MD5( m_opt_md5 ,)
2323 IF_FEATURE_HTTPD_SETUID( u_opt_setuid ,)
2324 p_opt_port ,
2325 p_opt_inetd ,
2326 p_opt_foreground,
2327 p_opt_verbose ,
2328 OPT_CONFIG_FILE = 1 << c_opt_config_file,
2329 OPT_DECODE_URL = 1 << d_opt_decode_url,
2330 OPT_HOME_HTTPD = 1 << h_opt_home_httpd,
2331 OPT_ENCODE_URL = IF_FEATURE_HTTPD_ENCODE_URL_STR((1 << e_opt_encode_url)) + 0,
2332 OPT_REALM = IF_FEATURE_HTTPD_BASIC_AUTH( (1 << r_opt_realm )) + 0,
2333 OPT_MD5 = IF_FEATURE_HTTPD_AUTH_MD5( (1 << m_opt_md5 )) + 0,
2334 OPT_SETUID = IF_FEATURE_HTTPD_SETUID( (1 << u_opt_setuid )) + 0,
2335 OPT_PORT = 1 << p_opt_port,
2336 OPT_INETD = 1 << p_opt_inetd,
2337 OPT_FOREGROUND = 1 << p_opt_foreground,
2338 OPT_VERBOSE = 1 << p_opt_verbose,
2339};
2340
2341
2342int httpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
2343int httpd_main(int argc UNUSED_PARAM, char **argv)
2344{
2345 int server_socket = server_socket; /* for gcc */
2346 unsigned opt;
2347 char *url_for_decode;
2348 IF_FEATURE_HTTPD_ENCODE_URL_STR(const char *url_for_encode;)
2349 IF_FEATURE_HTTPD_SETUID(const char *s_ugid = NULL;)
2350 IF_FEATURE_HTTPD_SETUID(struct bb_uidgid_t ugid;)
2351 IF_FEATURE_HTTPD_AUTH_MD5(const char *pass;)
2352
2353 INIT_G();
2354
2355#if ENABLE_LOCALE_SUPPORT
2356 /* Undo busybox.c: we want to speak English in http (dates etc) */
2357 setlocale(LC_TIME, "C");
2358#endif
2359
2360 home_httpd = xrealloc_getcwd_or_warn(NULL);
2361 /* -v counts, -i implies -f */
2362 opt_complementary = "vv:if";
2363 /* We do not "absolutize" path given by -h (home) opt.
2364 * If user gives relative path in -h,
2365 * $SCRIPT_FILENAME will not be set. */
2366 opt = getopt32(argv, "c:d:h:"
2367 IF_FEATURE_HTTPD_ENCODE_URL_STR("e:")
2368 IF_FEATURE_HTTPD_BASIC_AUTH("r:")
2369 IF_FEATURE_HTTPD_AUTH_MD5("m:")
2370 IF_FEATURE_HTTPD_SETUID("u:")
2371 "p:ifv",
2372 &opt_c_configFile, &url_for_decode, &home_httpd
2373 IF_FEATURE_HTTPD_ENCODE_URL_STR(, &url_for_encode)
2374 IF_FEATURE_HTTPD_BASIC_AUTH(, &g_realm)
2375 IF_FEATURE_HTTPD_AUTH_MD5(, &pass)
2376 IF_FEATURE_HTTPD_SETUID(, &s_ugid)
2377 , &bind_addr_or_port
2378 , &verbose
2379 );
2380 if (opt & OPT_DECODE_URL) {
2381 fputs(decodeString(url_for_decode, 1), stdout);
2382 return 0;
2383 }
2384#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
2385 if (opt & OPT_ENCODE_URL) {
2386 fputs(encodeString(url_for_encode), stdout);
2387 return 0;
2388 }
2389#endif
2390#if ENABLE_FEATURE_HTTPD_AUTH_MD5
2391 if (opt & OPT_MD5) {
2392 char salt[sizeof("$1$XXXXXXXX")];
2393 salt[0] = '$';
2394 salt[1] = '1';
2395 salt[2] = '$';
2396 crypt_make_salt(salt + 3, 4, 0);
2397 puts(pw_encrypt(pass, salt, 1));
2398 return 0;
2399 }
2400#endif
2401#if ENABLE_FEATURE_HTTPD_SETUID
2402 if (opt & OPT_SETUID) {
2403 xget_uidgid(&ugid, s_ugid);
2404 }
2405#endif
2406
2407#if !BB_MMU
2408 if (!(opt & OPT_FOREGROUND)) {
2409 bb_daemonize_or_rexec(0, argv); /* don't change current directory */
2410 }
2411#endif
2412
2413 xchdir(home_httpd);
2414 if (!(opt & OPT_INETD)) {
2415 signal(SIGCHLD, SIG_IGN);
2416 server_socket = openServer();
2417#if ENABLE_FEATURE_HTTPD_SETUID
2418 /* drop privileges */
2419 if (opt & OPT_SETUID) {
2420 if (ugid.gid != (gid_t)-1) {
2421 if (setgroups(1, &ugid.gid) == -1)
2422 bb_perror_msg_and_die("setgroups");
2423 xsetgid(ugid.gid);
2424 }
2425 xsetuid(ugid.uid);
2426 }
2427#endif
2428 }
2429
2430#if 0
2431 /* User can do it himself: 'env - PATH="$PATH" httpd'
2432 * We don't do it because we don't want to screw users
2433 * which want to do
2434 * 'env - VAR1=val1 VAR2=val2 httpd'
2435 * and have VAR1 and VAR2 values visible in their CGIs.
2436 * Besides, it is also smaller. */
2437 {
2438 char *p = getenv("PATH");
2439 /* env strings themself are not freed, no need to xstrdup(p): */
2440 clearenv();
2441 if (p)
2442 putenv(p - 5);
2443// if (!(opt & OPT_INETD))
2444// setenv_long("SERVER_PORT", ???);
2445 }
2446#endif
2447
2448 parse_conf(DEFAULT_PATH_HTTPD_CONF, FIRST_PARSE);
2449 if (!(opt & OPT_INETD))
2450 signal(SIGHUP, sighup_handler);
2451
2452 xfunc_error_retval = 0;
2453 if (opt & OPT_INETD)
2454 mini_httpd_inetd();
2455#if BB_MMU
2456 if (!(opt & OPT_FOREGROUND))
2457 bb_daemonize(0); /* don't change current directory */
2458 mini_httpd(server_socket); /* never returns */
2459#else
2460 mini_httpd_nommu(server_socket, argc, argv); /* never returns */
2461#endif
2462 /* return 0; */
2463}
Note: See TracBrowser for help on using the repository browser.