Changeset 1770 in MondoRescue for branches/stable/mindi-busybox/networking/httpd.c

Timestamp:

Nov 6, 2007, 11:01:53 AM (16 years ago)

Author:

Bruno Cornec

Message:

• Better output for mindi-busybox revision
• Remove dummy file created on NFS - report from Arnaud Tiger <arnaud.tiger_at_hp.com>
• strace useful for debug
• fix new versions for pb (2.0.0 for mindi and 1.7.2 for mindi-busybox)
• fix build process for mindi-busybox + options used in that version (dd for label-partitions-as-necessary)
• fix typo in label-partitions-as-necessary which doesn't seem to work
• Update to busybox 1.7.2
• perl is now required at restore time to support uuid swap partitions (and will be used for many other thigs

in the future for sure)

• next mindi version will be 2.0.0 due to all the changes made in it (udev may break working distros)
• small optimization in mindi on keyboard handling (one single find instead of multiple)
• better interaction for USB device when launching mindi manually
• attempt to automatically guess block disk size for ramdisk
• fix typos in bkphw
• Fix the remaining problem with UUID support for swap partitions
• Updates mondoarchive man page for USB support
• Adds preliminary Hardware support to mindi (Proliant SSSTK)
• Tries to add udev support also for rhel4
• Fix UUID support which was still broken.
• Be conservative in test for the start-nfs script
• Update config file for mindi-busybox for 1.7.2 migration
• Try to run around a busybox bug (1.2.2 pb on inexistant links)
• Add build content for mindi-busybox in pb
• Remove distributions content for mindi-busybox
• Fix a warning on inexistant raidtab
• Solve problem on tmpfs in restore init (Problem of inexistant symlink and busybox)
• Create MONDO_CACHE and use it everywhere + creation at start
• Really never try to eject a USB device
• Fix a issue with &> usage (replaced with 1> and 2>)
• Adds magic file to depllist in order to have file working + ldd which helps for debugging issues
• tty modes correct to avoid sh error messages
• Use ext3 normally and not ext2 instead
• USB device should be corrected after reading (take 1st part)
• Adds a mount_USB_here function derived from mount_CDROM_here
• usb detection place before /dev detection in device name at restore time
• Fix when restoring from USB: media is asked in interactive mode
• Adds USB support for mondorestore
• mount_cdrom => mount_media
• elilo.efi is now searched throughout /boot/efi and not in a fixed place as there is no standard
• untar-and-softlink => untar (+ interface change)
• suppress useless softlinks creation/removal in boot process
• avoids udevd messages on groups
• Increase # of disks to 99 as in mindi at restore time (should be a conf file parameter)
• skip existing big file creation
• seems to work correctly for USB mindi boot
• Adds group and tty link to udev conf
• Always load usb-torage (even 2.6) to initiate USB bus discovery
• Better printing of messages
• Attempt to fix a bug in supporting OpenSusE 10.3 kernel for initramfs (mindi may now use multiple regex for kernel initrd detection)
• Links were not correctly done as non relative for modules in mindi
• exclusion of modules denied now works
• Also create modules in their ordinary place, so that classical modprobe works + copy modules.dep
• Fix bugs for DENY_MODS handling
• Add device /dev/console for udev
• ide-generic should now really be excluded
• Fix a bug in major number for tty
• If udev then adds modprobe/insmod to rootfs
• tty0 is also cretaed with udev
• ide-generic put rather in DENY_MODS
• udevd remove from deplist s handled in mindi directly
• better default for mindi when using --usb
• Handles dynamically linked busybox (in case we want to use it soon ;-)
• Adds fixed devices to create for udev
• ide-generic should not be part of the initrd when using libata v2
• support a dynamically linked udev (case on Ubuntu 7.10 and Mandriva 2008.0 so should be quite generic) This will give incitation to move to dyn. linked binaries in the initrd which will help for other tasks (ia6 4)
• Improvement in udev support (do not use cl options not available in busybox)
• Udev in mindi
  • auto creation of the right links at boot time with udev-links.conf(from Mandriva 2008.0)
  • rework startup of udev as current makes kernel crash (from Mandriva 2008.0)
  • add support for 64 bits udev
