* Copyright (C) 2002,2003 Glenn Engel <glenne@engel.org>
* Copyright (C) 2003-2006 Vladimir Oleynik <dzo@simtreas.ru>
*
- * simplify patch stolen from libbb without using strdup
- *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
*
*****************************************************************************
*
* Typical usage:
- * for non root user
- * httpd -p 8080 -h $HOME/public_html
- * or for daemon start from rc script with uid=0:
- * httpd -u www
- * This is equivalent if www user have uid=80 to
- * httpd -p 80 -u 80 -h /www -c /etc/httpd.conf -r "Web Server Authentication"
- *
+ * For non root user:
+ * httpd -p 8080 -h $HOME/public_html
+ * For daemon start from rc script with uid=0:
+ * httpd -u www
+ * which is equivalent to (assuming user www has uid 80):
+ * httpd -p 80 -u 80 -h $PWD -c /etc/httpd.conf -r "Web Server Authentication"
*
- * When a url starts by "/cgi-bin/" it is assumed to be a cgi script. The
- * server changes directory to the location of the script and executes it
+ * When an url starts with "/cgi-bin/" it is assumed to be a cgi script.
+ * The server changes directory to the location of the script and executes it
* after setting QUERY_STRING and other environment variables.
*
+ * If directory URL is given, no index.html is found and CGI support is enabled,
+ * cgi-bin/index.cgi will be run. Directory to list is ../$QUERY_STRING.
+ * See httpd_indexcgi.c for an example GCI code.
+ *
* Doc:
* "CGI Environment Variables": http://hoohoo.ncsa.uiuc.edu/cgi/env.html
*
- * The applet can also be invoked as a url arg decoder and html text encoder
+ * The applet can also be invoked as an url arg decoder and html text encoder
* as follows:
- * foo=`httpd -d $foo` # decode "Hello%20World" as "Hello World"
- * bar=`httpd -e "<Hello World>"` # encode as "<Hello World>"
+ * foo=`httpd -d $foo` # decode "Hello%20World" as "Hello World"
+ * bar=`httpd -e "<Hello World>"` # encode as "<Hello World>"
* Note that url encoding for arguments is not the same as html encoding for
- * presentation. -d decodes a url-encoded argument while -e encodes in html
+ * presentation. -d decodes an url-encoded argument while -e encodes in html
* for page display.
*
* httpd.conf has the following format:
* /cgi-bin:foo:bar # Require user foo, pwd bar on urls starting with /cgi-bin/
* /adm:admin:setup # Require user admin, pwd setup on urls starting with /adm/
* /adm:toor:PaSsWd # or user toor, pwd PaSsWd on urls starting with /adm/
+ * /adm:root:* # or user root, pwd from /etc/passwd on urls starting with /adm/
+ * /wiki:*:* # or any user from /etc/passwd with according pwd on urls starting with /wiki/
* .au:audio/basic # additional mime type for audio.au files
- * *.php:/path/php # running cgi.php scripts through an interpreter
+ * *.php:/path/php # run xxx.php through an interpreter
*
* A/D may be as a/d or allow/deny - only first char matters.
* Deny/Allow IP logic:
* D:2.3.4. # deny from 2.3.4.0 - 2.3.4.255
* A:* # (optional line added for clarity)
*
- * If a sub directory contains a config file it is parsed and merged with
+ * If a sub directory contains config file, it is parsed and merged with
* any existing settings as if it was appended to the original configuration.
*
* subdir paths are relative to the containing subdir and thus cannot
* server exits with an error.
*
*/
+ /* TODO: use TCP_CORK, parse_config() */
+
+//usage:#define httpd_trivial_usage
+//usage: "[-ifv[v]]"
+//usage: " [-c CONFFILE]"
+//usage: " [-p [IP:]PORT]"
+//usage: IF_FEATURE_HTTPD_SETUID(" [-u USER[:GRP]]")
+//usage: IF_FEATURE_HTTPD_BASIC_AUTH(" [-r REALM]")
+//usage: " [-h HOME]\n"
+//usage: "or httpd -d/-e" IF_FEATURE_HTTPD_AUTH_MD5("/-m") " STRING"
+//usage:#define httpd_full_usage "\n\n"
+//usage: "Listen for incoming HTTP requests\n"
+//usage: "\n -i Inetd mode"
+//usage: "\n -f Don't daemonize"
+//usage: "\n -v[v] Verbose"
+//usage: "\n -p [IP:]PORT Bind to IP:PORT (default *:80)"
+//usage: IF_FEATURE_HTTPD_SETUID(
+//usage: "\n -u USER[:GRP] Set uid/gid after binding to port")
+//usage: IF_FEATURE_HTTPD_BASIC_AUTH(
+//usage: "\n -r REALM Authentication Realm for Basic Authentication")
+//usage: "\n -h HOME Home directory (default .)"
+//usage: "\n -c FILE Configuration file (default {/etc,HOME}/httpd.conf)"
+//usage: IF_FEATURE_HTTPD_AUTH_MD5(
+//usage: "\n -m STRING MD5 crypt STRING")
+//usage: "\n -e STRING HTML encode STRING"
+//usage: "\n -d STRING URL decode STRING"
#include "libbb.h"
+#if ENABLE_PAM
+/* PAM may include <locale.h>. We may need to undefine bbox's stub define: */
+# undef setlocale
+/* For some obscure reason, PAM is not in pam/xxx, but in security/xxx.
+ * Apparently they like to confuse people. */
+# include <security/pam_appl.h>
+# include <security/pam_misc.h>
+#endif
#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
-#include <sys/sendfile.h>
+# include <sys/sendfile.h>
#endif
-
-//#define DEBUG 1
-#define DEBUG 0
-
-#define IOBUF_SIZE 8192 /* IO buffer */
-
/* amount of buffering in a pipe */
#ifndef PIPE_BUF
# define PIPE_BUF 4096
#endif
+
+#define DEBUG 0
+
+#define IOBUF_SIZE 8192
#if PIPE_BUF >= IOBUF_SIZE
# error "PIPE_BUF >= IOBUF_SIZE"
#endif
#define HEADER_READ_TIMEOUT 60
-static const char default_path_httpd_conf[] ALIGN1 = "/etc";
-static const char httpd_conf[] ALIGN1 = "httpd.conf";
+static const char DEFAULT_PATH_HTTPD_CONF[] ALIGN1 = "/etc";
+static const char HTTPD_CONF[] ALIGN1 = "httpd.conf";
static const char HTTP_200[] ALIGN1 = "HTTP/1.0 200 OK\r\n";
+static const char index_html[] ALIGN1 = "index.html";
typedef struct has_next_ptr {
struct has_next_ptr *next;
HTTP_PAYMENT_REQUIRED = 402,
HTTP_BAD_GATEWAY = 502,
HTTP_SERVICE_UNAVAILABLE = 503, /* overload, maintenance */
- HTTP_RESPONSE_SETSIZE = 0xffffffff
#endif
};
#endif
};
-
struct globals {
int verbose; /* must be int (used by getopt32) */
smallint flg_deny_all;
- unsigned rmt_ip; /* used for IP-based allow/deny rules */
+ unsigned rmt_ip; /* used for IP-based allow/deny rules */
time_t last_mod;
char *rmt_ip_str; /* for $REMOTE_ADDR and $REMOTE_PORT */
const char *bind_addr_or_port;
const char *g_query;
- const char *configFile;
+ const char *opt_c_configFile;
const char *home_httpd;
const char *index_page;
const char *found_moved_temporarily;
Htaccess_IP *ip_a_d; /* config allow/deny lines */
- USE_FEATURE_HTTPD_BASIC_AUTH(const char *g_realm;)
- USE_FEATURE_HTTPD_BASIC_AUTH(char *remoteuser;)
- USE_FEATURE_HTTPD_CGI(char *referer;)
- USE_FEATURE_HTTPD_CGI(char *user_agent;)
- USE_FEATURE_HTTPD_CGI(char *host;)
- USE_FEATURE_HTTPD_CGI(char *http_accept;)
- USE_FEATURE_HTTPD_CGI(char *http_accept_language;)
+ IF_FEATURE_HTTPD_BASIC_AUTH(const char *g_realm;)
+ IF_FEATURE_HTTPD_BASIC_AUTH(char *remoteuser;)
+ IF_FEATURE_HTTPD_CGI(char *referer;)
+ IF_FEATURE_HTTPD_CGI(char *user_agent;)
+ IF_FEATURE_HTTPD_CGI(char *host;)
+ IF_FEATURE_HTTPD_CGI(char *http_accept;)
+ IF_FEATURE_HTTPD_CGI(char *http_accept_language;)
off_t file_size; /* -1 - unknown */
#if ENABLE_FEATURE_HTTPD_RANGES
#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
Htaccess *g_auth; /* config user:password lines */
#endif
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
Htaccess *mime_a; /* config mime types */
-#endif
#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
Htaccess *script_i; /* config script interpreters */
#endif
- char *iobuf; /* [IOBUF_SIZE] */
+ char *iobuf; /* [IOBUF_SIZE] */
#define hdr_buf bb_common_bufsiz1
char *hdr_ptr;
int hdr_cnt;
#if ENABLE_FEATURE_HTTPD_PROXY
Htaccess_Proxy *proxy;
#endif
+#if ENABLE_FEATURE_HTTPD_GZIP
+ /* client can handle gzip / we are going to send gzip */
+ smallint content_gzip;
+#endif
};
#define G (*ptr_to_globals)
#define verbose (G.verbose )
#define rmt_ip (G.rmt_ip )
#define bind_addr_or_port (G.bind_addr_or_port)
#define g_query (G.g_query )
-#define configFile (G.configFile )
+#define opt_c_configFile (G.opt_c_configFile )
#define home_httpd (G.home_httpd )
#define index_page (G.index_page )
#define found_mime_type (G.found_mime_type )
#define range_start (G.range_start )
#define range_end (G.range_end )
#define range_len (G.range_len )
+#else
+enum {
+ range_start = -1,
+ range_end = MAXINT(off_t) - 1,
+ range_len = MAXINT(off_t),
+};
#endif
#define rmt_ip_str (G.rmt_ip_str )
#define g_auth (G.g_auth )
#define hdr_cnt (G.hdr_cnt )
#define http_error_page (G.http_error_page )
#define proxy (G.proxy )
+#if ENABLE_FEATURE_HTTPD_GZIP
+# define content_gzip (G.content_gzip )
+#else
+# define content_gzip 0
+#endif
#define INIT_G() do { \
SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
- USE_FEATURE_HTTPD_BASIC_AUTH(g_realm = "Web Server Authentication";) \
+ IF_FEATURE_HTTPD_BASIC_AUTH(g_realm = "Web Server Authentication";) \
+ IF_FEATURE_HTTPD_RANGES(range_start = -1;) \
bind_addr_or_port = "80"; \
- index_page = "index.html"; \
+ index_page = index_html; \
file_size = -1; \
} while (0)
-#if !ENABLE_FEATURE_HTTPD_RANGES
-enum {
- range_start = 0,
- range_end = MAXINT(off_t) - 1,
- range_len = MAXINT(off_t),
-};
-#endif
-
#define STRNCASECMP(a, str) strncasecmp((a), (str), sizeof(str)-1)
*pptr = NULL;
}
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
static ALWAYS_INLINE void free_Htaccess_list(Htaccess **pptr)
{
free_llist((has_next_ptr**)pptr);
}
-#endif
static ALWAYS_INLINE void free_Htaccess_IP_list(Htaccess_IP **pptr)
{
/*
* Parse configuration file into in-memory linked list.
*
- * The first non-white character is examined to determine if the config line
- * is one of the following:
- * .ext:mime/type # new mime type not compiled into httpd
- * [adAD]:from # ip address allow/deny, * for wildcard
- * /path:user:pass # username/password
- * Ennn:error.html # error page for status nnn
- * P:/url:[http://]hostname[:port]/new/path # reverse proxy
- *
* Any previous IP rules are discarded.
* If the flag argument is not SUBDIR_PARSE then all /path and mime rules
* are also discarded. That is, previous settings are retained if flag is
* path Path where to look for httpd.conf (without filename).
* flag Type of the parse request.
*/
-/* flag */
-#define FIRST_PARSE 0
-#define SUBDIR_PARSE 1
-#define SIGNALED_PARSE 2
-#define FIND_FROM_HTTPD_ROOT 3
+/* flag param: */
+enum {
+ FIRST_PARSE = 0, /* path will be "/etc" */
+ SIGNALED_PARSE = 1, /* path will be "/etc" */
+ SUBDIR_PARSE = 2, /* path will be derived from URL */
+};
static void parse_conf(const char *path, int flag)
{
+ /* internally used extra flag state */
+ enum { TRY_CURDIR_PARSE = 3 };
+
FILE *f;
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
- Htaccess *prev;
-#endif
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
- Htaccess *cur;
-#endif
- const char *filename = configFile;
+ const char *filename;
char buf[160];
- char *p, *p0;
- char *after_colon;
- Htaccess_IP *pip;
/* discard old rules */
free_Htaccess_IP_list(&ip_a_d);
flg_deny_all = 0;
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
/* retain previous auth and mime config only for subdir parse */
if (flag != SUBDIR_PARSE) {
+ free_Htaccess_list(&mime_a);
#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
free_Htaccess_list(&g_auth);
#endif
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
- free_Htaccess_list(&mime_a);
-#endif
#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
free_Htaccess_list(&script_i);
#endif
}
-#endif
+ filename = opt_c_configFile;
if (flag == SUBDIR_PARSE || filename == NULL) {
- filename = alloca(strlen(path) + sizeof(httpd_conf) + 2);
- sprintf((char *)filename, "%s/%s", path, httpd_conf);
+ filename = alloca(strlen(path) + sizeof(HTTPD_CONF) + 2);
+ sprintf((char *)filename, "%s/%s", path, HTTPD_CONF);
}
while ((f = fopen_for_read(filename)) == NULL) {
- if (flag == SUBDIR_PARSE || flag == FIND_FROM_HTTPD_ROOT) {
+ if (flag >= SUBDIR_PARSE) { /* SUBDIR or TRY_CURDIR */
/* config file not found, no changes to config */
return;
}
- if (configFile && flag == FIRST_PARSE) /* if -c option given */
- bb_simple_perror_msg_and_die(filename);
- flag = FIND_FROM_HTTPD_ROOT;
- filename = httpd_conf;
+ if (flag == FIRST_PARSE) {
+ /* -c CONFFILE given, but CONFFILE doesn't exist? */
+ if (opt_c_configFile)
+ bb_simple_perror_msg_and_die(opt_c_configFile);
+ /* else: no -c, thus we looked at /etc/httpd.conf,
+ * and it's not there. try ./httpd.conf: */
+ }
+ flag = TRY_CURDIR_PARSE;
+ filename = HTTPD_CONF;
}
#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
- prev = g_auth;
-#endif
- /* This could stand some work */
- while ((p0 = fgets(buf, sizeof(buf), f)) != NULL) {
- after_colon = NULL;
- for (p = p0; *p0 != '\0' && *p0 != '#'; p0++) {
- if (!isspace(*p0)) {
- *p++ = *p0;
- if (*p0 == ':' && after_colon == NULL)
- after_colon = p;
+ /* in "/file:user:pass" lines, we prepend path in subdirs */
+ if (flag != SUBDIR_PARSE)
+ path = "";
+#endif
+ /* The lines can be:
+ *
+ * I:default_index_file
+ * H:http_home
+ * [AD]:IP[/mask] # allow/deny, * for wildcard
+ * Ennn:error.html # error page for status nnn
+ * P:/url:[http://]hostname[:port]/new/path # reverse proxy
+ * .ext:mime/type # mime type
+ * *.php:/path/php # run xxx.php through an interpreter
+ * /file:user:pass # username and password
+ */
+ while (fgets(buf, sizeof(buf), f) != NULL) {
+ unsigned strlen_buf;
+ unsigned char ch;
+ char *after_colon;
+
+ { /* remove all whitespace, and # comments */
+ char *p, *p0;
+
+ p0 = buf;
+ /* skip non-whitespace beginning. Often the whole line
+ * is non-whitespace. We want this case to work fast,
+ * without needless copying, therefore we don't merge
+ * this operation into next while loop. */
+ while ((ch = *p0) != '\0' && ch != '\n' && ch != '#'
+ && ch != ' ' && ch != '\t'
+ ) {
+ p0++;
+ }
+ p = p0;
+ /* if we enter this loop, we have some whitespace.
+ * discard it */
+ while (ch != '\0' && ch != '\n' && ch != '#') {
+ if (ch != ' ' && ch != '\t') {
+ *p++ = ch;
+ }
+ ch = *++p0;
}
+ *p = '\0';
+ strlen_buf = p - buf;
+ if (strlen_buf == 0)
+ continue; /* empty line */
}
- *p = '\0';
- /* test for empty or strange line */
- if (after_colon == NULL || *after_colon == '\0')
+ after_colon = strchr(buf, ':');
+ /* strange line? */
+ if (after_colon == NULL || *++after_colon == '\0')
+ goto config_error;
+
+ ch = (buf[0] & ~0x20); /* toupper if it's a letter */
+
+ if (ch == 'I') {
+ if (index_page != index_html)
+ free((char*)index_page);
+ index_page = xstrdup(after_colon);
continue;
- p0 = buf;
- if (*p0 == 'd' || *p0 == 'a')
- *p0 -= 0x20; /* a/d -> A/D */
- if (*after_colon == '*') {
- if (*p0 == 'D') {
- /* memorize "deny all" */
- flg_deny_all = 1;
- }
- /* skip assumed "A:*", it is a default anyway */
+ }
+
+ /* do not allow jumping around using H in subdir's configs */
+ if (flag == FIRST_PARSE && ch == 'H') {
+ home_httpd = xstrdup(after_colon);
+ xchdir(home_httpd);
continue;
}
- if (*p0 == 'A' || *p0 == 'D') {
- /* storing current config IP line */
- pip = xzalloc(sizeof(Htaccess_IP));
- if (scan_ip_mask(after_colon, &(pip->ip), &(pip->mask))) {
+ if (ch == 'A' || ch == 'D') {
+ Htaccess_IP *pip;
+
+ if (*after_colon == '*') {
+ if (ch == 'D') {
+ /* memorize "deny all" */
+ flg_deny_all = 1;
+ }
+ /* skip assumed "A:*", it is a default anyway */
+ continue;
+ }
+ /* store "allow/deny IP/mask" line */
+ pip = xzalloc(sizeof(*pip));
+ if (scan_ip_mask(after_colon, &pip->ip, &pip->mask)) {
/* IP{/mask} syntax error detected, protect all */
- *p0 = 'D';
+ ch = 'D';
pip->mask = 0;
}
- pip->allow_deny = *p0;
- if (*p0 == 'D') {
+ pip->allow_deny = ch;
+ if (ch == 'D') {
/* Deny:from_IP - prepend */
pip->next = ip_a_d;
ip_a_d = pip;
} else {
- /* A:from_IP - append (thus D precedes A) */
+ /* A:from_IP - append (thus all D's precedes A's) */
Htaccess_IP *prev_IP = ip_a_d;
if (prev_IP == NULL) {
ip_a_d = pip;
}
#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
- if (flag == FIRST_PARSE && *p0 == 'E') {
+ if (flag == FIRST_PARSE && ch == 'E') {
unsigned i;
- int status = atoi(++p0); /* error status code */
+ int status = atoi(buf + 1); /* error status code */
+
if (status < HTTP_CONTINUE) {
- bb_error_msg("config error '%s' in '%s'", buf, filename);
- continue;
+ goto config_error;
}
/* then error page; find matching status */
for (i = 0; i < ARRAY_SIZE(http_response_type); i++) {
#endif
#if ENABLE_FEATURE_HTTPD_PROXY
- if (flag == FIRST_PARSE && *p0 == 'P') {
+ if (flag == FIRST_PARSE && ch == 'P') {
/* P:/url:[http://]hostname[:port]/new/path */
char *url_from, *host_port, *url_to;
Htaccess_Proxy *proxy_entry;
url_from = after_colon;
host_port = strchr(after_colon, ':');
if (host_port == NULL) {
- bb_error_msg("config error '%s' in '%s'", buf, filename);
- continue;
+ goto config_error;
}
*host_port++ = '\0';
if (strncmp(host_port, "http://", 7) == 0)
host_port += 7;
if (*host_port == '\0') {
- bb_error_msg("config error '%s' in '%s'", buf, filename);
- continue;
+ goto config_error;
}
url_to = strchr(host_port, '/');
if (url_to == NULL) {
- bb_error_msg("config error '%s' in '%s'", buf, filename);
- continue;
+ goto config_error;
}
*url_to = '\0';
- proxy_entry = xzalloc(sizeof(Htaccess_Proxy));
+ proxy_entry = xzalloc(sizeof(*proxy_entry));
proxy_entry->url_from = xstrdup(url_from);
proxy_entry->host_port = xstrdup(host_port);
*url_to = '/';
continue;
}
#endif
+ /* the rest of directives are non-alphabetic,
+ * must avoid using "toupper'ed" ch */
+ ch = buf[0];
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
- if (*p0 == '/') {
- /* make full path from httpd root / current_path / config_line_path */
- const char *tp = (flag == SUBDIR_PARSE ? path : "");
- p0 = xmalloc(strlen(tp) + (after_colon - buf) + 2 + strlen(after_colon));
- after_colon[-1] = '\0';
- sprintf(p0, "/%s%s", tp, buf);
-
- /* looks like bb_simplify_path... */
- tp = p = p0;
- do {
- if (*p == '/') {
- if (*tp == '/') { /* skip duplicate (or initial) slash */
- continue;
- }
- if (*tp == '.') {
- if (tp[1] == '/' || tp[1] == '\0') { /* remove extra '.' */
- continue;
- }
- if ((tp[1] == '.') && (tp[2] == '/' || tp[2] == '\0')) {
- ++tp;
- if (p > p0) {
- while (*--p != '/') /* omit previous dir */
- continue;
- }
- continue;
- }
- }
- }
- *++p = *tp;
- } while (*++tp);
+ if (ch == '.' /* ".ext:mime/type" */
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+ || (ch == '*' && buf[1] == '.') /* "*.php:/path/php" */
+#endif
+ ) {
+ char *p;
+ Htaccess *cur;
- if ((p == p0) || (*p != '/')) { /* not a trailing slash */
- ++p; /* so keep last character */
+ cur = xzalloc(sizeof(*cur) /* includes space for NUL */ + strlen_buf);
+ strcpy(cur->before_colon, buf);
+ p = cur->before_colon + (after_colon - buf);
+ p[-1] = '\0';
+ cur->after_colon = p;
+ if (ch == '.') {
+ /* .mime line: prepend to mime_a list */
+ cur->next = mime_a;
+ mime_a = cur;
+ }
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+ else {
+ /* script interpreter line: prepend to script_i list */
+ cur->next = script_i;
+ script_i = cur;
}
- *p = ':';
- strcpy(p + 1, after_colon);
- }
#endif
- if (*p0 == 'I') {
- index_page = xstrdup(after_colon);
continue;
}
- /* Do not allow jumping around using H in subdir's configs */
- if (flag == FIRST_PARSE && *p0 == 'H') {
- home_httpd = xstrdup(after_colon);
- xchdir(home_httpd);
- continue;
- }
-
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES \
- || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
- /* storing current config line */
- cur = xzalloc(sizeof(Htaccess) + strlen(p0));
- strcpy(cur->before_colon, p0);
#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
- if (*p0 == '/') /* was malloced - see above */
- free(p0);
-#endif
- cur->after_colon = strchr(cur->before_colon, ':');
- *cur->after_colon++ = '\0';
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
- if (cur->before_colon[0] == '.') {
- /* .mime line: prepend to mime_a list */
- cur->next = mime_a;
- mime_a = cur;
- continue;
- }
-#endif
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
- if (cur->before_colon[0] == '*' && cur->before_colon[1] == '.') {
- /* script interpreter line: prepend to script_i list */
- cur->next = script_i;
- script_i = cur;
- continue;
- }
-#endif
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
-//TODO: we do not test for leading "/"??
-//also, do we leak cur if BASIC_AUTH is off?
- if (prev == NULL) {
- /* first line */
- g_auth = prev = cur;
- } else {
- /* sort path, if current length eq or bigger then move up */
- Htaccess *prev_hti = g_auth;
- size_t l = strlen(cur->before_colon);
- Htaccess *hti;
-
- for (hti = prev_hti; hti; hti = hti->next) {
- if (l >= strlen(hti->before_colon)) {
- /* insert before hti */
- cur->next = hti;
- if (prev_hti != hti) {
- prev_hti->next = cur;
- } else {
- /* insert as top */
- g_auth = cur;
+ if (ch == '/') { /* "/file:user:pass" */
+ char *p;
+ Htaccess *cur;
+ unsigned file_len;
+
+ /* note: path is "" unless we are in SUBDIR parse,
+ * otherwise it does NOT start with "/" */
+ cur = xzalloc(sizeof(*cur) /* includes space for NUL */
+ + 1 + strlen(path)
+ + strlen_buf
+ );
+ /* form "/path/file" */
+ sprintf(cur->before_colon, "/%s%.*s",
+ path,
+ (int) (after_colon - buf - 1), /* includes "/", but not ":" */
+ buf);
+ /* canonicalize it */
+ p = bb_simplify_abs_path_inplace(cur->before_colon);
+ file_len = p - cur->before_colon;
+ /* add "user:pass" after NUL */
+ strcpy(++p, after_colon);
+ cur->after_colon = p;
+
+ /* insert cur into g_auth */
+ /* g_auth is sorted by decreased filename length */
+ {
+ Htaccess *auth, **authp;
+
+ authp = &g_auth;
+ while ((auth = *authp) != NULL) {
+ if (file_len >= strlen(auth->before_colon)) {
+ /* insert cur before auth */
+ cur->next = auth;
+ break;
}
- break;
+ authp = &auth->next;
}
- if (prev_hti != hti)
- prev_hti = prev_hti->next;
- }
- if (!hti) { /* not inserted, add to bottom */
- prev->next = cur;
- prev = cur;
+ *authp = cur;
}
+ continue;
}
#endif /* BASIC_AUTH */
-#endif /* BASIC_AUTH || MIME_TYPES || SCRIPT_INTERPR */
- } /* while (fgets) */
- fclose(f);
+
+ /* the line is not recognized */
+ config_error:
+ bb_error_msg("config error '%s' in '%s'", buf, filename);
+ } /* while (fgets) */
+
+ fclose(f);
}
#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
char *p = out;
char ch;
- while ((ch = *string++)) {
+ while ((ch = *string++) != '\0') {
/* very simple check for what to encode */
if (isalnum(ch))
*p++ = ch;
*p = '\0';
return out;
}
-#endif /* FEATURE_HTTPD_ENCODE_URL_STR */
-
-/*
- * Given a URL encoded string, convert it to plain ascii.
- * Since decoding always makes strings smaller, the decode is done in-place.
- * Thus, callers should xstrdup() the argument if they do not want the
- * argument modified. The return is the original pointer, allowing this
- * function to be easily used as arguments to other functions.
- *
- * string The first string to decode.
- * option_d 1 if called for httpd -d
- *
- * Returns a pointer to the decoded string (same as input).
- */
-static unsigned hex_to_bin(unsigned char c)
-{
- unsigned v;
-
- v = c - '0';
- if (v <= 9)
- return v;
- /* c | 0x20: letters to lower case, non-letters
- * to (potentially different) non-letters */
- v = (unsigned)(c | 0x20) - 'a';
- if (v <= 5)
- return v + 10;
- return ~0;
-}
-/* For testing:
-void t(char c) { printf("'%c'(%u) %u\n", c, c, hex_to_bin(c)); }
-int main() { t(0x10); t(0x20); t('0'); t('9'); t('A'); t('F'); t('a'); t('f');
-t('0'-1); t('9'+1); t('A'-1); t('F'+1); t('a'-1); t('f'+1); return 0; }
-*/
-static char *decodeString(char *orig, int option_d)
-{
- /* note that decoded string is always shorter than original */
- char *string = orig;
- char *ptr = string;
- char c;
-
- while ((c = *ptr++) != '\0') {
- unsigned v;
-
- if (option_d && c == '+') {
- *string++ = ' ';
- continue;
- }
- if (c != '%') {
- *string++ = c;
- continue;
- }
- v = hex_to_bin(ptr[0]);
- if (v > 15) {
- bad_hex:
- if (!option_d)
- return NULL;
- *string++ = '%';
- continue;
- }
- v = (v * 16) | hex_to_bin(ptr[1]);
- if (v > 255)
- goto bad_hex;
- if (!option_d && (v == '/' || v == '\0')) {
- /* caller takes it as indication of invalid
- * (dangerous wrt exploits) chars */
- return orig + 1;
- }
- *string++ = v;
- ptr += 2;
- }
- *string = '\0';
- return orig;
-}
+#endif
#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
/*
strftime(tmp_str, sizeof(tmp_str), RFC1123FMT, gmtime(&last_mod));
#if ENABLE_FEATURE_HTTPD_RANGES
if (responseNum == HTTP_PARTIAL_CONTENT) {
- len += sprintf(iobuf + len, "Content-Range: bytes %"OFF_FMT"d-%"OFF_FMT"d/%"OFF_FMT"d\r\n",
+ len += sprintf(iobuf + len, "Content-Range: bytes %"OFF_FMT"u-%"OFF_FMT"u/%"OFF_FMT"u\r\n",
range_start,
range_end,
file_size);
#if ENABLE_FEATURE_HTTPD_RANGES
"Accept-Ranges: bytes\r\n"
#endif
- "Last-Modified: %s\r\n%s %"OFF_FMT"d\r\n",
+ "Last-Modified: %s\r\n%s %"OFF_FMT"u\r\n",
tmp_str,
- "Content-length:",
+ content_gzip ? "Transfer-length:" : "Content-length:",
file_size
);
}
+
+ if (content_gzip)
+ len += sprintf(iobuf + len, "Content-Encoding: gzip\r\n");
+
iobuf[len++] = '\r';
iobuf[len++] = '\n';
if (infoString) {
static void send_headers_and_exit(int responseNum) NORETURN;
static void send_headers_and_exit(int responseNum)
{
+ IF_FEATURE_HTTPD_GZIP(content_gzip = 0;)
send_headers(responseNum);
log_and_exit();
}
int count = 0;
char c;
+ alarm(HEADER_READ_TIMEOUT);
while (1) {
if (hdr_cnt <= 0) {
hdr_cnt = safe_read(STDIN_FILENO, hdr_buf, sizeof(hdr_buf));
continue;
if (c == '\n') {
iobuf[count] = '\0';
- return count;
+ break;
}
if (count < (IOBUF_SIZE - 1)) /* check overflow */
count++;
/* post_len <= 0 && hdr_cnt <= 0:
* no more POST data to CGI,
* let CGI see EOF on CGI's stdin */
- close(toCgi_wr);
+ if (toCgi_wr != fromCgi_rd)
+ close(toCgi_wr);
toCgi_wr = 0;
}
}
/* Now wait on the set of sockets */
- count = safe_poll(pfd, 3, -1);
+ count = safe_poll(pfd, toCgi_wr ? TO_CGI+1 : FROM_CGI+1, -1);
if (count <= 0) {
#if 0
if (safe_waitpid(pid, &status, WNOHANG) <= 0) {
*
* Parameters:
* const char *url The requested URL (with leading /).
+ * const char *orig_uri The original URI before rewriting (if any)
* int post_len Length of the POST body.
* const char *cookie For set HTTP_COOKIE.
* const char *content_type For set CONTENT_TYPE.
*/
static void send_cgi_and_exit(
const char *url,
+ const char *orig_uri,
const char *request,
int post_len,
const char *cookie,
const char *content_type) NORETURN;
static void send_cgi_and_exit(
const char *url,
+ const char *orig_uri,
const char *request,
int post_len,
const char *cookie,
{
struct fd_pair fromCgi; /* CGI -> httpd pipe */
struct fd_pair toCgi; /* httpd -> CGI pipe */
- char *script;
+ char *script, *last_slash;
int pid;
/* Make a copy. NB: caller guarantees:
*/
/* Check for [dirs/]script.cgi/PATH_INFO */
- script = (char*)url;
+ last_slash = script = (char*)url;
while ((script = strchr(script + 1, '/')) != NULL) {
- struct stat sb;
-
+ int dir;
*script = '\0';
- if (!is_directory(url + 1, 1, &sb)) {
+ dir = is_directory(url + 1, /*followlinks:*/ 1);
+ *script = '/';
+ if (!dir) {
/* not directory, found script.cgi/PATH_INFO */
- *script = '/';
break;
}
- *script = '/'; /* is directory, find next '/' */
+ /* is directory, find next '/' */
+ last_slash = script;
}
setenv1("PATH_INFO", script); /* set to /PATH_INFO or "" */
setenv1("REQUEST_METHOD", request);
if (g_query) {
- putenv(xasprintf("%s=%s?%s", "REQUEST_URI", url, g_query));
+ putenv(xasprintf("%s=%s?%s", "REQUEST_URI", orig_uri, g_query));
} else {
- setenv1("REQUEST_URI", url);
+ setenv1("REQUEST_URI", orig_uri);
}
if (script != NULL)
*script = '\0'; /* cut off /PATH_INFO */
if (referer)
setenv1("HTTP_REFERER", referer);
setenv1("HTTP_HOST", host); /* set to "" if NULL */
+ /* setenv1("SERVER_NAME", safe_gethostname()); - don't do this,
+ * just run "env SERVER_NAME=xyz httpd ..." instead */
xpiped_pair(fromCgi);
xpiped_pair(toCgi);
log_and_exit();
}
- if (!pid) {
+ if (pid == 0) {
/* Child process */
char *argv[3];
/* dup2(1, 2); */
/* Chdiring to script's dir */
- script = strrchr(url, '/');
+ script = last_slash;
if (script != url) { /* paranoia */
*script = '\0';
if (chdir(url + 1) != 0) {
- bb_perror_msg("chdir %s", url + 1);
+ bb_perror_msg("can't change directory to '%s'", url + 1);
goto error_execing_cgi;
}
// not needed: *script = '/';
* in the current directory */
execv(argv[0], argv);
if (verbose)
- bb_perror_msg("exec %s", argv[0]);
+ bb_perror_msg("can't execute '%s'", argv[0]);
error_execing_cgi:
/* send to stdout
* (we are CGI here, our stdout is pumped to the net) */
* const char *url The requested URL (with leading /).
* what What to send (headers/body/both).
*/
-static void send_file_and_exit(const char *url, int what)
+static NOINLINE void send_file_and_exit(const char *url, int what)
{
- static const char *const suffixTable[] = {
- /* Warning: shorter equivalent suffix in one line must be first */
- ".htm.html", "text/html",
- ".jpg.jpeg", "image/jpeg",
- ".gif", "image/gif",
- ".png", "image/png",
- ".txt.h.c.cc.cpp", "text/plain",
- ".css", "text/css",
- ".wav", "audio/wav",
- ".avi", "video/x-msvideo",
- ".qt.mov", "video/quicktime",
- ".mpe.mpeg", "video/mpeg",
- ".mid.midi", "audio/midi",
- ".mp3", "audio/mpeg",
-#if 0 /* unpopular */
- ".au", "audio/basic",
- ".pac", "application/x-ns-proxy-autoconfig",
- ".vrml.wrl", "model/vrml",
-#endif
- NULL
- };
-
char *suffix;
- int f;
- const char *const *table;
- const char *try_suffix;
+ int fd;
ssize_t count;
-#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
- off_t offset;
-#endif
+ if (content_gzip) {
+ /* does <url>.gz exist? Then use it instead */
+ char *gzurl = xasprintf("%s.gz", url);
+ fd = open(gzurl, O_RDONLY);
+ free(gzurl);
+ if (fd != -1) {
+ struct stat sb;
+ fstat(fd, &sb);
+ file_size = sb.st_size;
+ last_mod = sb.st_mtime;
+ } else {
+ IF_FEATURE_HTTPD_GZIP(content_gzip = 0;)
+ fd = open(url, O_RDONLY);
+ }
+ } else {
+ fd = open(url, O_RDONLY);
+ }
+ if (fd < 0) {
+ if (DEBUG)
+ bb_perror_msg("can't open '%s'", url);
+ /* Error pages are sent by using send_file_and_exit(SEND_BODY).
+ * IOW: it is unsafe to call send_headers_and_exit
+ * if what is SEND_BODY! Can recurse! */
+ if (what != SEND_BODY)
+ send_headers_and_exit(HTTP_NOT_FOUND);
+ log_and_exit();
+ }
/* If you want to know about EPIPE below
* (happens if you abort downloads from local httpd): */
signal(SIGPIPE, SIG_IGN);
- suffix = strrchr(url, '.');
-
- /* If not found, set default as "application/octet-stream"; */
+ /* If not found, default is "application/octet-stream" */
found_mime_type = "application/octet-stream";
+ suffix = strrchr(url, '.');
if (suffix) {
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+ static const char suffixTable[] ALIGN1 =
+ /* Shorter suffix must be first:
+ * ".html.htm" will fail for ".htm"
+ */
+ ".txt.h.c.cc.cpp\0" "text/plain\0"
+ /* .htm line must be after .h line */
+ ".htm.html\0" "text/html\0"
+ ".jpg.jpeg\0" "image/jpeg\0"
+ ".gif\0" "image/gif\0"
+ ".png\0" "image/png\0"
+ /* .css line must be after .c line */
+ ".css\0" "text/css\0"
+ ".wav\0" "audio/wav\0"
+ ".avi\0" "video/x-msvideo\0"
+ ".qt.mov\0" "video/quicktime\0"
+ ".mpe.mpeg\0" "video/mpeg\0"
+ ".mid.midi\0" "audio/midi\0"
+ ".mp3\0" "audio/mpeg\0"
+#if 0 /* unpopular */
+ ".au\0" "audio/basic\0"
+ ".pac\0" "application/x-ns-proxy-autoconfig\0"
+ ".vrml.wrl\0" "model/vrml\0"
+#endif
+ /* compiler adds another "\0" here */
+ ;
Htaccess *cur;
-#endif
- for (table = suffixTable; *table; table += 2) {
- try_suffix = strstr(table[0], suffix);
- if (try_suffix) {
- try_suffix += strlen(suffix);
- if (*try_suffix == '\0' || *try_suffix == '.') {
- found_mime_type = table[1];
- break;
- }
+
+ /* Examine built-in table */
+ const char *table = suffixTable;
+ const char *table_next;
+ for (; *table; table = table_next) {
+ const char *try_suffix;
+ const char *mime_type;
+ mime_type = table + strlen(table) + 1;
+ table_next = mime_type + strlen(mime_type) + 1;
+ try_suffix = strstr(table, suffix);
+ if (!try_suffix)
+ continue;
+ try_suffix += strlen(suffix);
+ if (*try_suffix == '\0' || *try_suffix == '.') {
+ found_mime_type = mime_type;
+ break;
}
+ /* Example: strstr(table, ".av") != NULL, but it
+ * does not match ".avi" after all and we end up here.
+ * The table is arranged so that in this case we know
+ * that it can't match anything in the following lines,
+ * and we stop the search: */
+ break;
}
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+ /* ...then user's table */
for (cur = mime_a; cur; cur = cur->next) {
if (strcmp(cur->before_colon, suffix) == 0) {
found_mime_type = cur->after_colon;
break;
}
}
-#endif
}
if (DEBUG)
bb_error_msg("sending file '%s' content-type: %s",
url, found_mime_type);
- f = open(url, O_RDONLY);
- if (f < 0) {
- if (DEBUG)
- bb_perror_msg("can't open '%s'", url);
- /* Error pages are sent by using send_file_and_exit(SEND_BODY).
- * IOW: it is unsafe to call send_headers_and_exit
- * if what is SEND_BODY! Can recurse! */
- if (what != SEND_BODY)
- send_headers_and_exit(HTTP_NOT_FOUND);
- log_and_exit();
- }
#if ENABLE_FEATURE_HTTPD_RANGES
- if (what == SEND_BODY)
- range_start = 0; /* err pages and ranges don't mix */
+ if (what == SEND_BODY /* err pages and ranges don't mix */
+ || content_gzip /* we are sending compressed page: can't do ranges */ ///why?
+ ) {
+ range_start = -1;
+ }
range_len = MAXINT(off_t);
- if (range_start) {
- if (!range_end) {
+ if (range_start >= 0) {
+ if (!range_end || range_end > file_size - 1) {
range_end = file_size - 1;
}
if (range_end < range_start
- || lseek(f, range_start, SEEK_SET) != range_start
+ || lseek(fd, range_start, SEEK_SET) != range_start
) {
- lseek(f, 0, SEEK_SET);
- range_start = 0;
+ lseek(fd, 0, SEEK_SET);
+ range_start = -1;
} else {
range_len = range_end - range_start + 1;
send_headers(HTTP_PARTIAL_CONTENT);
}
}
#endif
-
if (what & SEND_HEADERS)
send_headers(HTTP_OK);
-
#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
- offset = range_start;
- do {
- /* sz is rounded down to 64k */
- ssize_t sz = MAXINT(ssize_t) - 0xffff;
- USE_FEATURE_HTTPD_RANGES(if (sz > range_len) sz = range_len;)
- count = sendfile(1, f, &offset, sz);
- if (count < 0) {
- if (offset == range_start)
- goto fallback;
- goto fin;
+ {
+ off_t offset = range_start;
+ while (1) {
+ /* sz is rounded down to 64k */
+ ssize_t sz = MAXINT(ssize_t) - 0xffff;
+ IF_FEATURE_HTTPD_RANGES(if (sz > range_len) sz = range_len;)
+ count = sendfile(STDOUT_FILENO, fd, &offset, sz);
+ if (count < 0) {
+ if (offset == range_start)
+ break; /* fall back to read/write loop */
+ goto fin;
+ }
+ IF_FEATURE_HTTPD_RANGES(range_len -= count;)
+ if (count == 0 || range_len == 0)
+ log_and_exit();
}
- USE_FEATURE_HTTPD_RANGES(range_len -= sz;)
- } while (count > 0 && range_len);
- log_and_exit();
-
- fallback:
+ }
#endif
- while ((count = safe_read(f, iobuf, IOBUF_SIZE)) > 0) {
+ while ((count = safe_read(fd, iobuf, IOBUF_SIZE)) > 0) {
ssize_t n;
- USE_FEATURE_HTTPD_RANGES(if (count > range_len) count = range_len;)
+ IF_FEATURE_HTTPD_RANGES(if (count > range_len) count = range_len;)
n = full_write(STDOUT_FILENO, iobuf, count);
if (count != n)
break;
- USE_FEATURE_HTTPD_RANGES(range_len -= count;)
- if (!range_len)
+ IF_FEATURE_HTTPD_RANGES(range_len -= count;)
+ if (range_len == 0)
break;
}
-#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
- fin:
-#endif
- if (count < 0 && verbose > 1)
- bb_perror_msg("error");
+ if (count < 0) {
+ IF_FEATURE_HTTPD_USE_SENDFILE(fin:)
+ if (verbose > 1)
+ bb_perror_msg("error");
+ }
log_and_exit();
}
}
#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+
+# if ENABLE_PAM
+struct pam_userinfo {
+ const char *name;
+ const char *pw;
+};
+
+static int pam_talker(int num_msg,
+ const struct pam_message **msg,
+ struct pam_response **resp,
+ void *appdata_ptr)
+{
+ int i;
+ struct pam_userinfo *userinfo = (struct pam_userinfo *) appdata_ptr;
+ struct pam_response *response;
+
+ if (!resp || !msg || !userinfo)
+ return PAM_CONV_ERR;
+
+ /* allocate memory to store response */
+ response = xzalloc(num_msg * sizeof(*response));
+
+ /* copy values */
+ for (i = 0; i < num_msg; i++) {
+ const char *s;
+
+ switch (msg[i]->msg_style) {
+ case PAM_PROMPT_ECHO_ON:
+ s = userinfo->name;
+ break;
+ case PAM_PROMPT_ECHO_OFF:
+ s = userinfo->pw;
+ break;
+ case PAM_ERROR_MSG:
+ case PAM_TEXT_INFO:
+ s = "";
+ break;
+ default:
+ free(response);
+ return PAM_CONV_ERR;
+ }
+ response[i].resp = xstrdup(s);
+ if (PAM_SUCCESS != 0)
+ response[i].resp_retcode = PAM_SUCCESS;
+ }
+ *resp = response;
+ return PAM_SUCCESS;
+}
+# endif
+
/*
* Config file entries are of the form "/<path>:<user>:<passwd>".
* If config file has no prefix match for path, access is allowed.
*
* Returns 1 if user_and_passwd is OK.
*/
-static int check_user_passwd(const char *path, const char *user_and_passwd)
+static int check_user_passwd(const char *path, char *user_and_passwd)
{
Htaccess *cur;
const char *prev = NULL;
for (cur = g_auth; cur; cur = cur->next) {
const char *dir_prefix;
size_t len;
+ int r;
dir_prefix = cur->before_colon;
len = strlen(dir_prefix);
if (len != 1 /* dir_prefix "/" matches all, don't need to check */
&& (strncmp(dir_prefix, path, len) != 0
- || (path[len] != '/' && path[len] != '\0'))
+ || (path[len] != '/' && path[len] != '\0')
+ )
) {
continue;
}
prev = dir_prefix;
if (ENABLE_FEATURE_HTTPD_AUTH_MD5) {
- char *md5_passwd;
-
- md5_passwd = strchr(cur->after_colon, ':');
- if (md5_passwd && md5_passwd[1] == '$' && md5_passwd[2] == '1'
- && md5_passwd[3] == '$' && md5_passwd[4]
+ char *colon_after_user;
+ const char *passwd;
+# if ENABLE_FEATURE_SHADOWPASSWDS && !ENABLE_PAM
+ char sp_buf[256];
+# endif
+
+ colon_after_user = strchr(user_and_passwd, ':');
+ if (!colon_after_user)
+ goto bad_input;
+
+ /* compare "user:" */
+ if (cur->after_colon[0] != '*'
+ && strncmp(cur->after_colon, user_and_passwd,
+ colon_after_user - user_and_passwd + 1) != 0
) {
- char *encrypted;
- int r, user_len_p1;
-
- md5_passwd++;
- user_len_p1 = md5_passwd - cur->after_colon;
- /* comparing "user:" */
- if (strncmp(cur->after_colon, user_and_passwd, user_len_p1) != 0) {
+ continue;
+ }
+ /* this cfg entry is '*' or matches username from peer */
+
+ passwd = strchr(cur->after_colon, ':');
+ if (!passwd)
+ goto bad_input;
+ passwd++;
+ if (passwd[0] == '*') {
+# if ENABLE_PAM
+ struct pam_userinfo userinfo;
+ struct pam_conv conv_info = { &pam_talker, (void *) &userinfo };
+ pam_handle_t *pamh;
+
+ *colon_after_user = '\0';
+ userinfo.name = user_and_passwd;
+ userinfo.pw = colon_after_user + 1;
+ r = pam_start("httpd", user_and_passwd, &conv_info, &pamh) != PAM_SUCCESS;
+ if (r == 0) {
+ r = pam_authenticate(pamh, PAM_DISALLOW_NULL_AUTHTOK) != PAM_SUCCESS
+ || pam_acct_mgmt(pamh, PAM_DISALLOW_NULL_AUTHTOK) != PAM_SUCCESS
+ ;
+ pam_end(pamh, PAM_SUCCESS);
+ }
+ *colon_after_user = ':';
+ goto end_check_passwd;
+# else
+# if ENABLE_FEATURE_SHADOWPASSWDS
+ /* Using _r function to avoid pulling in static buffers */
+ struct spwd spw;
+# endif
+ struct passwd *pw;
+
+ *colon_after_user = '\0';
+ pw = getpwnam(user_and_passwd);
+ *colon_after_user = ':';
+ if (!pw || !pw->pw_passwd)
continue;
+ passwd = pw->pw_passwd;
+# if ENABLE_FEATURE_SHADOWPASSWDS
+ if ((passwd[0] == 'x' || passwd[0] == '*') && !passwd[1]) {
+ /* getspnam_r may return 0 yet set result to NULL.
+ * At least glibc 2.4 does this. Be extra paranoid here. */
+ struct spwd *result = NULL;
+ r = getspnam_r(pw->pw_name, &spw, sp_buf, sizeof(sp_buf), &result);
+ if (r == 0 && result)
+ passwd = result->sp_pwdp;
}
+# endif
+ /* In this case, passwd is ALWAYS encrypted:
+ * it came from /etc/passwd or /etc/shadow!
+ */
+ goto check_encrypted;
+# endif /* ENABLE_PAM */
+ }
+ /* Else: passwd is from httpd.conf, it is either plaintext or encrypted */
+ if (passwd[0] == '$' && isdigit(passwd[1])) {
+ char *encrypted;
+# if !ENABLE_PAM
+ check_encrypted:
+# endif
+ /* encrypt pwd from peer and check match with local one */
encrypted = pw_encrypt(
- user_and_passwd + user_len_p1 /* cleartext pwd from user */,
- md5_passwd /*salt */, 1 /* cleanup */);
- r = strcmp(encrypted, md5_passwd);
+ /* pwd (from peer): */ colon_after_user + 1,
+ /* salt: */ passwd,
+ /* cleanup: */ 0
+ );
+ r = strcmp(encrypted, passwd);
free(encrypted);
- if (r == 0)
- goto set_remoteuser_var; /* Ok */
- continue;
+ } else {
+ /* local passwd is from httpd.conf and it's plaintext */
+ r = strcmp(colon_after_user + 1, passwd);
}
+ goto end_check_passwd;
}
-
+ bad_input:
/* Comparing plaintext "user:pass" in one go */
- if (strcmp(cur->after_colon, user_and_passwd) == 0) {
- set_remoteuser_var:
+ r = strcmp(cur->after_colon, user_and_passwd);
+ end_check_passwd:
+ if (r == 0) {
remoteuser = xstrndup(user_and_passwd,
- strchrnul(user_and_passwd, ':') - user_and_passwd);
+ strchrnul(user_and_passwd, ':') - user_and_passwd
+ );
return 1; /* Ok */
}
} /* for */
/*
* Handle timeouts
*/
-static void exit_on_signal(int sig) NORETURN;
-static void exit_on_signal(int sig UNUSED_PARAM)
+static void send_REQUEST_TIMEOUT_and_exit(int sig) NORETURN;
+static void send_REQUEST_TIMEOUT_and_exit(int sig UNUSED_PARAM)
{
send_headers_and_exit(HTTP_REQUEST_TIMEOUT);
}
bb_error_msg("connected");
}
- /* Install timeout handler */
- signal_no_SA_RESTART_empty_mask(SIGALRM, exit_on_signal);
- alarm(HEADER_READ_TIMEOUT);
+ /* Install timeout handler. get_line() needs it. */
+ signal(SIGALRM, send_REQUEST_TIMEOUT_and_exit);
if (!get_line()) /* EOF or error or empty line */
send_headers_and_exit(HTTP_BAD_REQUEST);
/* Determine type of request (GET/POST) */
- urlp = strpbrk(iobuf, " \t");
+ // rfc2616: method and URI is separated by exactly one space
+ //urlp = strpbrk(iobuf, " \t"); - no, tab isn't allowed
+ urlp = strchr(iobuf, ' ');
if (urlp == NULL)
send_headers_and_exit(HTTP_BAD_REQUEST);
*urlp++ = '\0';
if (strcasecmp(iobuf, request_GET) != 0)
send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
#endif
- urlp = skip_whitespace(urlp);
+ // rfc2616: method and URI is separated by exactly one space
+ //urlp = skip_whitespace(urlp); - should not be necessary
if (urlp[0] != '/')
send_headers_and_exit(HTTP_BAD_REQUEST);
/* Find end of URL and parse HTTP version, if any */
http_major_version = '0';
- USE_FEATURE_HTTPD_PROXY(http_minor_version = '0';)
+ IF_FEATURE_HTTPD_PROXY(http_minor_version = '0';)
tptr = strchrnul(urlp, ' ');
/* Is it " HTTP/"? */
if (tptr[0] && strncmp(tptr + 1, HTTP_200, 5) == 0) {
http_major_version = tptr[6];
- USE_FEATURE_HTTPD_PROXY(http_minor_version = tptr[8];)
+ IF_FEATURE_HTTPD_PROXY(http_minor_version = tptr[8];)
}
*tptr = '\0';
/* NB: urlcopy ptr is never changed after this */
/* Extract url args if present */
- g_query = NULL;
+ /* g_query = NULL; - already is */
tptr = strchr(urlcopy, '?');
if (tptr) {
*tptr++ = '\0';
}
/* Decode URL escape sequences */
- tptr = decodeString(urlcopy, 0);
+ tptr = percent_decode_in_place(urlcopy, /*strict:*/ 1);
if (tptr == NULL)
send_headers_and_exit(HTTP_BAD_REQUEST);
if (tptr == urlcopy + 1) {
/* Algorithm stolen from libbb bb_simplify_path(),
* but don't strdup, retain trailing slash, protect root */
urlp = tptr = urlcopy;
- do {
+ for (;;) {
if (*urlp == '/') {
/* skip duplicate (or initial) slash */
if (*tptr == '/') {
- continue;
+ goto next_char;
}
if (*tptr == '.') {
- /* skip extra "/./" */
- if (tptr[1] == '/' || !tptr[1]) {
- continue;
- }
- /* "..": be careful */
- if (tptr[1] == '.' && (tptr[2] == '/' || !tptr[2])) {
- ++tptr;
- if (urlp == urlcopy) /* protect root */
+ if (tptr[1] == '.' && (tptr[2] == '/' || tptr[2] == '\0')) {
+ /* "..": be careful */
+ /* protect root */
+ if (urlp == urlcopy)
send_headers_and_exit(HTTP_BAD_REQUEST);
- while (*--urlp != '/') /* omit previous dir */;
+ /* omit previous dir */
+ while (*--urlp != '/')
continue;
+ /* skip to "./" or ".<NUL>" */
+ tptr++;
+ }
+ if (tptr[1] == '/' || tptr[1] == '\0') {
+ /* skip extra "/./" */
+ goto next_char;
}
}
}
*++urlp = *tptr;
- } while (*++tptr);
- *++urlp = '\0'; /* terminate after last character */
+ if (*urlp == '\0')
+ break;
+ next_char:
+ tptr++;
+ }
/* If URL is a directory, add '/' */
if (urlp[-1] != '/') {
- if (is_directory(urlcopy + 1, 1, &sb)) {
+ if (is_directory(urlcopy + 1, /*followlinks:*/ 1)) {
found_moved_temporarily = urlcopy;
}
}
while (ip_allowed && (tptr = strchr(tptr + 1, '/')) != NULL) {
/* have path1/path2 */
*tptr = '\0';
- if (is_directory(urlcopy + 1, 1, &sb)) {
+ if (is_directory(urlcopy + 1, /*followlinks:*/ 1)) {
/* may have subdir config */
parse_conf(urlcopy + 1, SUBDIR_PARSE);
ip_allowed = checkPermIP();
if (http_major_version >= '0') {
/* Request was with "... HTTP/nXXX", and n >= 0 */
- /* Read until blank line for HTTP version specified, else parse immediate */
+ /* Read until blank line */
while (1) {
- alarm(HEADER_READ_TIMEOUT);
if (!get_line())
break; /* EOF or error or empty line */
if (DEBUG)
if ((STRNCASECMP(iobuf, "Content-length:") == 0)) {
/* extra read only for POST */
if (prequest != request_GET
-#if ENABLE_FEATURE_HTTPD_CGI
+# if ENABLE_FEATURE_HTTPD_CGI
&& prequest != request_HEAD
-#endif
+# endif
) {
tptr = skip_whitespace(iobuf + sizeof("Content-length:") - 1);
if (!tptr[0])
s += sizeof("bytes=")-1;
range_start = BB_STRTOOFF(s, &s, 10);
if (s[0] != '-' || range_start < 0) {
- range_start = 0;
+ range_start = -1;
} else if (s[1]) {
range_end = BB_STRTOOFF(s+1, NULL, 10);
if (errno || range_end < range_start)
- range_start = 0;
+ range_start = -1;
}
}
}
+#endif
+#if ENABLE_FEATURE_HTTPD_GZIP
+ if (STRNCASECMP(iobuf, "Accept-Encoding:") == 0) {
+ /* Note: we do not support "gzip;q=0"
+ * method of _disabling_ gzip
+ * delivery. No one uses that, though */
+ const char *s = strstr(iobuf, "gzip");
+ if (s) {
+ // want more thorough checks?
+ //if (s[-1] == ' '
+ // || s[-1] == ','
+ // || s[-1] == ':'
+ //) {
+ content_gzip = 1;
+ //}
+ }
+ }
#endif
} /* while extra header reading */
}
/* We are done reading headers, disable peer timeout */
alarm(0);
- if (strcmp(bb_basename(urlcopy), httpd_conf) == 0 || !ip_allowed) {
- /* protect listing [/path]/httpd_conf or IP deny */
+ if (strcmp(bb_basename(urlcopy), HTTPD_CONF) == 0 || !ip_allowed) {
+ /* protect listing [/path]/httpd.conf or IP deny */
send_headers_and_exit(HTTP_FORBIDDEN);
}
#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
- /* Case: no "Authorization:" was seen, but page does require passwd.
+ /* Case: no "Authorization:" was seen, but page might require passwd.
* Check that with dummy user:pass */
if (authorized < 0)
- authorized = check_user_passwd(urlcopy, ":");
+ authorized = check_user_passwd(urlcopy, (char *) "");
if (!authorized)
send_headers_and_exit(HTTP_UNAUTHORIZED);
#endif
header_ptr += 2;
write(proxy_fd, header_buf, header_ptr - header_buf);
free(header_buf); /* on the order of 8k, free it */
- /* cgi_io_loop_and_exit needs to have two disctinct fds */
- cgi_io_loop_and_exit(proxy_fd, dup(proxy_fd), length);
+ cgi_io_loop_and_exit(proxy_fd, proxy_fd, length);
}
#endif
/* protect listing "cgi-bin/" */
send_headers_and_exit(HTTP_FORBIDDEN);
}
- send_cgi_and_exit(urlcopy, prequest, length, cookie, content_type);
+ send_cgi_and_exit(urlcopy, urlcopy, prequest, length, cookie, content_type);
}
+#endif
+
+ if (urlp[-1] == '/') {
+ /* When index_page string is appended to <dir>/ URL, it overwrites
+ * the query string. If we fall back to call /cgi-bin/index.cgi,
+ * query string would be lost and not available to the CGI.
+ * Work around it by making a deep copy.
+ */
+ if (ENABLE_FEATURE_HTTPD_CGI)
+ g_query = xstrdup(g_query); /* ok for NULL too */
+ strcpy(urlp, index_page);
+ }
+ if (stat(tptr, &sb) == 0) {
#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
- {
char *suffix = strrchr(tptr, '.');
if (suffix) {
Htaccess *cur;
for (cur = script_i; cur; cur = cur->next) {
if (strcmp(cur->before_colon + 1, suffix) == 0) {
- send_cgi_and_exit(urlcopy, prequest, length, cookie, content_type);
+ send_cgi_and_exit(urlcopy, urlcopy, prequest, length, cookie, content_type);
}
}
}
- }
#endif
- if (prequest != request_GET && prequest != request_HEAD) {
- send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
- }
-#endif /* FEATURE_HTTPD_CGI */
-
- if (urlp[-1] == '/')
- strcpy(urlp, index_page);
- if (stat(tptr, &sb) == 0) {
file_size = sb.st_size;
last_mod = sb.st_mtime;
}
/* It's a dir URL and there is no index.html
* Try cgi-bin/index.cgi */
if (access("/cgi-bin/index.cgi"+1, X_OK) == 0) {
- urlp[0] = '\0';
- g_query = urlcopy;
- send_cgi_and_exit("/cgi-bin/index.cgi", prequest, length, cookie, content_type);
+ urlp[0] = '\0'; /* remove index_page */
+ send_cgi_and_exit("/cgi-bin/index.cgi", urlcopy, prequest, length, cookie, content_type);
}
}
-#endif
- /* else {
- * fall through to send_file, it errors out if open fails
- * }
- */
+ /* else fall through to send_file, it errors out if open fails: */
+ if (prequest != request_GET && prequest != request_HEAD) {
+ /* POST for files does not make sense */
+ send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
+ }
send_file_and_exit(tptr,
-#if ENABLE_FEATURE_HTTPD_CGI
(prequest != request_HEAD ? SEND_HEADERS_AND_BODY : SEND_HEADERS)
+ );
#else
- SEND_HEADERS_AND_BODY
+ send_file_and_exit(tptr, SEND_HEADERS_AND_BODY);
#endif
- );
}
/*
/* Wait for connections... */
fromAddr.len = LSA_SIZEOF_SA;
n = accept(server_socket, &fromAddr.u.sa, &fromAddr.len);
-
if (n < 0)
continue;
+
/* set the KEEPALIVE option to cull dead connections */
setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
if (fork() == 0) {
/* child */
-#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
/* Do not reload config on HUP */
signal(SIGHUP, SIG_IGN);
-#endif
close(server_socket);
xmove_fd(n, 0);
xdup2(0, 1);
/* Wait for connections... */
fromAddr.len = LSA_SIZEOF_SA;
n = accept(server_socket, &fromAddr.u.sa, &fromAddr.len);
-
if (n < 0)
continue;
+
/* set the KEEPALIVE option to cull dead connections */
setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
if (vfork() == 0) {
/* child */
-#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
/* Do not reload config on HUP */
signal(SIGHUP, SIG_IGN);
-#endif
close(server_socket);
xmove_fd(n, 0);
xdup2(0, 1);
/* Run a copy of ourself in inetd mode */
re_exec(argv_copy);
}
+ argv_copy[0][0] &= 0x7f;
/* parent, or vfork failed */
close(n);
} /* while (1) */
handle_incoming_and_exit(&fromAddr);
}
-#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
-static void sighup_handler(int sig)
+static void sighup_handler(int sig UNUSED_PARAM)
{
- parse_conf(default_path_httpd_conf, sig ? SIGNALED_PARSE : FIRST_PARSE);
- signal_SA_RESTART_empty_mask(SIGHUP, sighup_handler);
+ parse_conf(DEFAULT_PATH_HTTPD_CONF, SIGNALED_PARSE);
}
-#endif
enum {
c_opt_config_file = 0,
d_opt_decode_url,
h_opt_home_httpd,
- USE_FEATURE_HTTPD_ENCODE_URL_STR(e_opt_encode_url,)
- USE_FEATURE_HTTPD_BASIC_AUTH( r_opt_realm ,)
- USE_FEATURE_HTTPD_AUTH_MD5( m_opt_md5 ,)
- USE_FEATURE_HTTPD_SETUID( u_opt_setuid ,)
+ IF_FEATURE_HTTPD_ENCODE_URL_STR(e_opt_encode_url,)
+ IF_FEATURE_HTTPD_BASIC_AUTH( r_opt_realm ,)
+ IF_FEATURE_HTTPD_AUTH_MD5( m_opt_md5 ,)
+ IF_FEATURE_HTTPD_SETUID( u_opt_setuid ,)
p_opt_port ,
p_opt_inetd ,
p_opt_foreground,
OPT_CONFIG_FILE = 1 << c_opt_config_file,
OPT_DECODE_URL = 1 << d_opt_decode_url,
OPT_HOME_HTTPD = 1 << h_opt_home_httpd,
- OPT_ENCODE_URL = USE_FEATURE_HTTPD_ENCODE_URL_STR((1 << e_opt_encode_url)) + 0,
- OPT_REALM = USE_FEATURE_HTTPD_BASIC_AUTH( (1 << r_opt_realm )) + 0,
- OPT_MD5 = USE_FEATURE_HTTPD_AUTH_MD5( (1 << m_opt_md5 )) + 0,
- OPT_SETUID = USE_FEATURE_HTTPD_SETUID( (1 << u_opt_setuid )) + 0,
+ OPT_ENCODE_URL = IF_FEATURE_HTTPD_ENCODE_URL_STR((1 << e_opt_encode_url)) + 0,
+ OPT_REALM = IF_FEATURE_HTTPD_BASIC_AUTH( (1 << r_opt_realm )) + 0,
+ OPT_MD5 = IF_FEATURE_HTTPD_AUTH_MD5( (1 << m_opt_md5 )) + 0,
+ OPT_SETUID = IF_FEATURE_HTTPD_SETUID( (1 << u_opt_setuid )) + 0,
OPT_PORT = 1 << p_opt_port,
OPT_INETD = 1 << p_opt_inetd,
OPT_FOREGROUND = 1 << p_opt_foreground,
int server_socket = server_socket; /* for gcc */
unsigned opt;
char *url_for_decode;
- USE_FEATURE_HTTPD_ENCODE_URL_STR(const char *url_for_encode;)
- USE_FEATURE_HTTPD_SETUID(const char *s_ugid = NULL;)
- USE_FEATURE_HTTPD_SETUID(struct bb_uidgid_t ugid;)
- USE_FEATURE_HTTPD_AUTH_MD5(const char *pass;)
+ IF_FEATURE_HTTPD_ENCODE_URL_STR(const char *url_for_encode;)
+ IF_FEATURE_HTTPD_SETUID(const char *s_ugid = NULL;)
+ IF_FEATURE_HTTPD_SETUID(struct bb_uidgid_t ugid;)
+ IF_FEATURE_HTTPD_AUTH_MD5(const char *pass;)
INIT_G();
* If user gives relative path in -h,
* $SCRIPT_FILENAME will not be set. */
opt = getopt32(argv, "c:d:h:"
- USE_FEATURE_HTTPD_ENCODE_URL_STR("e:")
- USE_FEATURE_HTTPD_BASIC_AUTH("r:")
- USE_FEATURE_HTTPD_AUTH_MD5("m:")
- USE_FEATURE_HTTPD_SETUID("u:")
+ IF_FEATURE_HTTPD_ENCODE_URL_STR("e:")
+ IF_FEATURE_HTTPD_BASIC_AUTH("r:")
+ IF_FEATURE_HTTPD_AUTH_MD5("m:")
+ IF_FEATURE_HTTPD_SETUID("u:")
"p:ifv",
- &configFile, &url_for_decode, &home_httpd
- USE_FEATURE_HTTPD_ENCODE_URL_STR(, &url_for_encode)
- USE_FEATURE_HTTPD_BASIC_AUTH(, &g_realm)
- USE_FEATURE_HTTPD_AUTH_MD5(, &pass)
- USE_FEATURE_HTTPD_SETUID(, &s_ugid)
+ &opt_c_configFile, &url_for_decode, &home_httpd
+ IF_FEATURE_HTTPD_ENCODE_URL_STR(, &url_for_encode)
+ IF_FEATURE_HTTPD_BASIC_AUTH(, &g_realm)
+ IF_FEATURE_HTTPD_AUTH_MD5(, &pass)
+ IF_FEATURE_HTTPD_SETUID(, &s_ugid)
, &bind_addr_or_port
, &verbose
);
if (opt & OPT_DECODE_URL) {
- fputs(decodeString(url_for_decode, 1), stdout);
+ fputs(percent_decode_in_place(url_for_decode, /*strict:*/ 0), stdout);
return 0;
}
#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
#endif
#if ENABLE_FEATURE_HTTPD_AUTH_MD5
if (opt & OPT_MD5) {
- puts(pw_encrypt(pass, "$1$", 1));
+ char salt[sizeof("$1$XXXXXXXX")];
+ salt[0] = '$';
+ salt[1] = '1';
+ salt[2] = '$';
+ crypt_make_salt(salt + 3, 4);
+ puts(pw_encrypt(pass, salt, /*cleanup:*/ 0));
return 0;
}
#endif
#endif
}
-#if 0 /*was #if ENABLE_FEATURE_HTTPD_CGI*/
+#if 0
/* User can do it himself: 'env - PATH="$PATH" httpd'
* We don't do it because we don't want to screw users
* which want to do
}
#endif
-#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
- if (!(opt & OPT_INETD)) {
- /* runs parse_conf() inside */
- sighup_handler(0);
- } else
-#endif
- {
- parse_conf(default_path_httpd_conf, FIRST_PARSE);
- }
+ parse_conf(DEFAULT_PATH_HTTPD_CONF, FIRST_PARSE);
+ if (!(opt & OPT_INETD))
+ signal(SIGHUP, sighup_handler);
xfunc_error_retval = 0;
if (opt & OPT_INETD)