httpd: add optional support for error pages

(by Pierre Metras <genepi@sympatico.ca>)

1 files changed, 153 insertions, 85 deletions

diff --git a/networking/httpd.c b/networking/httpd.c
index 070e2a915..7e60fc252 100644
--- a/networking/httpd.c
+++ b/networking/httpd.c
@@ -42,6 +42,7 @@
  * A:10.0.0.0/255.255.255.128  # Allow any address that previous set
  * 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/
  * /adm:toor:PaSsWd  # or user toor, pwd PaSsWd on urls starting with /adm/
@@ -84,6 +85,10 @@
  * subdir http request, any merge is discarded when the process exits.  As a
  * 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
  * root configuration file.  If -c is set and the file is not found, the
@@ -131,6 +136,84 @@ typedef struct Htaccess_IP {
         int allow_deny;
 } Htaccess_IP;
 
+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[] = {
+        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;
@@ -167,6 +250,9 @@ struct globals {
 #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
 };
 #define G (*ptr_to_globals)
 #define verbose           (G.verbose          )
@@ -192,6 +278,7 @@ struct globals {
 #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";) \
@@ -200,70 +287,13 @@ struct globals {
 } while (0)
 
 
-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." },
-#if ENABLE_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", "" },
-#endif
-};
 
 
 #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;
@@ -382,11 +412,13 @@ static int scan_ip_mask(const char *str, unsigned *ipp, unsigned *maskp)
  *    .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.
@@ -486,18 +518,6 @@ static void parse_conf(const char *path, int flag)
 
                 if (*p0 == 'a')
                         *p0 = 'A';
-                else if (*p0 != 'D' && *p0 != 'A'
-#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
-                         && *p0 != '/'
-#endif
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
-                         && *p0 != '.'
-#endif
-#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
-                         && *p0 != '*'
-#endif
-                        )
-                         continue;
                 if (*p0 == 'A' || *p0 == 'D') {
                         /* storing current config IP line */
                         pip = xzalloc(sizeof(Htaccess_IP));
@@ -527,6 +547,30 @@ static void parse_conf(const char *path, int flag)
                         }
                         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;
+                        }
+
+                        /* 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;
+                                }
+                        }
+                        continue;
+                }
+#endif
+
 #if ENABLE_FEATURE_HTTPD_BASIC_AUTH
                 if (*p0 == '/') {
                         /* make full path from httpd root / current_path / config_line_path */
@@ -813,24 +857,29 @@ static void log_and_exit(void)
  * 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.
- * Return result of write().
  */
-static void send_headers(HttpResponseNum responseNum)
+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(httpResponseNames); i++) {
-                if (httpResponseNames[i].type == responseNum) {
-                        responseString = httpResponseNames[i].name;
-                        infoString = httpResponseNames[i].info;
+        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;
                 }
         }
@@ -862,6 +911,20 @@ static void send_headers(HttpResponseNum responseNum)
                                 (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",
@@ -885,8 +948,8 @@ static void send_headers(HttpResponseNum responseNum)
         }
 }
 
-static void send_headers_and_exit(HttpResponseNum responseNum) ATTRIBUTE_NORETURN;
-static void send_headers_and_exit(HttpResponseNum responseNum)
+static void send_headers_and_exit(int responseNum) ATTRIBUTE_NORETURN;
+static void send_headers_and_exit(int responseNum)
 {
         send_headers(responseNum);
         log_and_exit();
@@ -1279,9 +1342,12 @@ static void send_cgi_and_exit(
 
 /*
  * 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) ATTRIBUTE_NORETURN;
-static void send_file_and_exit(const char *url)
+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 */
@@ -1350,10 +1416,12 @@ static void send_file_and_exit(const char *url)
         if (f < 0) {
                 if (DEBUG)
                         bb_perror_msg("cannot open '%s'", url);
-                send_headers_and_exit(HTTP_NOT_FOUND);
+                if (headers)
+                        send_headers_and_exit(HTTP_NOT_FOUND);
         }
 
-        send_headers(HTTP_OK);
+        if (headers)
+                send_headers(HTTP_OK);
 
         /* If you want to know about EPIPE below
          * (happens if you abort downloads from local httpd): */
@@ -1789,7 +1857,7 @@ static void handle_incoming_and_exit(const len_and_sockaddr *fromAddr)
          * }
          */
 
-        send_file_and_exit(tptr);
+        send_file_and_exit(tptr, TRUE);
 }
 
 /*