source: branches/3.2/mindi-busybox/networking/httpd.c @ 3232

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