• Try to render MyInsmod silent at boot time
• Adds udev support (mandatory for newest distributions to avoid remapping of devices in a different way as on the original system)
• We also need vaft format support for USB boot
• Adds libusual support (Ubuntu 7.10 needs it for USB)
• Improve Ubuntu/Debian keyboard detection and support
• pbinit adapted to new pb (0.8.10). Filtering of docs done in it
• Suppress some mondo warnings and errors on USB again
• Tries to fix lack of files in deb mindi package
• Verify should now work for USB devices
• More log/mesages improvement for USB support
• - Supress g_erase_tmpdir_and_scratchdir
• Improve some log messages for USB support
• Try to improve install in mindi to avoid issues with isolinux.cfg not installed vene if in the pkg :-(
• Improve mindi-busybox build
• In conformity with pb 0.8.9
• Add support for Ubuntu 7.10 in build process
• Add USB Key button to Menu UI (CD streamer removed)
• Attempt to fix error messages on tmp/scratch files at the end by removing those dir at the latest possible.
• Fix a bug linked to the size of the -E param which could be used (Arnaud Tiger/René Ribaud).
• Integrate ~/.pbrc content into mondorescue.pb (required project-builder >= 0.8.7)
• Put mondorescue in conformity with new pb filtering rules
• Add USB support at restore time (no test done yet). New start-usb script PB varibale added where useful
• Unmounting USB device before removal of temporary scratchdir
• Stil refining USB copy back to mondo (one command was not executed)
• No need to have the image subdor in the csratchdir when USB.
• umount the USB partition before attempting to use it
• Remove useless copy from mindi to mondo at end of USB handling

(risky merge, we are raising the limits of 2 diverging branches. The status of stable is not completely sure as such. Will need lots of tests, but it's not yet done :-()
(merge -r1692:1769 $SVN_M/branches/2.2.5)

File:

• branches/stable/mindi-busybox/networking/httpd.c (modified) (6 diffs)

branches/stable/mindi-busybox/networking/httpd.c

@@ -21 +21 @@
  *
  *
- * When a url contains "cgi-bin" it is assumed to be a cgi script.  The
+ * 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
  * after setting QUERY_STRING and other environment variables.
+ *
+ * Doc:
+ * "CGI Environment Variables": http://hoohoo.ncsa.uiuc.edu/cgi/env.html
  *
  * The server can also be invoked as a url arg decoder and html text encoder
@@ -40 +43 @@
  * A:127.0.0.1       # Allow local loopback connections
  * D:*               # Deny from other IP connections
+ * E404:/path/e404.html # /path/e404.html is the 404 (not found) error page
  * /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/
@@ -82 +86 @@
  * result, the subdir settings only have a lifetime of a single request.
  *
+ * Custom error pages can contain an absolute path or be relative to
+ * 'home_httpd'. Error pages are to be static files (no CGI or script). Error
+ * page can only be defined in the root configuration file and are not taken
+ * into account in local (directories) config files.
  *
  * If -c is not set, an attempt will be made to open the default
@@ -87 +95 @@
  * server exits with an error.
  *
-*/
-
-
-#include <stdio.h>
-#include <ctype.h>         /* for isspace           */
-#include <string.h>
-#include <stdlib.h>        /* for malloc            */
-#include <time.h>
-#include <unistd.h>        /* for close             */
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/socket.h>    /* for connect and socket*/
-#include <netinet/in.h>    /* for sockaddr_in       */
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <fcntl.h>         /* for open modes        */
-#include "busybox.h"
-
-
-static const char httpdVersion[] = "busybox httpd/1.35 6-Oct-2004";
-static const char default_path_httpd_conf[] = "/etc";
-static const char httpd_conf[] = "httpd.conf";
-static const char home[] = "./";
-
-#ifdef CONFIG_LFS
-# define cont_l_fmt "%lld"
-# define cont_l_type (long long)
-#else
-# define cont_l_fmt "%ld"
-# define cont_l_type (long)
-#endif
-
-#define TIMEOUT 60
-
-// Note: busybox xfuncs are not used because we want the server to keep running
-//       if something bad happens due to a malformed user request.
-//       As a result, all memory allocation after daemonize
-//       is checked rigorously
+ */
+
+#include "libbb.h"
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+#include <sys/sendfile.h>
+#endif
 
 //#define DEBUG 1
-
-#ifndef DEBUG
-# define DEBUG 0
-#endif
-
-#define MAX_MEMORY_BUFF 8192    /* IO buffer */
-
-typedef struct HT_ACCESS {
+#define DEBUG 0
+
+/* amount of buffering in a pipe */
+#ifndef PIPE_BUF
+# define PIPE_BUF 4096
+#endif
+
+#define IOBUF_SIZE 8192    /* IO buffer */
+
+#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 HTTP_200[] ALIGN1 = "HTTP/1.0 200 OK\r\n";
+
+typedef struct has_next_ptr {
+    struct has_next_ptr *next;
+} has_next_ptr;
+
+/* Must have "next" as a first member */
+typedef struct Htaccess {
+    struct Htaccess *next;
     char *after_colon;
-    struct HT_ACCESS *next;
-    char before_colon[1];         /* really bigger, must last */
+    char before_colon[1];  /* really bigger, must be last */
 } Htaccess;
 
-typedef struct HT_ACCESS_IP {
-    unsigned int ip;
-    unsigned int mask;
+/* Must have "next" as a first member */
+typedef struct Htaccess_IP {
+    struct Htaccess_IP *next;
+    unsigned ip;
+    unsigned mask;
     int allow_deny;
-    struct HT_ACCESS_IP *next;
 } Htaccess_IP;
 
-typedef struct
-{
-  char buf[MAX_MEMORY_BUFF];
-
-  USE_FEATURE_HTTPD_BASIC_AUTH(const char *realm;)
-  USE_FEATURE_HTTPD_BASIC_AUTH(char *remoteuser;)
-
-  const char *query;
-
-  USE_FEATURE_HTTPD_CGI(char *referer;)
-
-  const char *configFile;
-
-  unsigned int rmt_ip;
-#if defined(CONFIG_FEATURE_HTTPD_CGI) || DEBUG
-  char rmt_ip_str[16];     /* for set env REMOTE_ADDR */
-#endif
-  unsigned port;           /* server initial port and for
-                  set env REMOTE_PORT */
-  union HTTPD_FOUND {
+enum {
+    HTTP_OK = 200,
+    HTTP_MOVED_TEMPORARILY = 302,
+    HTTP_BAD_REQUEST = 400,       /* malformed syntax */
+    HTTP_UNAUTHORIZED = 401, /* authentication needed, respond with auth hdr */
+    HTTP_NOT_FOUND = 404,
+    HTTP_FORBIDDEN = 403,
+    HTTP_REQUEST_TIMEOUT = 408,
+    HTTP_NOT_IMPLEMENTED = 501,   /* used for unrecognized requests */
+    HTTP_INTERNAL_SERVER_ERROR = 500,
+    HTTP_CONTINUE = 100,
+#if 0   /* future use */
+    HTTP_SWITCHING_PROTOCOLS = 101,
+    HTTP_CREATED = 201,
+    HTTP_ACCEPTED = 202,
+    HTTP_NON_AUTHORITATIVE_INFO = 203,
+    HTTP_NO_CONTENT = 204,
+    HTTP_MULTIPLE_CHOICES = 300,
+    HTTP_MOVED_PERMANENTLY = 301,
+    HTTP_NOT_MODIFIED = 304,
+    HTTP_PAYMENT_REQUIRED = 402,
+    HTTP_BAD_GATEWAY = 502,
+    HTTP_SERVICE_UNAVAILABLE = 503, /* overload, maintenance */
+    HTTP_RESPONSE_SETSIZE = 0xffffffff
+#endif
+};
+
+static const uint16_t http_response_type[] ALIGN2 = {
+    HTTP_OK,
+    HTTP_MOVED_TEMPORARILY,
+    HTTP_REQUEST_TIMEOUT,
+    HTTP_NOT_IMPLEMENTED,
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH 
+    HTTP_UNAUTHORIZED,
+#endif
+    HTTP_NOT_FOUND,
+    HTTP_BAD_REQUEST,
+    HTTP_FORBIDDEN,
+    HTTP_INTERNAL_SERVER_ERROR,
+#if 0   /* not implemented */
+    HTTP_CREATED,
+    HTTP_ACCEPTED,
+    HTTP_NO_CONTENT,
+    HTTP_MULTIPLE_CHOICES,
+    HTTP_MOVED_PERMANENTLY,
+    HTTP_NOT_MODIFIED,
+    HTTP_BAD_GATEWAY,
+    HTTP_SERVICE_UNAVAILABLE,
+#endif
+};
+
+static const struct {
+    const char *name;
+    const char *info;
+} http_response[ARRAY_SIZE(http_response_type)] = {
+    { "OK", NULL },
+    { "Found", "Directories must end with a slash" }, /* ?? */
+    { "Request Timeout", "No request appeared within 60 seconds" },
+    { "Not Implemented", "The requested method is not recognized" },
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    { "Unauthorized", "" },
+#endif
+    { "Not Found", "The requested URL was not found" },
+    { "Bad Request", "Unsupported method" },
+    { "Forbidden", ""  },
+    { "Internal Server Error", "Internal Server Error" },
+#if 0   /* not implemented */
+    { "Created" },
+    { "Accepted" },
+    { "No Content" },
+    { "Multiple Choices" },
+    { "Moved Permanently" },
+    { "Not Modified" },
+    { "Bad Gateway", "" },
+    { "Service Unavailable", "" },
+#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 */
+    time_t last_mod;
+    off_t ContentLength;    /* -1 - unknown */
+    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 *home_httpd;
+
     const char *found_mime_type;
     const char *found_moved_temporarily;
-  } httpd_found;
-
-  off_t ContentLength;          /* -1 - unknown */
-  time_t last_mod;
-
-  Htaccess_IP *ip_a_d;          /* config allow/deny lines */
-  int flg_deny_all;
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-  Htaccess *auth;               /* config user:password lines */
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
-  Htaccess *mime_a;             /* config mime types */
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-  int accepted_socket;
-# define a_c_r config->accepted_socket
-# define a_c_w config->accepted_socket
-#else
-# define a_c_r 0
-# define a_c_w 1
-#endif
-  volatile int alarm_signaled;
-
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
-  Htaccess *script_i;           /* config script interpreters */
-#endif
-} HttpdConfig;
-
-static HttpdConfig *config;
-
-static const char request_GET[] = "GET";    /* size algorithmic optimize */
-
-static const char* const suffixTable [] = {
-/* Warning: shorted 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
-  0, "application/octet-stream" /* default */
-  };
-
-typedef enum
-{
-  HTTP_OK = 200,
-  HTTP_MOVED_TEMPORARILY = 302,
-  HTTP_BAD_REQUEST = 400,       /* malformed syntax */
-  HTTP_UNAUTHORIZED = 401, /* authentication needed, respond with auth hdr */
-  HTTP_NOT_FOUND = 404,
-  HTTP_FORBIDDEN = 403,
-  HTTP_REQUEST_TIMEOUT = 408,
-  HTTP_NOT_IMPLEMENTED = 501,   /* used for unrecognized requests */
-  HTTP_INTERNAL_SERVER_ERROR = 500,
-#if 0 /* future use */
-  HTTP_CONTINUE = 100,
-  HTTP_SWITCHING_PROTOCOLS = 101,
-  HTTP_CREATED = 201,
-  HTTP_ACCEPTED = 202,
-  HTTP_NON_AUTHORITATIVE_INFO = 203,
-  HTTP_NO_CONTENT = 204,
-  HTTP_MULTIPLE_CHOICES = 300,
-  HTTP_MOVED_PERMANENTLY = 301,
-  HTTP_NOT_MODIFIED = 304,
-  HTTP_PAYMENT_REQUIRED = 402,
-  HTTP_BAD_GATEWAY = 502,
-  HTTP_SERVICE_UNAVAILABLE = 503, /* overload, maintenance */
-  HTTP_RESPONSE_SETSIZE=0xffffffff
-#endif
-} HttpResponseNum;
-
-typedef struct
-{
-  HttpResponseNum type;
-  const char *name;
-  const char *info;
-} HttpEnumString;
-
-static const HttpEnumString httpResponseNames[] = {
-  { HTTP_OK, "OK", NULL },
-  { HTTP_MOVED_TEMPORARILY, "Found", "Directories must end with a slash." },
-  { HTTP_REQUEST_TIMEOUT, "Request Timeout",
-    "No request appeared within a reasonable time period." },
-  { HTTP_NOT_IMPLEMENTED, "Not Implemented",
-    "The requested method is not recognized by this server." },
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-  { HTTP_UNAUTHORIZED, "Unauthorized", "" },
-#endif
-  { HTTP_NOT_FOUND, "Not Found",
-    "The requested URL was not found on this server." },
-  { HTTP_BAD_REQUEST, "Bad Request", "Unsupported method." },
-  { HTTP_FORBIDDEN, "Forbidden", "" },
-  { HTTP_INTERNAL_SERVER_ERROR, "Internal Server Error",
-    "Internal Server Error" },
-#if 0                               /* not implemented */
-  { HTTP_CREATED, "Created" },
-  { HTTP_ACCEPTED, "Accepted" },
-  { HTTP_NO_CONTENT, "No Content" },
-  { HTTP_MULTIPLE_CHOICES, "Multiple Choices" },
-  { HTTP_MOVED_PERMANENTLY, "Moved Permanently" },
-  { HTTP_NOT_MODIFIED, "Not Modified" },
-  { HTTP_BAD_GATEWAY, "Bad Gateway", "" },
-  { HTTP_SERVICE_UNAVAILABLE, "Service Unavailable", "" },
+    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;)
+
+#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] */
+#define hdr_buf bb_common_bufsiz1
+    char *hdr_ptr;
+    int hdr_cnt;
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+    const char *http_error_page[ARRAY_SIZE(http_response_type)];
 #endif
 };
-
-
-static const char RFC1123FMT[] = "%a, %d %b %Y %H:%M:%S GMT";
-static const char Content_length[] = "Content-length:";
-
-
-static int
-scan_ip (const char **ep, unsigned int *ip, unsigned char endc)
-{
-  const char *p = *ep;
-  int auto_mask = 8;
-  int j;
-
-  *ip = 0;
-  for (j = 0; j < 4; j++) {
-    unsigned int octet;
-
-    if ((*p < '0' || *p > '9') && (*p != '/' || j == 0) && *p != 0)
-      return -auto_mask;
-    octet = 0;
-    while (*p >= '0' && *p <= '9') {
-      octet *= 10;
-      octet += *p - '0';
-      if (octet > 255)
+#define G (*ptr_to_globals)
+#define verbose           (G.verbose          )
+#define flg_deny_all      (G.flg_deny_all     )
+#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 home_httpd        (G.home_httpd       )
+#define found_mime_type   (G.found_mime_type  )
+#define found_moved_temporarily (G.found_moved_temporarily)
+#define ContentLength     (G.ContentLength    )
+#define last_mod          (G.last_mod         )
+#define ip_a_d            (G.ip_a_d           )
+#define g_realm           (G.g_realm          )
+#define remoteuser        (G.remoteuser       )
+#define referer           (G.referer          )
+#define user_agent        (G.user_agent       )
+#define rmt_ip_str        (G.rmt_ip_str       )
+#define g_auth            (G.g_auth           )
+#define mime_a            (G.mime_a           )
+#define script_i          (G.script_i         )
+#define iobuf             (G.iobuf            )
+#define hdr_ptr           (G.hdr_ptr          )
+#define hdr_cnt           (G.hdr_cnt          )
+#define http_error_page   (G.http_error_page  )
+#define INIT_G() do { \
+    PTR_TO_GLOBALS = xzalloc(sizeof(G)); \
+    USE_FEATURE_HTTPD_BASIC_AUTH(g_realm = "Web Server Authentication";) \
+    bind_addr_or_port = "80"; \
+    ContentLength = -1; \
+} while (0)
+
+
+#define STRNCASECMP(a, str) strncasecmp((a), (str), sizeof(str)-1)
+
+/* Prototypes */
+static void send_file_and_exit(const char *url, int headers) ATTRIBUTE_NORETURN;
+
+static void free_llist(has_next_ptr **pptr)
+{
+    has_next_ptr *cur = *pptr;
+    while (cur) {
+        has_next_ptr *t = cur;
+        cur = cur->next;
+        free(t);
+    }
+    *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)
+{
+    free_llist((has_next_ptr**)pptr);
+}
+
+/* Returns presumed mask width in bits or < 0 on error.
+ * Updates strp, stores IP at provided pointer */
+static int scan_ip(const char **strp, unsigned *ipp, unsigned char endc)
+{
+    const char *p = *strp;
+    int auto_mask = 8;
+    unsigned ip = 0;
+    int j;
+
+    if (*p == '/')
         return -auto_mask;
-      p++;
-    }
-    if (*p == '.')
-      p++;
-    if (*p != '/' && *p != 0)
-      auto_mask += 8;
-    *ip = ((*ip) << 8) | octet;
-  }
-  if (*p != 0) {
-    if (*p != endc)
-        return -auto_mask;
-    p++;
-    if(*p == 0)
-        return -auto_mask;
-  }
-  *ep = p;
-  return auto_mask;
-}
-
-static int
-scan_ip_mask (const char *ipm, unsigned int *ip, unsigned int *mask)
-{
-  int i;
-  unsigned int msk;
-
-  i = scan_ip(&ipm, ip, '/');
-  if(i < 0)
-    return i;
-  if(*ipm) {
-    const char *p = ipm;
-
-    i = 0;
-    while (*p) {
-        if (*p < '0' || *p > '9') {
-            if (*p == '.') {
-                i = scan_ip (&ipm, mask, 0);
-                return i != 32;
-            }
+
+    for (j = 0; j < 4; j++) {
+        unsigned octet;
+
+        if ((*p < '0' || *p > '9') && *p != '/' && *p)
+            return -auto_mask;
+        octet = 0;
+        while (*p >= '0' && *p <= '9') {
+            octet *= 10;
+            octet += *p - '0';
+            if (octet > 255)
+                return -auto_mask;
+            p++;
+        }
+        if (*p == '.')
+            p++;
+        if (*p != '/' && *p)
+            auto_mask += 8;
+        ip = (ip << 8) | octet;
+    }
+    if (*p) {
+        if (*p != endc)
+            return -auto_mask;
+        p++;
+        if (*p == '\0')
+            return -auto_mask;
+    }
+    *ipp = ip;
+    *strp = p;
+    return auto_mask;
+}
+
+/* Returns 0 on success. Stores IP and mask at provided pointers */
+static int scan_ip_mask(const char *str, unsigned *ipp, unsigned *maskp)
+{
+    int i;
+    unsigned mask;
+    char *p;
+
+    i = scan_ip(&str, ipp, '/');
+    if (i < 0)
+        return i;
+
+    if (*str) {
+        /* there is /xxx after dotted-IP address */
+        i = bb_strtou(str, &p, 10);
+        if (*p == '.') {
+            /* 'xxx' itself is dotted-IP mask, parse it */
+            /* (return 0 (success) only if it has N.N.N.N form) */
+            return scan_ip(&str, maskp, '\0') - 32;
+        }
+        if (*p)
             return -1;
-        }
-        i *= 10;
-        i += *p - '0';
-        p++;
-    }
-  }
-  if (i > 32 || i < 0)
-      return -1;
-  msk = 0x80000000;
-  *mask = 0;
-  while (i > 0) {
-    *mask |= msk;
-    msk >>= 1;
-    i--;
-  }
-  return 0;
-}
-
-#if defined(CONFIG_FEATURE_HTTPD_BASIC_AUTH) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES)
-static void free_config_lines(Htaccess **pprev)
-{
-    Htaccess *prev = *pprev;
-
-    while( prev ) {
-    Htaccess *cur = prev;
-
-    prev = cur->next;
-    free(cur);
-    }
-    *pprev = NULL;
-}
-#endif
-
+    }
+
+    if (i > 32)
+        return -1;
+
+    if (sizeof(unsigned) == 4 && i == 32) {
+        /* mask >>= 32 below may not work */
+        mask = 0;
+    } else {
+        mask = 0xffffffff;
+        mask >>= i;
+    }
+    /* i == 0 -> *maskp = 0x00000000
+     * i == 1 -> *maskp = 0x80000000
+     * i == 4 -> *maskp = 0xf0000000
+     * i == 31 -> *maskp = 0xfffffffe
+     * i == 32 -> *maskp = 0xffffffff */
+    *maskp = (uint32_t)(~mask);
+    return 0;
+}
+
+/*
+ * 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
+ *
+ * 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
+ * SUBDIR_PARSE.
+ * Error pages are only parsed on the main config file.
+ *
+ * path   Path where to look for httpd.conf (without filename).
+ * flag   Type of the parse request.
+ */
 /* flag */
 #define FIRST_PARSE          0
@@ -388 +427 @@
 #define SIGNALED_PARSE       2
 #define FIND_FROM_HTTPD_ROOT 3
-/****************************************************************************
- *
- > $Function: parse_conf()
- *
- * $Description: 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
- *
- * 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
- * SUBDIR_PARSE.
- *
- * $Parameters:
- *      (const char *) path . . null for ip address checks, path for password
- *                              checks.
- *      (int) flag  . . . . . . the source of the parse request.
- *
- * $Return: (None)
- *
- ****************************************************************************/
 static void parse_conf(const char *path, int flag)
 {
-    FILE *f;
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-    Htaccess *prev, *cur;
-#elif CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
-    Htaccess *cur;
-#endif
-
-    const char *cf = config->configFile;
-    char buf[160];
-    char *p0 = NULL;
-    char *c, *p;
-
-    /* free previous ip setup if present */
-    Htaccess_IP *pip = config->ip_a_d;
-
-    while( pip ) {
-    Htaccess_IP *cur_ipl = pip;
-
-    pip = cur_ipl->next;
-    free(cur_ipl);
-    }
-    config->ip_a_d = NULL;
-
-    config->flg_deny_all = 0;
-
-#if defined(CONFIG_FEATURE_HTTPD_BASIC_AUTH) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR)
-    /* retain previous auth and mime config only for subdir parse */
-    if(flag != SUBDIR_PARSE) {
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-    free_config_lines(&config->auth);
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
-    free_config_lines(&config->mime_a);
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
-    free_config_lines(&config->script_i);
-#endif
-    }
-#endif
-
-    if(flag == SUBDIR_PARSE || cf == NULL) {
-    cf = alloca(strlen(path) + sizeof(httpd_conf) + 2);
-    if(cf == NULL) {
-        if(flag == FIRST_PARSE)
-        bb_error_msg_and_die(bb_msg_memory_exhausted);
-        return;
-    }
-    sprintf((char *)cf, "%s/%s", path, httpd_conf);
-    }
-
-    while((f = fopen(cf, "r")) == NULL) {
-    if(flag == SUBDIR_PARSE || flag == FIND_FROM_HTTPD_ROOT) {
-        /* config file not found, no changes to config */
-        return;
-    }
-    if(config->configFile && flag == FIRST_PARSE) /* if -c option given */
-        bb_perror_msg_and_die("%s", cf);
-    flag = FIND_FROM_HTTPD_ROOT;
-    cf = httpd_conf;
-    }
-
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-    prev = config->auth;
-#endif
-    /* This could stand some work */
-    while ( (p0 = fgets(buf, sizeof(buf), f)) != NULL) {
-    c = NULL;
-    for(p = p0; *p0 != 0 && *p0 != '#'; p0++) {
-        if(!isspace(*p0)) {
-            *p++ = *p0;
-            if(*p0 == ':' && c == NULL)
-            c = p;
-        }
-    }
-    *p = 0;
-
-    /* test for empty or strange line */
-    if (c == NULL || *c == 0)
-        continue;
-    p0 = buf;
-    if(*p0 == 'd')
-        *p0 = 'D';
-    if(*c == '*') {
-        if(*p0 == 'D') {
-        /* memorize deny all */
-        config->flg_deny_all++;
-        }
-        /* skip default other "word:*" config lines */
-        continue;
-    }
-
-    if(*p0 == 'a')
-        *p0 = 'A';
-    else if(*p0 != 'D' && *p0 != 'A'
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-       && *p0 != '/'
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
-       && *p0 != '.'
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
-       && *p0 != '*'
-#endif
-      )
-           continue;
-    if(*p0 == 'A' || *p0 == 'D') {
-        /* storing current config IP line */
-        pip = calloc(1, sizeof(Htaccess_IP));
-        if(pip) {
-            if(scan_ip_mask (c, &(pip->ip), &(pip->mask))) {
-            /* syntax IP{/mask} error detected, protect all */
+    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 *cf = configFile;
+    char buf[160];
+    char *p0 = NULL;
+    char *c, *p;
+    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) {
+#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
+
+    if (flag == SUBDIR_PARSE || cf == NULL) {
+        cf = alloca(strlen(path) + sizeof(httpd_conf) + 2);
+        sprintf((char *)cf, "%s/%s", path, httpd_conf);
+    }
+
+    while ((f = fopen(cf, "r")) == NULL) {
+        if (flag == SUBDIR_PARSE || flag == FIND_FROM_HTTPD_ROOT) {
+            /* config file not found, no changes to config */
+            return;
+        }
+        if (configFile && flag == FIRST_PARSE) /* if -c option given */
+            bb_perror_msg_and_die("%s", cf);
+        flag = FIND_FROM_HTTPD_ROOT;
+        cf = 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) {
+        c = NULL;
+        for (p = p0; *p0 != '\0' && *p0 != '#'; p0++) {
+            if (!isspace(*p0)) {
+                *p++ = *p0;
+                if (*p0 == ':' && c == NULL)
+                    c = p;
+            }
+        }
+        *p = '\0';
+
+        /* test for empty or strange line */
+        if (c == NULL || *c == '\0')
+            continue;
+        p0 = buf;
+        if (*p0 == 'd')
             *p0 = 'D';
-            pip->mask = 0;
-            }
-            pip->allow_deny = *p0;
-            if(*p0 == 'D') {
-            /* Deny:form_IP move top */
-            pip->next = config->ip_a_d;
-            config->ip_a_d = pip;
-            } else {
-            /* add to bottom A:form_IP config line */
-            Htaccess_IP *prev_IP = config->ip_a_d;
-
-            if(prev_IP == NULL) {
-                config->ip_a_d = pip;
-            } else {
-                while(prev_IP->next)
-                    prev_IP = prev_IP->next;
-                prev_IP->next = pip;
-            }
-            }
-        }
-        continue;
-    }
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-    if(*p0 == '/') {
-        /* make full path from httpd root / curent_path / config_line_path */
-        cf = flag == SUBDIR_PARSE ? path : "";
-        p0 = malloc(strlen(cf) + (c - buf) + 2 + strlen(c));
-        if(p0 == NULL)
-        continue;
-        c[-1] = 0;
-        sprintf(p0, "/%s%s", cf, buf);
-
-        /* another call bb_simplify_path */
-        cf = p = p0;
-
-        do {
-            if (*p == '/') {
-            if (*cf == '/') {    /* skip duplicate (or initial) slash */
-                continue;
-            } else if (*cf == '.') {
-                if (cf[1] == '/' || cf[1] == 0) { /* remove extra '.' */
+        if (*c == '*') {
+            if (*p0 == 'D') {
+                /* memorize deny all */
+                flg_deny_all = 1;
+            }
+            /* skip default other "word:*" config lines */
+            continue;
+        }
+
+        if (*p0 == 'a')
+            *p0 = 'A';
+        if (*p0 == 'A' || *p0 == 'D') {
+            /* storing current config IP line */
+            pip = xzalloc(sizeof(Htaccess_IP));
+            if (pip) {
+                if (scan_ip_mask(c, &(pip->ip), &(pip->mask))) {
+                    /* syntax IP{/mask} error detected, protect all */
+                    *p0 = 'D';
+                    pip->mask = 0;
+                }
+                pip->allow_deny = *p0;
+                if (*p0 == 'D') {
+                    /* Deny:from_IP move top */
+                    pip->next = ip_a_d;
+                    ip_a_d = pip;
+                } else {
+                    /* add to bottom A:form_IP config line */
+                    Htaccess_IP *prev_IP = ip_a_d;
+
+                    if (prev_IP == NULL) {
+                        ip_a_d = pip;
+                    } else {
+                        while (prev_IP->next)
+                            prev_IP = prev_IP->next;
+                        prev_IP->next = pip;
+                    }
+                }
+            }
+            continue;
+        }
+
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+        if (flag == FIRST_PARSE && *p0 == 'E') {
+            int i;
+            /* error status code */
+            int status = atoi(++p0);
+            /* c already points at the character following ':' in parse loop */
+            /* c = strchr(p0, ':'); c++; */
+            if (status < HTTP_CONTINUE) {
+                bb_error_msg("config error '%s' in '%s'", buf, cf);
                 continue;
-                } else if ((cf[1] == '.') && (cf[2] == '/' || cf[2] == 0)) {
-                ++cf;
-                if (p > p0) {
-                    while (*--p != '/');    /* omit previous dir */
-                }
-                continue;
-                }
-            }
-            }
-            *++p = *cf;
-        } while (*++cf);
-
-        if ((p == p0) || (*p != '/')) {      /* not a trailing slash */
-        ++p;                             /* so keep last character */
-        }
-        *p = 0;
-        sprintf(p0, "%s:%s", p0, c);
-    }
-#endif
-
-#if defined(CONFIG_FEATURE_HTTPD_BASIC_AUTH) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR)
-    /* storing current config line */
-    cur = calloc(1, sizeof(Htaccess) + strlen(p0));
-    if(cur) {
-        cf = strcpy(cur->before_colon, p0);
-        c = strchr(cf, ':');
-        *c++ = 0;
-        cur->after_colon = c;
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
-        if(*cf == '.') {
-        /* config .mime line move top for overwrite previous */
-        cur->next = config->mime_a;
-        config->mime_a = cur;
-        continue;
-        }
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
-        if(*cf == '*' && cf[1] == '.') {
-        /* config script interpreter line move top for overwrite previous */
-        cur->next = config->script_i;
-        config->script_i = cur;
-        continue;
-        }
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-        free(p0);
-        if(prev == NULL) {
-        /* first line */
-        config->auth = prev = cur;
-        } else {
-        /* sort path, if current lenght eq or bigger then move up */
-        Htaccess *prev_hti = config->auth;
-        size_t l = strlen(cf);
-        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 */
-                config->auth = cur;
-            }
-            break;
-            }
-            if(prev_hti != hti)
-                prev_hti = prev_hti->next;
-        }
-        if(!hti)  {       /* not inserted, add to bottom */
-            prev->next = cur;
-            prev = cur;
-        }
-        }
-#endif
-    }
-#endif
-   }
-   fclose(f);
-}
-
-#ifdef CONFIG_FEATURE_HTTPD_ENCODE_URL_STR
-/****************************************************************************
- *
- > $Function: encodeString()
- *
- * $Description: Given a string, html encode special characters.
- *   This is used for the -e command line option to provide an easy way
- *   for scripts to encode result data without confusing browsers.  The
- *   returned string pointer is memory allocated by malloc().
- *
- * $Parameters:
- *      (const char *) string . . The first string to encode.
- *
- * $Return: (char *) . . . .. . . A pointer to the encoded string.
- *
- * $Errors: Returns a null string ("") if memory is not available.
- *
- ****************************************************************************/
-static char *encodeString(const char *string)
-{
-  /* take the simple route and encode everything */
-  /* could possibly scan once to get length.     */
-  int len = strlen(string);
-  char *out = malloc(len * 6 + 1);
-  char *p=out;
-  char ch;
-
-  if (!out) return "";
-  while ((ch = *string++)) {
-    // very simple check for what to encode
-    if (isalnum(ch)) *p++ = ch;
-    else p += sprintf(p, "&#%d;", (unsigned char) ch);
-  }
-  *p=0;
-  return out;
-}
-#endif          /* CONFIG_FEATURE_HTTPD_ENCODE_URL_STR */
-
-/****************************************************************************
- *
- > $Function: decodeString()
- *
- * $Description: 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 strdup() 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.
- *
- * $Parameters:
- *      (char *) string . . . The first string to decode.
- *      (int)    flag   . . . 1 if require decode '+' as ' ' for CGI
- *
- * $Return: (char *)  . . . . A pointer to the decoded string (same as input).
- *
- * $Errors: None
- *
- ****************************************************************************/
-static char *decodeString(char *orig, int flag_plus_to_space)
-{
-  /* note that decoded string is always shorter than original */
-  char *string = orig;
-  char *ptr = string;
-
-  while (*ptr)
-  {
-    if (*ptr == '+' && flag_plus_to_space)    { *string++ = ' '; ptr++; }
-    else if (*ptr != '%') *string++ = *ptr++;
-    else  {
-      unsigned int value1, value2;
-
-      ptr++;
-      if(sscanf(ptr, "%1X", &value1) != 1 ||
-                sscanf(ptr+1, "%1X", &value2) != 1) {
-    if(!flag_plus_to_space)
-        return NULL;
-    *string++ = '%';
-      } else {
-    value1 = value1 * 16 + value2;
-    if(value1 == '/' || value1 == 0)
-        return orig+1;
-    *string++ = value1;
-    ptr += 2;
-      }
-    }
-  }
-  *string = '\0';
-  return orig;
-}
-
-
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-/****************************************************************************
- *
- > $Function: addEnv()
- *
- * $Description: Add an environment variable setting to the global list.
- *    A NAME=VALUE string is allocated, filled, and added to the list of
- *    environment settings passed to the cgi execution script.
- *
- * $Parameters:
- *  (char *) name_before_underline - The first part environment variable name.
- *  (char *) name_after_underline  - The second part environment variable name.
- *  (char *) value  . . The value to which the env variable is set.
- *
- * $Return: (void)
- *
- * $Errors: Silently returns if the env runs out of space to hold the new item
- *
- ****************************************************************************/
-static void addEnv(const char *name_before_underline,
-            const char *name_after_underline, const char *value)
-{
-  char *s = NULL;
-  const char *underline;
-
-  if (!value)
-    value = "";
-  underline = *name_after_underline ? "_" : "";
-  asprintf(&s, "%s%s%s=%s", name_before_underline, underline,
-                    name_after_underline, value);
-  if(s) {
-    putenv(s);
-  }
-}
-
-#if defined(CONFIG_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV) || defined(CONFIG_FEATURE_HTTPD_WITHOUT_INETD)
-/* set environs SERVER_PORT and REMOTE_PORT */
-static void addEnvPort(const char *port_name)
-{
-      char buf[16];
-
-      sprintf(buf, "%u", config->port);
-      addEnv(port_name, "PORT", buf);
-}
-#endif
-#endif          /* CONFIG_FEATURE_HTTPD_CGI */
-
-
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-/****************************************************************************
- *
- > $Function: decodeBase64()
- *
- > $Description: Decode a base 64 data stream as per rfc1521.
- *    Note that the rfc states that none base64 chars are to be ignored.
- *    Since the decode always results in a shorter size than the input, it is
- *    OK to pass the input arg as an output arg.
- *
- * $Parameter:
- *      (char *) Data . . . . A pointer to a base64 encoded string.
- *                            Where to place the decoded data.
- *
- * $Return: void
- *
- * $Errors: None
- *
- ****************************************************************************/
-static void decodeBase64(char *Data)
-{
-
-  const unsigned char *in = (const unsigned char *)Data;
-  // The decoded size will be at most 3/4 the size of the encoded
-  unsigned long ch = 0;
-  int i = 0;
-
-  while (*in) {
-    int t = *in++;
-
-    if(t >= '0' && t <= '9')
-    t = t - '0' + 52;
-    else if(t >= 'A' && t <= 'Z')
-    t = t - 'A';
-    else if(t >= 'a' && t <= 'z')
-    t = t - 'a' + 26;
-    else if(t == '+')
-    t = 62;
-    else if(t == '/')
-    t = 63;
-    else if(t == '=')
-    t = 0;
-    else
-    continue;
-
-    ch = (ch << 6) | t;
-    i++;
-    if (i == 4) {
-    *Data++ = (char) (ch >> 16);
-    *Data++ = (char) (ch >> 8);
-    *Data++ = (char) ch;
-    i = 0;
-    }
-  }
-  *Data = 0;
-}
-#endif
-
-
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-/****************************************************************************
- *
- > $Function: openServer()
- *
- * $Description: create a listen server socket on the designated port.
- *
- * $Return: (int)  . . . A connection socket. -1 for errors.
- *
- * $Errors: None
- *
- ****************************************************************************/
-static int openServer(void)
-{
-  struct sockaddr_in lsocket;
-  int fd;
-  int on = 1;
-
-  /* create the socket right now */
-  /* inet_addr() returns a value that is already in network order */
-  memset(&lsocket, 0, sizeof(lsocket));
-  lsocket.sin_family = AF_INET;
-  lsocket.sin_addr.s_addr = INADDR_ANY;
-  lsocket.sin_port = htons(config->port);
-  fd = bb_xsocket(AF_INET, SOCK_STREAM, 0);
-  /* tell the OS it's OK to reuse a previous address even though */
-  /* it may still be in a close down state.  Allows bind to succeed. */
-#ifdef SO_REUSEPORT
-  setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (void *)&on, sizeof(on)) ;
-#else
-  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on)) ;
-#endif
-  bb_xbind(fd, (struct sockaddr *)&lsocket, sizeof(lsocket));
-  listen(fd, 9); /* bb_xlisten? */
-  signal(SIGCHLD, SIG_IGN);   /* prevent zombie (defunct) processes */
-  return fd;
-}
-#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
-
-/****************************************************************************
- *
- > $Function: sendHeaders()
- *
- * $Description: Create and send HTTP response headers.
- *   The arguments are combined and sent as one write operation.  Note that
- *   IE will puke big-time if the headers are not sent in one packet and the
- *   second packet is delayed for any reason.
- *
- * $Parameter:
- *      (HttpResponseNum) responseNum . . . The result code to send.
- *
- * $Return: (int)  . . . . writing errors
- *
- ****************************************************************************/
-static int sendHeaders(HttpResponseNum responseNum)
-{
-  char *buf = config->buf;
-  const char *responseString = "";
-  const char *infoString = 0;
-  const char *mime_type;
-  unsigned int i;
-  time_t timer = time(0);
-  char timeStr[80];
-  int len;
-
-  for (i = 0;
-    i < (sizeof(httpResponseNames)/sizeof(httpResponseNames[0])); i++) {
-        if (httpResponseNames[i].type == responseNum) {
-            responseString = httpResponseNames[i].name;
-            infoString = httpResponseNames[i].info;
-            break;
-        }
-  }
-  /* error message is HTML */
-  mime_type = responseNum == HTTP_OK ?
-        config->httpd_found.found_mime_type : "text/html";
-
-  /* emit the current date */
-  strftime(timeStr, sizeof(timeStr), RFC1123FMT, gmtime(&timer));
-  len = sprintf(buf,
-    "HTTP/1.0 %d %s\r\nContent-type: %s\r\n"
-    "Date: %s\r\nConnection: close\r\n",
-      responseNum, responseString, mime_type, timeStr);
-
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-  if (responseNum == HTTP_UNAUTHORIZED) {
-    len += sprintf(buf+len, "WWW-Authenticate: Basic realm=\"%s\"\r\n",
-                                config->realm);
-  }
-#endif
-  if(responseNum == HTTP_MOVED_TEMPORARILY) {
-    len += sprintf(buf+len, "Location: %s/%s%s\r\n",
-        config->httpd_found.found_moved_temporarily,
-        (config->query ? "?" : ""),
-        (config->query ? config->query : ""));
-  }
-
-  if (config->ContentLength != -1) {    /* file */
-    strftime(timeStr, sizeof(timeStr), RFC1123FMT, gmtime(&config->last_mod));
-    len += sprintf(buf+len, "Last-Modified: %s\r\n%s " cont_l_fmt "\r\n",
-                  timeStr, Content_length, cont_l_type config->ContentLength);
-  }
-  strcat(buf, "\r\n");
-  len += 2;
-  if (infoString) {
-    len += sprintf(buf+len,
-        "<HEAD><TITLE>%d %s</TITLE></HEAD>\n"
-        "<BODY><H1>%d %s</H1>\n%s\n</BODY>\n",
-        responseNum, responseString,
-        responseNum, responseString, infoString);
-  }
-#if DEBUG
-  fprintf(stderr, "Headers: '%s'", buf);
-#endif
-  return bb_full_write(a_c_w, buf, len);
-}
-
-/****************************************************************************
- *
- > $Function: getLine()
- *
- * $Description: Read from the socket until an end of line char found.
- *
- *   Characters are read one at a time until an eol sequence is found.
- *
- * $Return: (int) . . . . number of characters read.  -1 if error.
- *
- ****************************************************************************/
-static int getLine(void)
-{
-  int  count = 0;
-  char *buf = config->buf;
-
-  while (read(a_c_r, buf + count, 1) == 1) {
-    if (buf[count] == '\r') continue;
-    if (buf[count] == '\n') {
-      buf[count] = 0;
-      return count;
-    }
-    if(count < (MAX_MEMORY_BUFF-1))      /* check owerflow */
-    count++;
-  }
-  if (count) return count;
-  else return -1;
-}
-
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-/****************************************************************************
- *
- > $Function: sendCgi()
- *
- * $Description: Execute a CGI script and send it's stdout back
- *
- *   Environment variables are set up and the script is invoked with pipes
- *   for stdin/stdout.  If a post is being done the script is fed the POST
- *   data in addition to setting the QUERY_STRING variable (for GETs or POSTs).
- *
- * $Parameters:
- *      (const char *) url . . . . . . The requested URL (with leading /).
- *      (int bodyLen)  . . . . . . . . Length of the post body.
- *      (const char *cookie) . . . . . For set HTTP_COOKIE.
- *      (const char *content_type) . . For set CONTENT_TYPE.
-
- *
- * $Return: (char *)  . . . . A pointer to the decoded string (same as input).
- *
- * $Errors: None
- *
- ****************************************************************************/
-static int sendCgi(const char *url,
-           const char *request, int bodyLen, const char *cookie,
-           const char *content_type)
-{
-  int fromCgi[2];  /* pipe for reading data from CGI */
-  int toCgi[2];    /* pipe for sending data to CGI */
-
-  static char * argp[] = { 0, 0 };
-  int pid = 0;
-  int inFd;
-  int outFd;
-  int firstLine = 1;
-
-  do {
-    if (pipe(fromCgi) != 0) {
-      break;
-    }
-    if (pipe(toCgi) != 0) {
-      break;
-    }
-
-    pid = fork();
-    if (pid < 0) {
-    pid = 0;
-    break;
-    }
-
-    if (!pid) {
-      /* child process */
-      char *script;
-      char *purl = strdup( url );
-      char realpath_buff[MAXPATHLEN];
-
-      if(purl == NULL)
-    _exit(242);
-
-      inFd  = toCgi[0];
-      outFd = fromCgi[1];
-
-      dup2(inFd, 0);  // replace stdin with the pipe
-      dup2(outFd, 1);  // replace stdout with the pipe
-      if(!DEBUG)
-    dup2(outFd, 2);  // replace stderr with the pipe
-
-      close(toCgi[0]);
-      close(toCgi[1]);
-      close(fromCgi[0]);
-      close(fromCgi[1]);
-
-      /*
-       * Find PATH_INFO.
-       */
-      script = purl;
-      while((script = strchr( script + 1, '/' )) != NULL) {
-    /* have script.cgi/PATH_INFO or dirs/script.cgi[/PATH_INFO] */
-    struct stat sb;
-
-    *script = '\0';
-    if(is_directory(purl + 1, 1, &sb) == 0) {
-        /* not directory, found script.cgi/PATH_INFO */
-        *script = '/';
-        break;
-    }
-    *script = '/';          /* is directory, find next '/' */
-      }
-      addEnv("PATH", "INFO", script);   /* set /PATH_INFO or NULL */
-      addEnv("PATH",           "",         getenv("PATH"));
-      addEnv("REQUEST",        "METHOD",   request);
-      if(config->query) {
-    char *uri = alloca(strlen(purl) + 2 + strlen(config->query));
-    if(uri)
-        sprintf(uri, "%s?%s", purl, config->query);
-    addEnv("REQUEST",        "URI",   uri);
-      } else {
-    addEnv("REQUEST",        "URI",   purl);
-      }
-      if(script != NULL)
-    *script = '\0';         /* reduce /PATH_INFO */
-       /* SCRIPT_FILENAME required by PHP in CGI mode */
-       if(realpath(purl + 1, realpath_buff))
-     addEnv("SCRIPT", "FILENAME", realpath_buff);
-       else
-     *realpath_buff = 0;
-      /* set SCRIPT_NAME as full path: /cgi-bin/dirs/script.cgi */
-      addEnv("SCRIPT_NAME",    "",         purl);
-      addEnv("QUERY_STRING",   "",         config->query);
-      addEnv("SERVER",         "SOFTWARE", httpdVersion);
-      addEnv("SERVER",         "PROTOCOL", "HTTP/1.0");
-      addEnv("GATEWAY_INTERFACE", "",      "CGI/1.1");
-      addEnv("REMOTE",         "ADDR",     config->rmt_ip_str);
-#ifdef CONFIG_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
-      addEnvPort("REMOTE");
-#endif
-      if(bodyLen) {
-    char sbl[32];
-
-    sprintf(sbl, "%d", bodyLen);
-    addEnv("CONTENT", "LENGTH", sbl);
-      }
-      if(cookie)
-    addEnv("HTTP", "COOKIE", cookie);
-      if(content_type)
-    addEnv("CONTENT", "TYPE", content_type);
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-      if(config->remoteuser) {
-    addEnv("REMOTE", "USER", config->remoteuser);
-    addEnv("AUTH_TYPE", "", "Basic");
-      }
-#endif
-      if(config->referer)
-    addEnv("HTTP", "REFERER", config->referer);
-
-    /* set execve argp[0] without path */
-      argp[0] = strrchr( purl, '/' ) + 1;
-    /* but script argp[0] must have absolute path and chdiring to this */
-      if(*realpath_buff) {
-        script = strrchr(realpath_buff, '/');
-        if(script) {
-        *script = '\0';
-        if(chdir(realpath_buff) == 0) {
-          // now run the program.  If it fails,
-          // use _exit() so no destructors
-          // get called and make a mess.
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
-          char *interpr = NULL;
-          char *suffix = strrchr(purl, '.');
-
-          if(suffix) {
-            Htaccess * cur;
-            for (cur = config->script_i; cur; cur = cur->next)
-                if(strcmp(cur->before_colon + 1, suffix) == 0) {
-                    interpr = cur->after_colon;
+            }
+
+            /* then error page; find matching status */
+            for (i = 0; i < ARRAY_SIZE(http_response_type); i++) {
+                if (http_response_type[i] == status) {
+                    http_error_page[i] = concat_path_file((*c == '/') ? NULL : home_httpd, c);
                     break;
                 }
-          }
-#endif
-          *script = '/';
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
-          if (interpr)
-            execv(interpr, argp);
-          else
-#endif
-            execv(realpath_buff, argp);
-        }
-        }
-      }
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-      config->accepted_socket = 1;      /* send to stdout */
-#endif
-      sendHeaders(HTTP_NOT_FOUND);
-      _exit(242);
-    } /* end child */
-
-  } while (0);
-
-  if (pid) {
-    /* parent process */
-    int status;
-    size_t post_readed_size = 0, post_readed_idx = 0;
-
-    inFd  = fromCgi[0];
-    outFd = toCgi[1];
-    close(fromCgi[1]);
-    close(toCgi[0]);
-    signal(SIGPIPE, SIG_IGN);
-
-    while (1) {
-      fd_set readSet;
-      fd_set writeSet;
-      char wbuf[128];
-      int nfound;
-      int count;
-
-      FD_ZERO(&readSet);
-      FD_ZERO(&writeSet);
-      FD_SET(inFd, &readSet);
-      if(bodyLen > 0 || post_readed_size > 0) {
-    FD_SET(outFd, &writeSet);
-    nfound = outFd > inFd ? outFd : inFd;
-    if(post_readed_size == 0) {
-        FD_SET(a_c_r, &readSet);
-        if(nfound < a_c_r)
-            nfound = a_c_r;
-    }
-      /* Now wait on the set of sockets! */
-    nfound = select(nfound + 1, &readSet, &writeSet, 0, NULL);
-      } else {
-    if(!bodyLen) {
-        close(outFd);
-        bodyLen = -1;
-    }
-    nfound = select(inFd + 1, &readSet, 0, 0, NULL);
-      }
-
-      if (nfound <= 0) {
-    if (waitpid(pid, &status, WNOHANG) > 0) {
-      close(inFd);
+            }
+            continue;
+        }
+#endif
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+        if (*p0 == '/') {
+            /* make full path from httpd root / current_path / config_line_path */
+            cf = (flag == SUBDIR_PARSE ? path : "");
+            p0 = xmalloc(strlen(cf) + (c - buf) + 2 + strlen(c));
+            c[-1] = '\0';
+            sprintf(p0, "/%s%s", cf, buf);
+
+            /* another call bb_simplify_path */
+            cf = p = p0;
+
+            do {
+                if (*p == '/') {
+                    if (*cf == '/') {    /* skip duplicate (or initial) slash */
+                        continue;
+                    } else if (*cf == '.') {
+                        if (cf[1] == '/' || cf[1] == '\0') { /* remove extra '.' */
+                            continue;
+                        } else if ((cf[1] == '.') && (cf[2] == '/' || cf[2] == '\0')) {
+                            ++cf;
+                            if (p > p0) {
+                                while (*--p != '/') /* omit previous dir */;
+                            }
+                            continue;
+                        }
+                    }
+                }
+                *++p = *cf;
+            } while (*++cf);
+
+            if ((p == p0) || (*p != '/')) {      /* not a trailing slash */
+                ++p;                             /* so keep last character */
+            }
+            *p = '\0';
+            sprintf(p0 + strlen(p0), ":%s", c);
+        }
+#endif
+
+#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));
+        if (cur) {
+            cf = strcpy(cur->before_colon, p0);
+            c = strchr(cf, ':');
+            *c++ = 0;
+            cur->after_colon = c;
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+            if (*cf == '.') {
+                /* config .mime line move top for overwrite previous */
+                cur->next = mime_a;
+                mime_a = cur;
+                continue;
+            }
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+            if (*cf == '*' && cf[1] == '.') {
+                /* config script interpreter line move top for overwrite previous */
+                cur->next = script_i;
+                script_i = cur;
+                continue;
+            }
+#endif
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+            free(p0);
+            if (prev == NULL) {
+                /* first line */
+                g_auth = prev = cur;
+            } else {
+                /* sort path, if current lenght eq or bigger then move up */
+                Htaccess *prev_hti = g_auth;
+                size_t l = strlen(cf);
+                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;
+                        }
+                        break;
+                    }
+                    if (prev_hti != hti)
+                        prev_hti = prev_hti->next;
+                }
+                if (!hti) {       /* not inserted, add to bottom */
+                    prev->next = cur;
+                    prev = cur;
+                }
+            }
+#endif
+        }
+#endif
+     }
+     fclose(f);
+}
+
+#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
+/*
+ * Given a string, html-encode special characters.
+ * This is used for the -e command line option to provide an easy way
+ * for scripts to encode result data without confusing browsers.  The
+ * returned string pointer is memory allocated by malloc().
+ *
+ * Returns a pointer to the encoded string (malloced).
+ */
+static char *encodeString(const char *string)
+{
+    /* take the simple route and encode everything */
+    /* could possibly scan once to get length.     */
+    int len = strlen(string);
+    char *out = xmalloc(len * 6 + 1);
+    char *p = out;
+    char ch;
+
+    while ((ch = *string++)) {
+        /* very simple check for what to encode */
+        if (isalnum(ch))
+            *p++ = ch;
+        else
+            p += sprintf(p, "&#%d;", (unsigned char) 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 strdup() 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;
+}
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+/*
+ * Decode a base64 data stream as per rfc1521.
+ * Note that the rfc states that non base64 chars are to be ignored.
+ * Since the decode always results in a shorter size than the input,
+ * it is OK to pass the input arg as an output arg.
+ * Parameter: a pointer to a base64 encoded string.
+ * Decoded data is stored in-place.
+ */
+static void decodeBase64(char *Data)
+{
+    const unsigned char *in = (const unsigned char *)Data;
+    /* The decoded size will be at most 3/4 the size of the encoded */
+    unsigned ch = 0;
+    int i = 0;
+
+    while (*in) {
+        int t = *in++;
+
+        if (t >= '0' && t <= '9')
+            t = t - '0' + 52;
+        else if (t >= 'A' && t <= 'Z')
+            t = t - 'A';
+        else if (t >= 'a' && t <= 'z')
+            t = t - 'a' + 26;
+        else if (t == '+')
+            t = 62;
+        else if (t == '/')
+            t = 63;
+        else if (t == '=')
+            t = 0;
+        else
+            continue;
+
+        ch = (ch << 6) | t;
+        i++;
+        if (i == 4) {
+            *Data++ = (char) (ch >> 16);
+            *Data++ = (char) (ch >> 8);
+            *Data++ = (char) ch;
+            i = 0;
+        }
+    }
+    *Data = '\0';
+}
+#endif
+
+/*
+ * Create a listen server socket on the designated port.
+ */
+static int openServer(void)
+{
+    int n = bb_strtou(bind_addr_or_port, NULL, 10);
+    if (!errno && n && n <= 0xffff)
+        n = create_and_bind_stream_or_die(NULL, n);
+    else
+        n = create_and_bind_stream_or_die(bind_addr_or_port, 80);
+    xlisten(n, 9);
+    return n;
+}
+
+/*
+ * Log the connection closure and exit.
+ */
+static void log_and_exit(void) ATTRIBUTE_NORETURN;
+static void log_and_exit(void)
+{
+    /* Paranoia. IE said to be buggy. It may send some extra data
+     * or be confused by us just exiting without SHUT_WR. Oh well. */
+    shutdown(1, SHUT_WR);
+    ndelay_on(0);
+    while (read(0, iobuf, IOBUF_SIZE) > 0)
+        continue;
+
+    if (verbose > 2)
+        bb_error_msg("closed");
+    _exit(xfunc_error_retval);
+}
+
+/*
+ * Create and send HTTP response headers.
+ * The arguments are combined and sent as one write operation.  Note that
+ * IE will puke big-time if the headers are not sent in one packet and the
+ * second packet is delayed for any reason.
+ * responseNum - the result code to send.
+ */
+static void send_headers(int responseNum)
+{
+    static const char RFC1123FMT[] ALIGN1 = "%a, %d %b %Y %H:%M:%S GMT";
+
+    const char *responseString = "";
+    const char *infoString = NULL;
+    const char *mime_type;
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+    const char *error_page = 0;
+#endif
+    unsigned i;
+    time_t timer = time(0);
+    char tmp_str[80];
+    int len;
+
+    for (i = 0; i < ARRAY_SIZE(http_response_type); i++) {
+        if (http_response_type[i] == responseNum) {
+            responseString = http_response[i].name;
+            infoString = http_response[i].info;
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+            error_page = http_error_page[i];
+#endif
+            break;
+        }
+    }
+    /* error message is HTML */
+    mime_type = responseNum == HTTP_OK ?
+                found_mime_type : "text/html";
+
+    if (verbose)
+        bb_error_msg("response:%u", responseNum);
+
+    /* emit the current date */
+    strftime(tmp_str, sizeof(tmp_str), RFC1123FMT, gmtime(&timer));
+    len = sprintf(iobuf,
+            "HTTP/1.0 %d %s\r\nContent-type: %s\r\n"
+            "Date: %s\r\nConnection: close\r\n",
+            responseNum, responseString, mime_type, tmp_str);
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    if (responseNum == HTTP_UNAUTHORIZED) {
+        len += sprintf(iobuf + len,
+                "WWW-Authenticate: Basic realm=\"%s\"\r\n",
+                g_realm);
+    }
+#endif
+    if (responseNum == HTTP_MOVED_TEMPORARILY) {
+        len += sprintf(iobuf + len, "Location: %s/%s%s\r\n",
+                found_moved_temporarily,
+                (g_query ? "?" : ""),
+                (g_query ? g_query : ""));
+    }
+
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+    if (error_page && !access(error_page, R_OK)) {
+        strcat(iobuf, "\r\n");
+        len += 2;
+
+        if (DEBUG)
+            fprintf(stderr, "headers: '%s'\n", iobuf);
+        full_write(1, iobuf, len);
+        if (DEBUG)
+            fprintf(stderr, "writing error page: '%s'\n", error_page);
+        return send_file_and_exit(error_page, FALSE);
+    }
+#endif
+
+    if (ContentLength != -1) {    /* file */
+        strftime(tmp_str, sizeof(tmp_str), RFC1123FMT, gmtime(&last_mod));
+        len += sprintf(iobuf + len, "Last-Modified: %s\r\n%s %"OFF_FMT"d\r\n",
+            tmp_str, "Content-length:", ContentLength);
+    }
+    iobuf[len++] = '\r';
+    iobuf[len++] = '\n';
+    if (infoString) {
+        len += sprintf(iobuf + len,
+                "<HTML><HEAD><TITLE>%d %s</TITLE></HEAD>\n"
+                "<BODY><H1>%d %s</H1>\n%s\n</BODY></HTML>\n",
+                responseNum, responseString,
+                responseNum, responseString, infoString);
+    }
+    if (DEBUG)
+        fprintf(stderr, "headers: '%s'\n", iobuf);
+    if (full_write(1, iobuf, len) != len) {
+        if (verbose > 1)
+            bb_perror_msg("error");
+        log_and_exit();
+    }
+}
+
+static void send_headers_and_exit(int responseNum) ATTRIBUTE_NORETURN;
+static void send_headers_and_exit(int responseNum)
+{
+    send_headers(responseNum);
+    log_and_exit();
+}
+
+/*
+ * Read from the socket until '\n' or EOF. '\r' chars are removed.
+ * '\n' is replaced with NUL.
+ * Return number of characters read or 0 if nothing is read
+ * ('\r' and '\n' are not counted).
+ * Data is returned in iobuf.
+ */
+static int get_line(void)
+{
+    int count = 0;
+    char c;
+
+    while (1) {
+        if (hdr_cnt <= 0) {
+            hdr_cnt = safe_read(0, hdr_buf, sizeof(hdr_buf));
+            if (hdr_cnt <= 0)
+                break;
+            hdr_ptr = hdr_buf;
+        }
+        iobuf[count] = c = *hdr_ptr++;
+        hdr_cnt--;
+
+        if (c == '\r')
+            continue;
+        if (c == '\n') {
+            iobuf[count] = '\0';
+            return count;
+        }
+        if (count < (IOBUF_SIZE - 1))      /* check overflow */
+            count++;
+    }
+    return count;
+}
+
+#if ENABLE_FEATURE_HTTPD_CGI
+static void setenv1(const char *name, const char *value)
+{
+    setenv(name, value ? value : "", 1);
+}
+
+/*
+ * Spawn CGI script, forward CGI's stdin/out <=> network
+ *
+ * Environment variables are set up and the script is invoked with pipes
+ * for stdin/stdout.  If a post is being done the script is fed the POST
+ * data in addition to setting the QUERY_STRING variable (for GETs or POSTs).
+ *
+ * Parameters:
+ * const char *url              The requested URL (with leading /).
+ * int bodyLen                  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 *request,
+        int bodyLen,
+        const char *cookie,
+        const char *content_type) ATTRIBUTE_NORETURN;
+static void send_cgi_and_exit(
+        const char *url,
+        const char *request,
+        int bodyLen,
+        const char *cookie,
+        const char *content_type)
+{
+    struct { int rd; int wr; } fromCgi;  /* CGI -> httpd pipe */
+    struct { int rd; int wr; } toCgi;    /* httpd -> CGI pipe */
+    char *fullpath;
+    char *script;
+    char *purl;
+    int buf_count;
+    int status;
+    int pid = 0;
+
+    /*
+     * We are mucking with environment _first_ and then vfork/exec,
+     * this allows us to use vfork safely. Parent don't care about
+     * these environment changes anyway.
+     */
+
+    /*
+     * Find PATH_INFO.
+     */
+    purl = xstrdup(url);
+    script = purl;
+    while ((script = strchr(script + 1, '/')) != NULL) {
+        /* have script.cgi/PATH_INFO or dirs/script.cgi[/PATH_INFO] */
+        struct stat sb;
+
+        *script = '\0';
+        if (!is_directory(purl + 1, 1, &sb)) {
+            /* not directory, found script.cgi/PATH_INFO */
+            *script = '/';
+            break;
+        }
+        *script = '/';          /* is directory, find next '/' */
+    }
+    setenv1("PATH_INFO", script);   /* set /PATH_INFO or "" */
+    setenv1("REQUEST_METHOD", request);
+    if (g_query) {
+        putenv(xasprintf("%s=%s?%s", "REQUEST_URI", purl, g_query));
+    } else {
+        setenv1("REQUEST_URI", purl);
+    }
+    if (script != NULL)
+        *script = '\0';         /* cut off /PATH_INFO */
+
+    /* SCRIPT_FILENAME required by PHP in CGI mode */
+    fullpath = concat_path_file(home_httpd, purl);
+    setenv1("SCRIPT_FILENAME", fullpath);
+    /* set SCRIPT_NAME as full path: /cgi-bin/dirs/script.cgi */
+    setenv1("SCRIPT_NAME", purl);
+    /* http://hoohoo.ncsa.uiuc.edu/cgi/env.html:
+     * QUERY_STRING: The information which follows the ? in the URL
+     * which referenced this script. This is the query information.
+     * It should not be decoded in any fashion. This variable
+     * should always be set when there is query information,
+     * regardless of command line decoding. */
+    /* (Older versions of bbox seem to do some decoding) */
+    setenv1("QUERY_STRING", g_query);
+    putenv((char*)"SERVER_SOFTWARE=busybox httpd/"BB_VER);
+    putenv((char*)"SERVER_PROTOCOL=HTTP/1.0");
+    putenv((char*)"GATEWAY_INTERFACE=CGI/1.1");
+    /* Having _separate_ variables for IP and port defeats
+     * the purpose of having socket abstraction. Which "port"
+     * are you using on Unix domain socket?
+     * IOW - REMOTE_PEER="1.2.3.4:56" makes much more sense.
+     * Oh well... */
+    {
+        char *p = rmt_ip_str ? rmt_ip_str : (char*)"";
+        char *cp = strrchr(p, ':');
+        if (ENABLE_FEATURE_IPV6 && cp && strchr(cp, ']'))
+            cp = NULL;
+        if (cp) *cp = '\0'; /* delete :PORT */
+        setenv1("REMOTE_ADDR", p);
+        if (cp) {
+            *cp = ':';
+#if ENABLE_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
+            setenv1("REMOTE_PORT", cp + 1);
+#endif
+        }
+    }
+    setenv1("HTTP_USER_AGENT", user_agent);
+    if (bodyLen)
+        putenv(xasprintf("CONTENT_LENGTH=%d", bodyLen));
+    if (cookie)
+        setenv1("HTTP_COOKIE", cookie);
+    if (content_type)
+        setenv1("CONTENT_TYPE", content_type);
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    if (remoteuser) {
+        setenv1("REMOTE_USER", remoteuser);
+        putenv((char*)"AUTH_TYPE=Basic");
+    }
+#endif
+    if (referer)
+        setenv1("HTTP_REFERER", referer);
+
+    xpipe(&fromCgi.rd);
+    xpipe(&toCgi.rd);
+
+    pid = vfork();
+    if (pid < 0) {
+        /* TODO: log perror? */
+        log_and_exit();
+    }
+
+    if (!pid) {
+        /* Child process */
+        xfunc_error_retval = 242;
+
+        xmove_fd(toCgi.rd, 0);  /* replace stdin with the pipe */
+        xmove_fd(fromCgi.wr, 1);  /* replace stdout with the pipe */
+        close(fromCgi.rd);
+        close(toCgi.wr);
+        /* User seeing stderr output can be a security problem.
+         * If CGI really wants that, it can always do dup itself. */
+        /* dup2(1, 2); */
+
+        /* script must have absolute path */
+        script = strrchr(fullpath, '/');
+        if (!script)
+            goto error_execing_cgi;
+        *script = '\0';
+        /* chdiring to script's dir */
+        if (chdir(fullpath) == 0) {
+            char *argv[2];
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+            char *interpr = NULL;
+            char *suffix = strrchr(purl, '.');
+
+            if (suffix) {
+                Htaccess *cur;
+                for (cur = script_i; cur; cur = cur->next) {
+                    if (strcmp(cur->before_colon + 1, suffix) == 0) {
+                        interpr = cur->after_colon;
+                        break;
+                    }
+                }
+            }
+#endif
+            *script = '/';
+            /* set argv[0] to name without path */
+            argv[0] = (char*)bb_basename(purl);
+            argv[1] = NULL;
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+            if (interpr)
+                execv(interpr, argv);
+            else
+#endif
+                execv(fullpath, argv);
+        }
+ error_execing_cgi:
+        /* send to stdout
+         * (we are CGI here, our stdout is pumped to the net) */
+        send_headers_and_exit(HTTP_NOT_FOUND);
+    } /* end child */
+
+    /* Parent process */
+
+    /* First, restore variables possibly changed by child */
+    xfunc_error_retval = 0;
+
+    /* Prepare for pumping data.
+     * iobuf is used for CGI -> network data,
+     * hdr_buf is for network -> CGI data (POSTDATA) */
+    buf_count = 0;
+    close(fromCgi.wr);
+    close(toCgi.rd);
+
+    /* If CGI dies, we still want to correctly finish reading its output
+     * and send it to the peer. So please no SIGPIPEs! */
+    signal(SIGPIPE, SIG_IGN);
+
+    /* This loop still looks messy. What is an exit criteria?
+     * "CGI's output closed"? Or "CGI has exited"?
+     * What to do if CGI has closed both input and output, but
+     * didn't exit? etc... */
+
+    /* NB: breaking out of this loop jumps to log_and_exit() */
+    while (1) {
+        fd_set readSet;
+        fd_set writeSet;
+        int nfound;
+        int count;
+
+        FD_ZERO(&readSet);
+        FD_ZERO(&writeSet);
+        FD_SET(fromCgi.rd, &readSet);
+        if (bodyLen > 0 || hdr_cnt > 0) {
+            FD_SET(toCgi.wr, &writeSet);
+            nfound = toCgi.wr > fromCgi.rd ? toCgi.wr : fromCgi.rd;
+            if (hdr_cnt <= 0)
+                FD_SET(0, &readSet);
+            /* Now wait on the set of sockets! */
+            nfound = select(nfound + 1, &readSet, &writeSet, NULL, NULL);
+        } else {
+            if (!bodyLen) {
+                close(toCgi.wr); /* no more POST data to CGI */
+                bodyLen = -1;
+            }
+            nfound = select(fromCgi.rd + 1, &readSet, NULL, NULL, NULL);
+        }
+
+        if (nfound <= 0) {
+            if (waitpid(pid, &status, WNOHANG) <= 0) {
+                /* Weird. CGI didn't exit and no fd's
+                 * are ready, yet select returned?! */
+                continue;
+            }
+            close(fromCgi.rd);
+            if (DEBUG && WIFEXITED(status))
+                bb_error_msg("CGI exited, status=%d", WEXITSTATUS(status));
+            if (DEBUG && WIFSIGNALED(status))
+                bb_error_msg("CGI killed, signal=%d", WTERMSIG(status));
+            break;
+        }
+
+        if (hdr_cnt > 0 && FD_ISSET(toCgi.wr, &writeSet)) {
+            /* Have data from peer and can write to CGI */
+            count = safe_write(toCgi.wr, hdr_ptr, hdr_cnt);
+            /* Doesn't happen, we dont use nonblocking IO here
+             *if (count < 0 && errno == EAGAIN) {
+             *  ...
+             *} else */
+            if (count > 0) {
+                hdr_ptr += count;
+                hdr_cnt -= count;
+            } else {
+                hdr_cnt = bodyLen = 0; /* EOF/broken pipe to CGI */
+            }
+        } else if (bodyLen > 0 && hdr_cnt == 0
+         && FD_ISSET(0, &readSet)
+        ) {
+            /* We expect data, prev data portion is eaten by CGI
+             * and there *is* data to read from the peer
+             * (POSTDATA?) */
+            count = bodyLen > (int)sizeof(hdr_buf) ? (int)sizeof(hdr_buf) : bodyLen;
+            count = safe_read(0, hdr_buf, count);
+            if (count > 0) {
+                hdr_cnt = count;
+                hdr_ptr = hdr_buf;
+                bodyLen -= count;
+            } else {
+                bodyLen = 0; /* closed */
+            }
+        }
+
+#define PIPESIZE PIPE_BUF
+#if PIPESIZE >= IOBUF_SIZE
+# error "PIPESIZE >= IOBUF_SIZE"
+#endif
+        if (FD_ISSET(fromCgi.rd, &readSet)) {
+            /* There is something to read from CGI */
+            char *rbuf = iobuf;
+
+            /* Are we still buffering CGI output? */
+            if (buf_count >= 0) {
+                /* HTTP_200[] has single "\r\n" at the end.
+                 * According to http://hoohoo.ncsa.uiuc.edu/cgi/out.html,
+                 * CGI scripts MUST send their own header terminated by
+                 * empty line, then data. That's why we have only one
+                 * <cr><lf> pair here. We will output "200 OK" line
+                 * if needed, but CGI still has to provide blank line
+                 * between header and body */
+
+                /* Must use safe_read, not full_read, because
+                 * CGI may output a few first bytes and then wait
+                 * for POSTDATA without closing stdout.
+                 * With full_read we may wait here forever. */
+                count = safe_read(fromCgi.rd, rbuf + buf_count, PIPESIZE - 8);
+                if (count <= 0) {
+                    /* eof (or error) and there was no "HTTP",
+                     * so write it, then write received data */
+                    if (buf_count) {
+                        full_write(1, HTTP_200, sizeof(HTTP_200)-1);
+                        full_write(1, rbuf, buf_count);
+                    }
+                    break; /* CGI stdout is closed, exiting */
+                }
+                buf_count += count;
+                count = 0;
+                /* "Status" header format is: "Status: 302 Redirected\r\n" */
+                if (buf_count >= 8 && memcmp(rbuf, "Status: ", 8) == 0) {
+                    /* send "HTTP/1.0 " */
+                    if (full_write(1, HTTP_200, 9) != 9)
+                        break;
+                    rbuf += 8; /* skip "Status: " */
+                    count = buf_count - 8;
+                    buf_count = -1; /* buffering off */
+                } else if (buf_count >= 4) {
+                    /* Did CGI add "HTTP"? */
+                    if (memcmp(rbuf, HTTP_200, 4) != 0) {
+                        /* there is no "HTTP", do it ourself */
+                        if (full_write(1, HTTP_200, sizeof(HTTP_200)-1) != sizeof(HTTP_200)-1)
+                            break;
+                    }
+                    /* Commented out:
+                    if (!strstr(rbuf, "ontent-")) {
+                        full_write(s, "Content-type: text/plain\r\n\r\n", 28);
+                    }
+                     * Counter-example of valid CGI without Content-type:
+                     * echo -en "HTTP/1.0 302 Found\r\n"
+                     * echo -en "Location: http://www.busybox.net\r\n"
+                     * echo -en "\r\n"
+                     */
+                    count = buf_count;
+                    buf_count = -1; /* buffering off */
+                }
+            } else {
+                count = safe_read(fromCgi.rd, rbuf, PIPESIZE);
+                if (count <= 0)
+                    break;  /* eof (or error) */
+            }
+            if (full_write(1, rbuf, count) != count)
+                break;
+            if (DEBUG)
+                fprintf(stderr, "cgi read %d bytes: '%.*s'\n", count, count, rbuf);
+        } /* if (FD_ISSET(fromCgi.rd)) */
+    } /* while (1) */
+    log_and_exit();
+}
+#endif          /* FEATURE_HTTPD_CGI */
+
+/*
+ * Send a file response to a HTTP request, and exit
+ * 
+ * Parameters:
+ * const char *url    The requested URL (with leading /).
+ * headers            Don't send headers before if FALSE.
+ */
+static void send_file_and_exit(const char *url, int headers)
+{
+    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;
+    ssize_t count;
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+    off_t offset = 0;
+#endif
+
+    suffix = strrchr(url, '.');
+
+    /* If not found, set default as "application/octet-stream";  */
+    found_mime_type = "application/octet-stream";
+    if (suffix) {
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+        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;
+                }
+            }
+        }
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+        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("cannot open '%s'", url);
+        if (headers)
+            send_headers_and_exit(HTTP_NOT_FOUND);
+    }
+
+    if (headers)
+        send_headers(HTTP_OK);
+
+    /* If you want to know about EPIPE below
+     * (happens if you abort downloads from local httpd): */
+    signal(SIGPIPE, SIG_IGN);
+
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+    do {
+        /* byte count (3rd arg) is rounded down to 64k */
+        count = sendfile(1, f, &offset, MAXINT(ssize_t) - 0xffff);
+        if (count < 0) {
+            if (offset == 0)
+                goto fallback;
+            goto fin;
+        }
+    } while (count > 0);
+    log_and_exit();
+
+ fallback:
+#endif
+    while ((count = safe_read(f, iobuf, IOBUF_SIZE)) > 0) {
+        ssize_t n = count;
+        count = full_write(1, iobuf, count);
+        if (count != n)
+            break;
+    }
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+ fin:
+#endif
+    if (count < 0 && verbose > 1)
+        bb_perror_msg("error");
+    log_and_exit();
+}
+
+static int checkPermIP(void)
+{
+    Htaccess_IP *cur;
+
+    /* This could stand some work */
+    for (cur = ip_a_d; cur; cur = cur->next) {
 #if DEBUG
-      if (WIFEXITED(status))
-          bb_error_msg("piped has exited with status=%d", WEXITSTATUS(status));
-      if (WIFSIGNALED(status))
-          bb_error_msg("piped has exited with signal=%d", WTERMSIG(status));
-#endif
-      break;
-    }
-      } else if(post_readed_size > 0 && FD_ISSET(outFd, &writeSet)) {
-        count = bb_full_write(outFd, wbuf + post_readed_idx, post_readed_size);
-        if(count > 0) {
-            post_readed_size -= count;
-            post_readed_idx += count;
-            if(post_readed_size == 0)
-                post_readed_idx = 0;
-        } else {
-            post_readed_size = post_readed_idx = bodyLen = 0; /* broken pipe to CGI */
-        }
-      } else if(bodyLen > 0 && post_readed_size == 0 && FD_ISSET(a_c_r, &readSet)) {
-        count = bodyLen > (int)sizeof(wbuf) ? (int)sizeof(wbuf) : bodyLen;
-        count = safe_read(a_c_r, wbuf, count);
-        if(count > 0) {
-            post_readed_size += count;
-            bodyLen -= count;
-        } else {
-            bodyLen = 0;    /* closed */
-        }
-      }
-      if(FD_ISSET(inFd, &readSet)) {
-    int s = a_c_w;
-    char *rbuf = config->buf;
-
-#ifndef PIPE_BUF
-# define PIPESIZE 4096          /* amount of buffering in a pipe */
+        fprintf(stderr,
+            "checkPermIP: '%s' ? '%u.%u.%u.%u/%u.%u.%u.%u'\n",
+            rmt_ip_str,
+            (unsigned char)(cur->ip >> 24),
+            (unsigned char)(cur->ip >> 16),
+            (unsigned char)(cur->ip >> 8),
+            (unsigned char)(cur->ip),
+            (unsigned char)(cur->mask >> 24),
+            (unsigned char)(cur->mask >> 16),
+            (unsigned char)(cur->mask >> 8),
+            (unsigned char)(cur->mask)
+        );
+#endif
+        if ((rmt_ip & cur->mask) == cur->ip)
+            return cur->allow_deny == 'A';   /* Allow/Deny */
+    }
+
+    /* if unconfigured, return 1 - access from all */
+    return !flg_deny_all;
+}
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+/*
+ * Check the permission file for access password protected.
+ *
+ * If config file isn't present, everything is allowed.
+ * Entries are of the form you can see example from header source
+ *
+ * path      The file path.
+ * request   User information to validate.
+ *
+ * Returns 1 if request is OK.
+ */
+static int checkPerm(const char *path, const char *request)
+{
+    Htaccess *cur;
+    const char *p;
+    const char *p0;
+
+    const char *prev = NULL;
+
+    /* This could stand some work */
+    for (cur = g_auth; cur; cur = cur->next) {
+        size_t l;
+
+        p0 = cur->before_colon;
+        if (prev != NULL && strcmp(prev, p0) != 0)
+            continue;       /* find next identical */
+        p = cur->after_colon;
+        if (DEBUG)
+            fprintf(stderr, "checkPerm: '%s' ? '%s'\n", p0, request);
+
+        l = strlen(p0);
+        if (strncmp(p0, path, l) == 0
+         && (l == 1 || path[l] == '/' || path[l] == '\0')
+        ) {
+            char *u;
+            /* path match found.  Check request */
+            /* for check next /path:user:password */
+            prev = p0;
+            u = strchr(request, ':');
+            if (u == NULL) {
+                /* bad request, ':' required */
+                break;
+            }
+
+            if (ENABLE_FEATURE_HTTPD_AUTH_MD5) {
+                char *cipher;
+                char *pp;
+
+                if (strncmp(p, request, u - request) != 0) {
+                    /* user doesn't match */
+                    continue;
+                }
+                pp = strchr(p, ':');
+                if (pp && pp[1] == '$' && pp[2] == '1'
+                 && pp[3] == '$' && pp[4]
+                ) {
+                    pp++;
+                    cipher = pw_encrypt(u+1, pp);
+                    if (strcmp(cipher, pp) == 0)
+                        goto set_remoteuser_var;   /* Ok */
+                    /* unauthorized */
+                    continue;
+                }
+            }
+
+            if (strcmp(p, request) == 0) {
+ set_remoteuser_var:
+                remoteuser = strdup(request);
+                if (remoteuser)
+                    remoteuser[u - request] = '\0';
+                return 1;   /* Ok */
+            }
+            /* unauthorized */
+        }
+    } /* for */
+
+    return prev == NULL;
+}
+#endif  /* FEATURE_HTTPD_BASIC_AUTH */
+
+/*
+ * Handle timeouts
+ */
+static void exit_on_signal(int sig) ATTRIBUTE_NORETURN;
+static void exit_on_signal(int sig)
+{
+    send_headers_and_exit(HTTP_REQUEST_TIMEOUT);
+}
+
+/*
+ * Handle an incoming http request and exit.
+ */
+static void handle_incoming_and_exit(const len_and_sockaddr *fromAddr) ATTRIBUTE_NORETURN;
+static void handle_incoming_and_exit(const len_and_sockaddr *fromAddr)
+{
+    static const char request_GET[] ALIGN1 = "GET";
+
+    struct stat sb;
+    char *urlcopy;
+    char *urlp;
+    char *tptr;
+    int http_major_version;
+    int ip_allowed;
+#if ENABLE_FEATURE_HTTPD_CGI
+    const char *prequest;
+    unsigned long length = 0;
+    char *cookie = 0;
+    char *content_type = 0;
+#endif
+    struct sigaction sa;
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    int credentials = -1;  /* if not required this is Ok */
+#endif
+
+    /* Allocation of iobuf is postponed until now
+     * (IOW, server process doesn't need to waste 8k) */
+    iobuf = xmalloc(IOBUF_SIZE);
+
+    rmt_ip = 0;
+    if (fromAddr->sa.sa_family == AF_INET) {
+        rmt_ip = ntohl(fromAddr->sin.sin_addr.s_addr);
+    }
+#if ENABLE_FEATURE_IPV6
+    if (fromAddr->sa.sa_family == AF_INET6
+     && fromAddr->sin6.sin6_addr.s6_addr32[0] == 0
+     && fromAddr->sin6.sin6_addr.s6_addr32[1] == 0
+     && ntohl(fromAddr->sin6.sin6_addr.s6_addr32[2]) == 0xffff)
+        rmt_ip = ntohl(fromAddr->sin6.sin6_addr.s6_addr32[3]);
+#endif
+    if (ENABLE_FEATURE_HTTPD_CGI || DEBUG || verbose) {
+        rmt_ip_str = xmalloc_sockaddr2dotted(&fromAddr->sa);
+    }
+    if (verbose) {
+        /* this trick makes -v logging much simpler */
+        applet_name = rmt_ip_str;
+        if (verbose > 2)
+            bb_error_msg("connected");
+    }
+
+    /* Install timeout handler */
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = exit_on_signal;
+    /* sigemptyset(&sa.sa_mask); - memset should be enough */
+    /*sa.sa_flags = 0; - no SA_RESTART */
+    sigaction(SIGALRM, &sa, NULL);
+    alarm(HEADER_READ_TIMEOUT);
+
+    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");
+    if (urlp == NULL)
+        send_headers_and_exit(HTTP_BAD_REQUEST);
+    *urlp++ = '\0';
+#if ENABLE_FEATURE_HTTPD_CGI
+    prequest = request_GET;
+    if (strcasecmp(iobuf, prequest) != 0) {
+        prequest = "POST";
+        if (strcasecmp(iobuf, prequest) != 0)
+            send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
+    }
 #else
-# define PIPESIZE PIPE_BUF
-#endif
-#if PIPESIZE >= MAX_MEMORY_BUFF
-# error "PIPESIZE >= MAX_MEMORY_BUFF"
-#endif
-
-    // There is something to read
-    count = safe_read(inFd, rbuf, PIPESIZE);
-    if (count == 0)
-        break;  /* closed */
-    if (count > 0) {
-      if (firstLine) {
-        rbuf[count] = 0;
-        /* check to see if the user script added headers */
-        if(strncmp(rbuf, "HTTP/1.0 200 OK\r\n", 4) != 0) {
-          bb_full_write(s, "HTTP/1.0 200 OK\r\n", 17);
-        }
-        if (strstr(rbuf, "ontent-") == 0) {
-          bb_full_write(s, "Content-type: text/plain\r\n\r\n", 28);
-        }
-        firstLine = 0;
-      }
-      if (bb_full_write(s, rbuf, count) != count)
-          break;
-
-#if DEBUG
-      fprintf(stderr, "cgi read %d bytes\n", count);
-#endif
-    }
-      }
-    }
-  }
-  return 0;
-}
-#endif          /* CONFIG_FEATURE_HTTPD_CGI */
-
-/****************************************************************************
- *
- > $Function: sendFile()
- *
- * $Description: Send a file response to an HTTP request
- *
- * $Parameter:
- *      (const char *) url . . The URL requested.
- *
- * $Return: (int)  . . . . . . Always 0.
- *
- ****************************************************************************/
-static int sendFile(const char *url)
-{
-  char * suffix;
-  int  f;
-  const char * const * table;
-  const char * try_suffix;
-
-  suffix = strrchr(url, '.');
-
-  for (table = suffixTable; *table; table += 2)
-    if(suffix != NULL && (try_suffix = strstr(*table, suffix)) != 0) {
-        try_suffix += strlen(suffix);
-        if(*try_suffix == 0 || *try_suffix == '.')
-            break;
-    }
-  /* also, if not found, set default as "application/octet-stream";  */
-  config->httpd_found.found_mime_type = *(table+1);
-#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
-  if (suffix) {
-    Htaccess * cur;
-
-    for (cur = config->mime_a; cur; cur = cur->next) {
-    if(strcmp(cur->before_colon, suffix) == 0) {
-        config->httpd_found.found_mime_type = cur->after_colon;
-        break;
-    }
-    }
-  }
-#endif  /* CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES */
-
-#if DEBUG
-  fprintf(stderr, "Sending file '%s' Content-type: %s\n",
-            url, config->httpd_found.found_mime_type);
-#endif
-
-  f = open(url, O_RDONLY);
-  if (f >= 0) {
-    int count;
-    char *buf = config->buf;
-
-    sendHeaders(HTTP_OK);
-    while ((count = bb_full_read(f, buf, MAX_MEMORY_BUFF)) > 0) {
-        if (bb_full_write(a_c_w, buf, count) != count)
-            break;
-    }
-    close(f);
-  } else {
-#if DEBUG
-    bb_perror_msg("Unable to open '%s'", url);
-#endif
-    sendHeaders(HTTP_NOT_FOUND);
-  }
-
-  return 0;
-}
-
-static int checkPermIP(void)
-{
-    Htaccess_IP * cur;
-
-    /* This could stand some work */
-    for (cur = config->ip_a_d; cur; cur = cur->next) {
-#if DEBUG
-    fprintf(stderr, "checkPermIP: '%s' ? ", config->rmt_ip_str);
-    fprintf(stderr, "'%u.%u.%u.%u/%u.%u.%u.%u'\n",
-        (unsigned char)(cur->ip >> 24),
-        (unsigned char)(cur->ip >> 16),
-        (unsigned char)(cur->ip >> 8),
-                cur->ip & 0xff,
-        (unsigned char)(cur->mask >> 24),
-        (unsigned char)(cur->mask >> 16),
-        (unsigned char)(cur->mask >> 8),
-                cur->mask & 0xff);
-#endif
-    if((config->rmt_ip & cur->mask) == cur->ip)
-        return cur->allow_deny == 'A';   /* Allow/Deny */
-    }
-
-    /* if unconfigured, return 1 - access from all */
-    return !config->flg_deny_all;
-}
-
-/****************************************************************************
- *
- > $Function: checkPerm()
- *
- * $Description: Check the permission file for access password protected.
- *
- *   If config file isn't present, everything is allowed.
- *   Entries are of the form you can see example from header source
- *
- * $Parameters:
- *      (const char *) path  . . . . The file path.
- *      (const char *) request . . . User information to validate.
- *
- * $Return: (int)  . . . . . . . . . 1 if request OK, 0 otherwise.
- *
- ****************************************************************************/
-
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-static int checkPerm(const char *path, const char *request)
-{
-    Htaccess * cur;
-    const char *p;
-    const char *p0;
-
-    const char *prev = NULL;
-
-    /* This could stand some work */
-    for (cur = config->auth; cur; cur = cur->next) {
-    p0 = cur->before_colon;
-    if(prev != NULL && strcmp(prev, p0) != 0)
-        continue;       /* find next identical */
-    p = cur->after_colon;
-#if DEBUG
-    fprintf(stderr,"checkPerm: '%s' ? '%s'\n", p0, request);
-#endif
+    if (strcasecmp(iobuf, request_GET) != 0)
+        send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
+#endif
+    urlp = skip_whitespace(urlp);
+    if (urlp[0] != '/')
+        send_headers_and_exit(HTTP_BAD_REQUEST);
+
+    /* Find end of URL and parse HTTP version, if any */
+    http_major_version = -1;
+    tptr = strchrnul(urlp, ' ');
+    /* Is it " HTTP/"? */
+    if (tptr[0] && strncmp(tptr + 1, HTTP_200, 5) == 0)
+        http_major_version = (tptr[6] - '0');
+    *tptr = '\0';
+
+    /* Copy URL from after "GET "/"POST " to stack-allocated char[] */
+    urlcopy = alloca((tptr - urlp) + sizeof("/index.html"));
+    /*if (urlcopy == NULL)
+     *  send_headers_and_exit(HTTP_INTERNAL_SERVER_ERROR);*/
+    strcpy(urlcopy, urlp);
+    /* NB: urlcopy ptr is never changed after this */
+
+    /* Extract url args if present */
+    tptr = strchr(urlcopy, '?');
+    g_query = NULL;
+    if (tptr) {
+        *tptr++ = '\0';
+        g_query = tptr;
+    }
+
+    /* Decode URL escape sequences */
+    tptr = decodeString(urlcopy, 0);
+    if (tptr == NULL)
+        send_headers_and_exit(HTTP_BAD_REQUEST);
+    if (tptr == urlcopy + 1) {
+        /* '/' or NUL is encoded */
+        send_headers_and_exit(HTTP_NOT_FOUND);
+    }
+
+    /* Canonicalize path */
+    /* Algorithm stolen from libbb bb_simplify_path(),
+     * but don't strdup and reducing trailing slash and protect out root */
+    urlp = tptr = urlcopy;
+    do {
+        if (*urlp == '/') {
+            /* skip duplicate (or initial) slash */
+            if (*tptr == '/') {
+                continue;
+            }
+            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 */
+                        send_headers_and_exit(HTTP_BAD_REQUEST);
+                    while (*--urlp != '/') /* omit previous dir */;
+                        continue;
+                }
+            }
+        }
+        *++urlp = *tptr;
+    } while (*++tptr);
+    *++urlp = '\0';       /* so keep last character */
+    tptr = urlp;          /* end ptr */
+
+    /* If URL is a directory, add '/' */
+    if (tptr[-1] != '/') {
+        if (is_directory(urlcopy + 1, 1, &sb)) {
+            found_moved_temporarily = urlcopy;
+        }
+    }
+
+    /* Log it */
+    if (verbose > 1)
+        bb_error_msg("url:%s", urlcopy);
+
+    tptr = urlcopy;
+    ip_allowed = checkPermIP();
+    while (ip_allowed && (tptr = strchr(tptr + 1, '/')) != NULL) {
+        /* have path1/path2 */
+        *tptr = '\0';
+        if (is_directory(urlcopy + 1, 1, &sb)) {
+            /* may be having subdir config */
+            parse_conf(urlcopy + 1, SUBDIR_PARSE);
+            ip_allowed = checkPermIP();
+        }
+        *tptr = '/';
+    }
+    if (http_major_version >= 0) {
+        /* Request was with "... HTTP/nXXX", and n >= 0 */
+
+        /* Read until blank line for HTTP version specified, else parse immediate */
+        while (1) {
+            alarm(HEADER_READ_TIMEOUT);
+            if (!get_line())
+                break; /* EOF or error or empty line */
+            if (DEBUG)
+                bb_error_msg("header: '%s'", iobuf);
+
+#if ENABLE_FEATURE_HTTPD_CGI
+            /* try and do our best to parse more lines */
+            if ((STRNCASECMP(iobuf, "Content-length:") == 0)) {
+                /* extra read only for POST */
+                if (prequest != request_GET) {
+                    tptr = iobuf + sizeof("Content-length:") - 1;
+                    if (!tptr[0])
+                        send_headers_and_exit(HTTP_BAD_REQUEST);
+                    errno = 0;
+                    /* not using strtoul: it ignores leading minus! */
+                    length = strtol(tptr, &tptr, 10);
+                    /* length is "ulong", but we need to pass it to int later */
+                    /* so we check for negative or too large values in one go: */
+                    /* (long -> ulong conv caused negatives to be seen as > INT_MAX) */
+                    if (tptr[0] || errno || length > INT_MAX)
+                        send_headers_and_exit(HTTP_BAD_REQUEST);
+                }
+            } else if (STRNCASECMP(iobuf, "Cookie:") == 0) {
+                cookie = strdup(skip_whitespace(iobuf + sizeof("Cookie:")-1));
+            } else if (STRNCASECMP(iobuf, "Content-Type:") == 0) {
+                content_type = strdup(skip_whitespace(iobuf + sizeof("Content-Type:")-1));
+            } else if (STRNCASECMP(iobuf, "Referer:") == 0) {
+                referer = strdup(skip_whitespace(iobuf + sizeof("Referer:")-1));
+            } else if (STRNCASECMP(iobuf, "User-Agent:") == 0) {
+                user_agent = strdup(skip_whitespace(iobuf + sizeof("User-Agent:")-1));
+            }
+#endif
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+            if (STRNCASECMP(iobuf, "Authorization:") == 0) {
+                /* We only allow Basic credentials.
+                 * It shows up as "Authorization: Basic <userid:password>" where
+                 * the userid:password is base64 encoded.
+                 */
+                tptr = skip_whitespace(iobuf + sizeof("Authorization:")-1);
+                if (STRNCASECMP(tptr, "Basic") != 0)
+                    continue;
+                tptr += sizeof("Basic")-1;
+                /* decodeBase64() skips whitespace itself */
+                decodeBase64(tptr);
+                credentials = checkPerm(urlcopy, tptr);
+            }
+#endif          /* FEATURE_HTTPD_BASIC_AUTH */
+        } /* while extra header reading */
+    }
+
+    /* We read headers, disable peer timeout */
+    alarm(0);
+
+    if (strcmp(bb_basename(urlcopy), httpd_conf) == 0 || ip_allowed == 0) {
+        /* protect listing [/path]/httpd_conf or IP deny */
+        send_headers_and_exit(HTTP_FORBIDDEN);
+    }
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    if (credentials <= 0 && checkPerm(urlcopy, ":") == 0) {
+        send_headers_and_exit(HTTP_UNAUTHORIZED);
+    }
+#endif
+
+    if (found_moved_temporarily) {
+        send_headers_and_exit(HTTP_MOVED_TEMPORARILY);
+    }
+
+    tptr = urlcopy + 1;      /* skip first '/' */
+
+#if ENABLE_FEATURE_HTTPD_CGI
+    if (strncmp(tptr, "cgi-bin/", 8) == 0) {
+        if (tptr[8] == '\0') {
+            /* protect listing "cgi-bin/" */
+            send_headers_and_exit(HTTP_FORBIDDEN);
+        }
+        send_cgi_and_exit(urlcopy, prequest, length, cookie, content_type);
+    }
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
     {
-        size_t l = strlen(p0);
-
-        if(strncmp(p0, path, l) == 0 &&
-                (l == 1 || path[l] == '/' || path[l] == 0)) {
-        char *u;
-        /* path match found.  Check request */
-        /* for check next /path:user:password */
-        prev = p0;
-        u = strchr(request, ':');
-        if(u == NULL) {
-            /* bad request, ':' required */
-            break;
-            }
-
-#ifdef CONFIG_FEATURE_HTTPD_AUTH_MD5
-        {
-            char *cipher;
-            char *pp;
-
-            if(strncmp(p, request, u-request) != 0) {
-                /* user uncompared */
-                continue;
-            }
-            pp = strchr(p, ':');
-            if(pp && pp[1] == '$' && pp[2] == '1' &&
-                         pp[3] == '$' && pp[4]) {
-                pp++;
-                cipher = pw_encrypt(u+1, pp);
-                if (strcmp(cipher, pp) == 0)
-                    goto set_remoteuser_var;   /* Ok */
-                /* unauthorized */
-                continue;
-            }
-        }
-#endif
-        if (strcmp(p, request) == 0) {
-#ifdef CONFIG_FEATURE_HTTPD_AUTH_MD5
-set_remoteuser_var:
-#endif
-            config->remoteuser = strdup(request);
-            if(config->remoteuser)
-            config->remoteuser[(u - request)] = 0;
-            return 1;   /* Ok */
-        }
-        /* unauthorized */
-        }
-    }
-    }   /* for */
-
-    return prev == NULL;
-}
-
-#endif  /* CONFIG_FEATURE_HTTPD_BASIC_AUTH */
-
-/****************************************************************************
- *
- > $Function: handle_sigalrm()
- *
- * $Description: Handle timeouts
- *
- ****************************************************************************/
-
-static void
-handle_sigalrm( int sig )
-{
-    sendHeaders(HTTP_REQUEST_TIMEOUT);
-    config->alarm_signaled = sig;
-}
-
-/****************************************************************************
- *
- > $Function: handleIncoming()
- *
- * $Description: Handle an incoming http request.
- *
- ****************************************************************************/
-static void handleIncoming(void)
-{
-  char *buf = config->buf;
-  char *url;
-  char *purl;
-  int  blank = -1;
-  char *test;
-  struct stat sb;
-  int ip_allowed;
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-  const char *prequest = request_GET;
-  long length=0;
-  char *cookie = 0;
-  char *content_type = 0;
-#endif
-  fd_set s_fd;
-  struct timeval tv;
-  int retval;
-  struct sigaction sa;
-
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-  int credentials = -1;  /* if not requred this is Ok */
-#endif
-
-  sa.sa_handler = handle_sigalrm;
-  sigemptyset(&sa.sa_mask);
-  sa.sa_flags = 0; /* no SA_RESTART */
-  sigaction(SIGALRM, &sa, NULL);
-
-  do {
-    int  count;
-
-    (void) alarm( TIMEOUT );
-    if (getLine() <= 0)
-    break;  /* closed */
-
-    purl = strpbrk(buf, " \t");
-    if(purl == NULL) {
-BAD_REQUEST:
-      sendHeaders(HTTP_BAD_REQUEST);
-      break;
-    }
-    *purl = 0;
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-    if(strcasecmp(buf, prequest) != 0) {
-    prequest = "POST";
-    if(strcasecmp(buf, prequest) != 0) {
-        sendHeaders(HTTP_NOT_IMPLEMENTED);
-        break;
-    }
-    }
+        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);
+                }
+            }
+        }
+    }
+#endif
+    if (prequest != request_GET) {
+        send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
+    }
+#endif  /* FEATURE_HTTPD_CGI */
+
+    if (urlp[-1] == '/')
+        strcpy(urlp, "index.html");
+    if (stat(tptr, &sb) == 0) {
+        /* It's a dir URL and there is index.html */
+        ContentLength = sb.st_size;
+        last_mod = sb.st_mtime;
+    }
+#if ENABLE_FEATURE_HTTPD_CGI
+    else if (urlp[-1] == '/') {
+        /* 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);
+        }
+    }
+#endif
+    /* else {
+     *  fall through to send_file, it errors out if open fails
+     * }
+     */
+
+    send_file_and_exit(tptr, TRUE);
+}
+
+/*
+ * The main http server function.
+ * Given a socket, listen for new connections and farm out
+ * the processing as a [v]forked process.
+ * Never returns.
+ */
+#if BB_MMU
+static void mini_httpd(int server_socket) ATTRIBUTE_NORETURN;
+static void mini_httpd(int server_socket)
+{
+    /* NB: it's best to not use xfuncs in this loop before fork().
+     * Otherwise server may die on transient errors (temporary
+     * out-of-memory condition, etc), which is Bad(tm).
+     * Try to do any dangerous calls after fork.
+     */
+    while (1) {
+        int n;
+        len_and_sockaddr fromAddr;
+        
+        /* Wait for connections... */
+        fromAddr.len = LSA_SIZEOF_SA;
+        n = accept(server_socket, &fromAddr.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);
+
+            handle_incoming_and_exit(&fromAddr);
+        }
+        /* parent, or fork failed */
+        close(n);
+    } /* while (1) */
+    /* never reached */
+}
 #else
-    if(strcasecmp(buf, request_GET) != 0) {
-    sendHeaders(HTTP_NOT_IMPLEMENTED);
-    break;
-    }
-#endif
-    *purl = ' ';
-    count = sscanf(purl, " %[^ ] HTTP/%d.%*d", buf, &blank);
-
-    if (count < 1 || buf[0] != '/') {
-      /* Garbled request/URL */
-      goto BAD_REQUEST;
-    }
-    url = alloca(strlen(buf) + 12);      /* + sizeof("/index.html\0") */
-    if(url == NULL) {
-    sendHeaders(HTTP_INTERNAL_SERVER_ERROR);
-    break;
-    }
-    strcpy(url, buf);
-    /* extract url args if present */
-    test = strchr(url, '?');
-    if (test) {
-      *test++ = 0;
-      config->query = test;
-    }
-
-    test = decodeString(url, 0);
-    if(test == NULL)
-    goto BAD_REQUEST;
-    if(test == (buf+1)) {
-    sendHeaders(HTTP_NOT_FOUND);
-    break;
-    }
-    /* algorithm stolen from libbb bb_simplify_path(),
-       but don`t strdup and reducing trailing slash and protect out root */
-    purl = test = url;
-
-    do {
-    if (*purl == '/') {
-        if (*test == '/') {        /* skip duplicate (or initial) slash */
-        continue;
-        } else if (*test == '.') {
-        if (test[1] == '/' || test[1] == 0) { /* skip extra '.' */
-            continue;
-        } else if ((test[1] == '.') && (test[2] == '/' || test[2] == 0)) {
-            ++test;
-            if (purl == url) {
-            /* protect out root */
-            goto BAD_REQUEST;
-            }
-            while (*--purl != '/');    /* omit previous dir */
-            continue;
-        }
-        }
-    }
-    *++purl = *test;
-    } while (*++test);
-
-    *++purl = 0;        /* so keep last character */
-    test = purl;        /* end ptr */
-
-    /* If URL is directory, adding '/' */
-    if(test[-1] != '/') {
-        if ( is_directory(url + 1, 1, &sb) ) {
-            config->httpd_found.found_moved_temporarily = url;
-        }
-    }
-#if DEBUG
-    fprintf(stderr, "url='%s', args=%s\n", url, config->query);
-#endif
-
-    test = url;
-    ip_allowed = checkPermIP();
-    while(ip_allowed && (test = strchr( test + 1, '/' )) != NULL) {
-    /* have path1/path2 */
-    *test = '\0';
-    if( is_directory(url + 1, 1, &sb) ) {
-        /* may be having subdir config */
-        parse_conf(url + 1, SUBDIR_PARSE);
-        ip_allowed = checkPermIP();
-    }
-    *test = '/';
-    }
-    if(blank >= 0) {
-      // read until blank line for HTTP version specified, else parse immediate
-      while(1) {
-    alarm(TIMEOUT);
-    count = getLine();
-    if(count <= 0)
-        break;
-
-#if DEBUG
-    fprintf(stderr, "Header: '%s'\n", buf);
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-    /* try and do our best to parse more lines */
-    if ((strncasecmp(buf, Content_length, 15) == 0)) {
-      if(prequest != request_GET)
-          length = strtol(buf + 15, 0, 0); // extra read only for POST
-    } else if ((strncasecmp(buf, "Cookie:", 7) == 0)) {
-          for(test = buf + 7; isspace(*test); test++)
-              ;
-          cookie = strdup(test);
-    } else if ((strncasecmp(buf, "Content-Type:", 13) == 0)) {
-          for(test = buf + 13; isspace(*test); test++)
-              ;
-          content_type = strdup(test);
-    } else if ((strncasecmp(buf, "Referer:", 8) == 0)) {
-          for(test = buf + 8; isspace(*test); test++)
-              ;
-          config->referer = strdup(test);
-    }
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-    if (strncasecmp(buf, "Authorization:", 14) == 0) {
-      /* We only allow Basic credentials.
-       * It shows up as "Authorization: Basic <userid:password>" where
-       * the userid:password is base64 encoded.
-       */
-      for(test = buf + 14; isspace(*test); test++)
-          ;
-      if (strncasecmp(test, "Basic", 5) != 0)
-          continue;
-
-      test += 5;  /* decodeBase64() skiping space self */
-      decodeBase64(test);
-      credentials = checkPerm(url, test);
-    }
-#endif          /* CONFIG_FEATURE_HTTPD_BASIC_AUTH */
-
-      }   /* while extra header reading */
-    }
-    (void) alarm( 0 );
-    if(config->alarm_signaled)
-    break;
-
-    if (strcmp(strrchr(url, '/') + 1, httpd_conf) == 0 || ip_allowed == 0) {
-        /* protect listing [/path]/httpd_conf or IP deny */
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-FORBIDDEN:      /* protect listing /cgi-bin */
-#endif
-        sendHeaders(HTTP_FORBIDDEN);
-        break;
-    }
-
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-    if (credentials <= 0 && checkPerm(url, ":") == 0) {
-      sendHeaders(HTTP_UNAUTHORIZED);
-      break;
-    }
-#endif
-
-    if(config->httpd_found.found_moved_temporarily) {
-    sendHeaders(HTTP_MOVED_TEMPORARILY);
-#if DEBUG
-    /* clear unforked memory flag */
-    config->httpd_found.found_moved_temporarily = NULL;
-#endif
-    break;
-    }
-
-    test = url + 1;      /* skip first '/' */
-
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-    /* if strange Content-Length */
-    if (length < 0)
-    break;
-
-    if (strncmp(test, "cgi-bin", 7) == 0) {
-        if(test[7] == '/' && test[8] == 0)
-            goto FORBIDDEN;     // protect listing cgi-bin/
-        sendCgi(url, prequest, length, cookie, content_type);
-    } else {
-    if (prequest != request_GET)
-        sendHeaders(HTTP_NOT_IMPLEMENTED);
-    else {
-#endif  /* CONFIG_FEATURE_HTTPD_CGI */
-        if(purl[-1] == '/')
-            strcpy(purl, "index.html");
-        if ( stat(test, &sb ) == 0 ) {
-            config->ContentLength = sb.st_size;
-            config->last_mod = sb.st_mtime;
-        }
-        sendFile(test);
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-        /* unset if non inetd looped */
-        config->ContentLength = -1;
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-    }
-    }
-#endif
-
-  } while (0);
-
-
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-/* from inetd don`t looping: freeing, closing automatic from exit always */
-# if DEBUG
-  fprintf(stderr, "closing socket\n");
-# endif
-# ifdef CONFIG_FEATURE_HTTPD_CGI
-  free(cookie);
-  free(content_type);
-  free(config->referer);
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-  free(config->remoteuser);
-#endif
-# endif
-#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
-  shutdown(a_c_w, SHUT_WR);
-
-  /* Properly wait for remote to closed */
-  FD_ZERO (&s_fd) ;
-  FD_SET (a_c_r, &s_fd) ;
-
-  do {
-    tv.tv_sec = 2 ;
-    tv.tv_usec = 0 ;
-    retval = select (a_c_r + 1, &s_fd, NULL, NULL, &tv);
-  } while (retval > 0 && (read (a_c_r, buf, sizeof (config->buf)) > 0));
-
-  shutdown(a_c_r, SHUT_RD);
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-  close(config->accepted_socket);
-#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
-}
-
-/****************************************************************************
- *
- > $Function: miniHttpd()
- *
- * $Description: The main http server function.
- *
- *   Given an open socket fildes, listen for new connections and farm out
- *   the processing as a forked process.
- *
- * $Parameters:
- *      (int) server. . . The server socket fildes.
- *
- * $Return: (int) . . . . Always 0.
- *
- ****************************************************************************/
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-static int miniHttpd(int server)
-{
-  fd_set readfd, portfd;
-
-  FD_ZERO(&portfd);
-  FD_SET(server, &portfd);
-
-  /* copy the ports we are watching to the readfd set */
-  while (1) {
-    readfd = portfd;
-
-    /* Now wait INDEFINITELY on the set of sockets! */
-    if (select(server + 1, &readfd, 0, 0, 0) > 0) {
-      if (FD_ISSET(server, &readfd)) {
-    int on;
-    struct sockaddr_in fromAddr;
-
-    socklen_t fromAddrLen = sizeof(fromAddr);
-    int s = accept(server,
-               (struct sockaddr *)&fromAddr, &fromAddrLen);
-
-    if (s < 0) {
-        continue;
-    }
-    config->accepted_socket = s;
-    config->rmt_ip = ntohl(fromAddr.sin_addr.s_addr);
-#if defined(CONFIG_FEATURE_HTTPD_CGI) || DEBUG
-    sprintf(config->rmt_ip_str, "%u.%u.%u.%u",
-        (unsigned char)(config->rmt_ip >> 24),
-        (unsigned char)(config->rmt_ip >> 16),
-        (unsigned char)(config->rmt_ip >> 8),
-                config->rmt_ip & 0xff);
-    config->port = ntohs(fromAddr.sin_port);
-#if DEBUG
-    bb_error_msg("connection from IP=%s, port %u\n",
-                    config->rmt_ip_str, config->port);
-#endif
-#endif /* CONFIG_FEATURE_HTTPD_CGI */
-
-    /*  set the KEEPALIVE option to cull dead connections */
-    on = 1;
-    setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof (on));
-
-#if !DEBUG
-    if (fork() == 0)
-#endif
-    {
-        /* This is the spawned thread */
-#ifdef CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
-        /* protect reload config, may be confuse checking */
-        signal(SIGHUP, SIG_IGN);
-#endif
-        handleIncoming();
-#if !DEBUG
-        exit(0);
-#endif
-    }
-    close(s);
-      }
-    }
-  } // while (1)
-  return 0;
-}
-
-#else
-    /* from inetd */
-
-static int miniHttpd(void)
-{
-  struct sockaddr_in fromAddrLen;
-  socklen_t sinlen = sizeof (struct sockaddr_in);
-
-  getpeername (0, (struct sockaddr *)&fromAddrLen, &sinlen);
-  config->rmt_ip = ntohl(fromAddrLen.sin_addr.s_addr);
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-  sprintf(config->rmt_ip_str, "%u.%u.%u.%u",
-        (unsigned char)(config->rmt_ip >> 24),
-        (unsigned char)(config->rmt_ip >> 16),
-        (unsigned char)(config->rmt_ip >> 8),
-                config->rmt_ip & 0xff);
-#endif
-  config->port = ntohs(fromAddrLen.sin_port);
-  handleIncoming();
-  return 0;
-}
-#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
-
-#ifdef CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+static void mini_httpd_nommu(int server_socket, int argc, char **argv) ATTRIBUTE_NORETURN;
+static void mini_httpd_nommu(int server_socket, int argc, char **argv)
+{
+    char *argv_copy[argc + 2];
+
+    argv_copy[0] = argv[0];
+    argv_copy[1] = (char*)"-i";
+    memcpy(&argv_copy[2], &argv[1], argc * sizeof(argv[0]));
+
+    /* NB: it's best to not use xfuncs in this loop before vfork().
+     * Otherwise server may die on transient errors (temporary
+     * out-of-memory condition, etc), which is Bad(tm).
+     * Try to do any dangerous calls after fork.
+     */
+    while (1) {
+        int n;
+        len_and_sockaddr fromAddr;
+        
+        /* Wait for connections... */
+        fromAddr.len = LSA_SIZEOF_SA;
+        n = accept(server_socket, &fromAddr.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);
+        }
+        /* parent, or vfork failed */
+        close(n);
+    } /* while (1) */
+    /* never reached */
+}
+#endif
+
+/*
+ * Process a HTTP connection on stdin/out.
+ * Never returns.
+ */
+static void mini_httpd_inetd(void) ATTRIBUTE_NORETURN;
+static void mini_httpd_inetd(void)
+{
+    len_and_sockaddr fromAddr;
+
+    fromAddr.len = LSA_SIZEOF_SA;
+    getpeername(0, &fromAddr.sa, &fromAddr.len);
+    handle_incoming_and_exit(&fromAddr);
+}
+
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
 static void sighup_handler(int sig)
 {
-    /* set and reset */
     struct sigaction sa;
 
-    parse_conf(default_path_httpd_conf,
-            sig == SIGHUP ? SIGNALED_PARSE : FIRST_PARSE);
+    parse_conf(default_path_httpd_conf, sig == SIGHUP ? SIGNALED_PARSE : FIRST_PARSE);
+
+    memset(&sa, 0, sizeof(sa));
     sa.sa_handler = sighup_handler;
-    sigemptyset(&sa.sa_mask);
+    /*sigemptyset(&sa.sa_mask); - memset should be enough */
     sa.sa_flags = SA_RESTART;
     sigaction(SIGHUP, &sa, NULL);
@@ -1891 +1986 @@
 #endif
 
-enum httpd_opts_nums {
+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,)
-    USE_FEATURE_HTTPD_WITHOUT_INETD(p_opt_port,)
+    USE_FEATURE_HTTPD_BASIC_AUTH(    r_opt_realm     ,)
+    USE_FEATURE_HTTPD_AUTH_MD5(      m_opt_md5       ,)
+    USE_FEATURE_HTTPD_SETUID(        u_opt_setuid    ,)
+    p_opt_port      ,
+    p_opt_inetd     ,
+    p_opt_foreground,
+    p_opt_verbose   ,
+    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_PORT        = 1 << p_opt_port,
+    OPT_INETD       = 1 << p_opt_inetd,
+    OPT_FOREGROUND  = 1 << p_opt_foreground,
+    OPT_VERBOSE     = 1 << p_opt_verbose,
 };
 
-static const char httpd_opts[]="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:")
-    USE_FEATURE_HTTPD_WITHOUT_INETD("p:");
-
-#define OPT_CONFIG_FILE (1<<c_opt_config_file)
-#define OPT_DECODE_URL  (1<<d_opt_decode_url)
-#define OPT_HOME_HTTPD  (1<<h_opt_home_httpd)
-
-#define OPT_ENCODE_URL  USE_FEATURE_HTTPD_ENCODE_URL_STR((1<<e_opt_encode_url)) \
-            SKIP_FEATURE_HTTPD_ENCODE_URL_STR(0)
-
-#define OPT_REALM       USE_FEATURE_HTTPD_BASIC_AUTH((1<<r_opt_realm)) \
-            SKIP_FEATURE_HTTPD_BASIC_AUTH(0)
-
-#define OPT_MD5         USE_FEATURE_HTTPD_AUTH_MD5((1<<m_opt_md5)) \
-            SKIP_FEATURE_HTTPD_AUTH_MD5(0)
-
-#define OPT_SETUID      USE_FEATURE_HTTPD_SETUID((1<<u_opt_setuid)) \
-            SKIP_FEATURE_HTTPD_SETUID(0)
-
-#define OPT_PORT        USE_FEATURE_HTTPD_WITHOUT_INETD((1<<p_opt_port)) \
-            SKIP_FEATURE_HTTPD_WITHOUT_INETD(0)
-
-
-int httpd_main(int argc, char *argv[])
-{
-  unsigned long opt;
-  const char *home_httpd = home;
-  char *url_for_decode;
-  USE_FEATURE_HTTPD_ENCODE_URL_STR(const char *url_for_encode;)
-  USE_FEATURE_HTTPD_WITHOUT_INETD(const char *s_port;)
-  USE_FEATURE_HTTPD_WITHOUT_INETD(int server;)
-
-  USE_FEATURE_HTTPD_SETUID(const char *s_uid;)
-  USE_FEATURE_HTTPD_SETUID(long uid = -1;)
-
-  USE_FEATURE_HTTPD_AUTH_MD5(const char *pass;)
-
-  config = xcalloc(1, sizeof(*config));
-#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
-  config->realm = "Web Server Authentication";
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-  config->port = 80;
-#endif
-
-  config->ContentLength = -1;
-
-  opt = bb_getopt_ulflags(argc, argv, httpd_opts,
-            &(config->configFile), &url_for_decode, &home_httpd
+
+int httpd_main(int argc, char **argv);
+int httpd_main(int argc, char **argv)
+{
+    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;)
+
+    INIT_G();
+
+#if ENABLE_LOCALE_SUPPORT
+    /* Undo busybox.c: we want to speak English in http (dates etc) */
+    setlocale(LC_TIME, "C");
+#endif
+
+    home_httpd = xrealloc_getcwd_or_warn(NULL);
+    /* -v counts, -i implies -f */
+    opt_complementary = "vv:if";
+    /* We do not "absolutize" path given by -h (home) opt.
+     * If user gives relative path in -h, $SCRIPT_FILENAME can end up
+     * relative too. */
+    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:")
+            "p:ifv",
+            &configFile, &url_for_decode, &home_httpd
             USE_FEATURE_HTTPD_ENCODE_URL_STR(, &url_for_encode)
-            USE_FEATURE_HTTPD_BASIC_AUTH(, &(config->realm))
+            USE_FEATURE_HTTPD_BASIC_AUTH(, &g_realm)
             USE_FEATURE_HTTPD_AUTH_MD5(, &pass)
-            USE_FEATURE_HTTPD_SETUID(, &s_uid)
-            USE_FEATURE_HTTPD_WITHOUT_INETD(, &s_port)
-    );
-
-  if(opt & OPT_DECODE_URL) {
-      printf("%s", decodeString(url_for_decode, 1));
-      return 0;
-  }
-#ifdef CONFIG_FEATURE_HTTPD_ENCODE_URL_STR
-  if(opt & OPT_ENCODE_URL) {
-      printf("%s", encodeString(url_for_encode));
-      return 0;
-  }
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_AUTH_MD5
-  if(opt & OPT_MD5) {
-      printf("%s\n", pw_encrypt(pass, "$1$"));
-      return 0;
-  }
-#endif
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-    if(opt & OPT_PORT)
-    config->port = bb_xgetlarg(s_port, 10, 1, 0xffff);
-#ifdef CONFIG_FEATURE_HTTPD_SETUID
-    if(opt & OPT_SETUID) {
-    char *e;
-
-    uid = strtol(s_uid, &e, 0);
-    if(*e != '\0') {
-        /* not integer */
-        uid = bb_xgetpwnam(s_uid);
-    }
-      }
-#endif
-#endif
-
-  bb_xchdir(home_httpd);
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-  server = openServer();
-# ifdef CONFIG_FEATURE_HTTPD_SETUID
-  /* drop privileges */
-  if(uid > 0)
-    setuid(uid);
-# endif
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_CGI
-   {
-    char *p = getenv("PATH");
-    if(p) {
-        p = bb_xstrdup(p);
-    }
-    clearenv();
-    if(p)
-        setenv("PATH", p, 1);
-# ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-    addEnvPort("SERVER");
-# endif
-   }
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
-  sighup_handler(0);
+            USE_FEATURE_HTTPD_SETUID(, &s_ugid)
+            , &bind_addr_or_port
+            , &verbose
+        );
+    if (opt & OPT_DECODE_URL) {
+        fputs(decodeString(url_for_decode, 1), stdout);
+        return 0;
+    }
+#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
+    if (opt & OPT_ENCODE_URL) {
+        fputs(encodeString(url_for_encode), stdout);
+        return 0;
+    }
+#endif
+#if ENABLE_FEATURE_HTTPD_AUTH_MD5
+    if (opt & OPT_MD5) {
+        puts(pw_encrypt(pass, "$1$"));
+        return 0;
+    }
+#endif
+#if ENABLE_FEATURE_HTTPD_SETUID
+    if (opt & OPT_SETUID) {
+        if (!get_uidgid(&ugid, s_ugid, 1))
+            bb_error_msg_and_die("unrecognized user[:group] "
+                        "name '%s'", s_ugid);
+    }
+#endif
+
+#if !BB_MMU
+    if (!(opt & OPT_FOREGROUND)) {
+        bb_daemonize_or_rexec(0, argv); /* don't change current directory */
+    }
+#endif
+
+    xchdir(home_httpd);
+    if (!(opt & OPT_INETD)) {
+        signal(SIGCHLD, SIG_IGN);
+        server_socket = openServer();
+#if ENABLE_FEATURE_HTTPD_SETUID
+        /* drop privileges */
+        if (opt & OPT_SETUID) {
+            if (ugid.gid != (gid_t)-1) {
+                if (setgroups(1, &ugid.gid) == -1)
+                    bb_perror_msg_and_die("setgroups");
+                xsetgid(ugid.gid);
+            }
+            xsetuid(ugid.uid);
+        }
+#endif
+    }
+
+#if ENABLE_FEATURE_HTTPD_CGI
+    {
+        char *p = getenv("PATH");
+        /* env strings themself are not freed, no need to strdup(p): */
+        clearenv();
+        if (p)
+            putenv(p - 5);
+//      if (!(opt & OPT_INETD))
+//          setenv_long("SERVER_PORT", ???);
+    }
+#endif
+
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+    if (!(opt & OPT_INETD))
+        sighup_handler(0);
+    else /* do not install HUP handler in inetd mode */
+#endif
+        parse_conf(default_path_httpd_conf, FIRST_PARSE);
+
+    xfunc_error_retval = 0;
+    if (opt & OPT_INETD)
+        mini_httpd_inetd();
+#if BB_MMU
+    if (!(opt & OPT_FOREGROUND))
+        bb_daemonize(0); /* don't change current directory */
+    mini_httpd(server_socket); /* never returns */
 #else
-  parse_conf(default_path_httpd_conf, FIRST_PARSE);
-#endif
-
-#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
-# if !DEBUG
-  bb_xdaemon(1, 0);     /* don`t change curent directory */
-# endif
-  return miniHttpd(server);
-#else
-  return miniHttpd();
-#endif
-}
+    mini_httpd_nommu(server_socket, argc, argv); /* never returns */
+#endif
+    /* return 0; */
+}