Adding upstream version 2.4.38.upstream/2.4.38

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 897 insertions, 0 deletions

diff --git a/modules/mappers/mod_imagemap.c b/modules/mappers/mod_imagemap.c
new file mode 100644
index 0000000..187a500
--- /dev/null
+++ b/modules/mappers/mod_imagemap.c
@@ -0,0 +1,897 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This imagemap module started as a port of the original imagemap.c
+ * written by Rob McCool (11/13/93 robm@ncsa.uiuc.edu).
+ * This version includes the mapping algorithms found in version 1.3
+ * of imagemap.c.
+ *
+ * Contributors to this code include:
+ *
+ * Kevin Hughes, kevinh@pulua.hcc.hawaii.edu
+ *
+ * Eric Haines, erich@eye.com
+ * "macmartinized" polygon code copyright 1992 by Eric Haines, erich@eye.com
+ *
+ * Randy Terbush, randy@zyzzyva.com
+ * port to Apache module format, "base_uri" and support for relative URLs
+ *
+ * James H. Cloos, Jr., cloos@jhcloos.com
+ * Added point datatype, using code in NCSA's version 1.8 imagemap.c
+ * program, as distributed with version 1.4.1 of their server.
+ * The point code is originally added by Craig Milo Rogers, Rogers@ISI.Edu
+ *
+ * Nathan Kurz, nate@tripod.com
+ * Rewrite/reorganization.  New handling of default, base and relative URLs.
+ * New Configuration directives:
+ *    ImapMenu {none, formatted, semiformatted, unformatted}
+ *    ImapDefault {error, nocontent, referer, menu, URL}
+ *    ImapBase {map, referer, URL}
+ * Support for creating non-graphical menu added.  (backwards compatible):
+ *    Old:  directive URL [x,y ...]
+ *    New:  directive URL "Menu text" [x,y ...]
+ *     or:  directive URL x,y ... "Menu text"
+ * Map format and menu concept courtesy Joshua Bell, jsbell@acs.ucalgary.ca.
+ *
+ * Mark Cox, mark@ukweb.com, Allow relative URLs even when no base specified
+ */
+
+#include "apr.h"
+#include "apr_strings.h"
+#include "apr_lib.h"
+
+#define APR_WANT_STDIO          /* for sscanf() */
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+
+#include "ap_config.h"
+#include "httpd.h"
+#include "http_config.h"
+#include "http_request.h"
+#include "http_core.h"
+#include "http_protocol.h"
+#include "http_main.h"
+#include "http_log.h"
+#include "util_script.h"
+#include "mod_core.h"
+
+
+#define IMAP_MAGIC_TYPE "application/x-httpd-imap"
+#define MAXVERTS 100
+#define X 0
+#define Y 1
+
+#define IMAP_MENU_DEFAULT "formatted"
+#define IMAP_DEFAULT_DEFAULT "nocontent"
+#define IMAP_BASE_DEFAULT "map"
+
+module AP_MODULE_DECLARE_DATA imagemap_module;
+
+typedef struct {
+    char *imap_menu;
+    char *imap_default;
+    char *imap_base;
+} imap_conf_rec;
+
+static void *create_imap_dir_config(apr_pool_t *p, char *dummy)
+{
+    imap_conf_rec *icr =
+    (imap_conf_rec *) apr_palloc(p, sizeof(imap_conf_rec));
+
+    icr->imap_menu = NULL;
+    icr->imap_default = NULL;
+    icr->imap_base = NULL;
+
+    return icr;
+}
+
+static void *merge_imap_dir_configs(apr_pool_t *p, void *basev, void *addv)
+{
+    imap_conf_rec *new = (imap_conf_rec *) apr_palloc(p, sizeof(imap_conf_rec));
+    imap_conf_rec *base = (imap_conf_rec *) basev;
+    imap_conf_rec *add = (imap_conf_rec *) addv;
+
+    new->imap_menu = add->imap_menu ? add->imap_menu : base->imap_menu;
+    new->imap_default = add->imap_default ? add->imap_default
+                                          : base->imap_default;
+    new->imap_base = add->imap_base ? add->imap_base : base->imap_base;
+
+    return new;
+}
+
+
+static const command_rec imap_cmds[] =
+{
+    AP_INIT_TAKE1("ImapMenu", ap_set_string_slot,
+                  (void *)APR_OFFSETOF(imap_conf_rec, imap_menu), OR_INDEXES,
+                  "the type of menu generated: none, formatted, semiformatted, "
+                  "unformatted"),
+    AP_INIT_TAKE1("ImapDefault", ap_set_string_slot,
+                  (void *)APR_OFFSETOF(imap_conf_rec, imap_default), OR_INDEXES,
+                  "the action taken if no match: error, nocontent, referer, "
+                  "menu, URL"),
+    AP_INIT_TAKE1("ImapBase", ap_set_string_slot,
+                  (void *)APR_OFFSETOF(imap_conf_rec, imap_base), OR_INDEXES,
+                  "the base for all URL's: map, referer, URL (or start of)"),
+    {NULL}
+};
+
+static int pointinrect(const double point[2], double coords[MAXVERTS][2])
+{
+    double max[2], min[2];
+    if (coords[0][X] > coords[1][X]) {
+        max[0] = coords[0][X];
+        min[0] = coords[1][X];
+    }
+    else {
+        max[0] = coords[1][X];
+        min[0] = coords[0][X];
+    }
+
+    if (coords[0][Y] > coords[1][Y]) {
+        max[1] = coords[0][Y];
+        min[1] = coords[1][Y];
+    }
+    else {
+        max[1] = coords[1][Y];
+        min[1] = coords[0][Y];
+    }
+
+    return ((point[X] >= min[0] && point[X] <= max[0]) &&
+            (point[Y] >= min[1] && point[Y] <= max[1]));
+}
+
+static int pointincircle(const double point[2], double coords[MAXVERTS][2])
+{
+    double radius1, radius2;
+
+    radius1 = ((coords[0][Y] - coords[1][Y]) * (coords[0][Y] - coords[1][Y]))
+        + ((coords[0][X] - coords[1][X]) * (coords[0][X] - coords[1][X]));
+
+    radius2 = ((coords[0][Y] - point[Y]) * (coords[0][Y] - point[Y]))
+        + ((coords[0][X] - point[X]) * (coords[0][X] - point[X]));
+
+    return (radius2 <= radius1);
+}
+
+#define fmin(a,b) (((a)>(b))?(b):(a))
+#define fmax(a,b) (((a)>(b))?(a):(b))
+
+static int pointinpoly(const double point[2], double pgon[MAXVERTS][2])
+{
+    int i, numverts, crossings = 0;
+    double x = point[X], y = point[Y];
+
+    for (numverts = 0; numverts < MAXVERTS && pgon[numverts][X] != -1;
+        numverts++) {
+        /* just counting the vertexes */
+    }
+
+    for (i = 0; i < numverts; i++) {
+        double x1=pgon[i][X];
+        double y1=pgon[i][Y];
+        double x2=pgon[(i + 1) % numverts][X];
+        double y2=pgon[(i + 1) % numverts][Y];
+        double d=(y - y1) * (x2 - x1) - (x - x1) * (y2 - y1);
+
+        if ((y1 >= y) != (y2 >= y)) {
+            crossings +=y2 - y1 >= 0 ? d >= 0 : d <= 0;
+        }
+        if (!d && fmin(x1,x2) <= x && x <= fmax(x1,x2)
+            && fmin(y1,y2) <= y && y <= fmax(y1,y2)) {
+            return 1;
+        }
+    }
+    return crossings & 0x01;
+}
+
+
+static int is_closer(const double point[2], double coords[MAXVERTS][2],
+                     double *closest)
+{
+    double dist_squared = ((point[X] - coords[0][X])
+                           * (point[X] - coords[0][X]))
+                          + ((point[Y] - coords[0][Y])
+                             * (point[Y] - coords[0][Y]));
+
+    if (point[X] < 0 || point[Y] < 0) {
+        return (0);          /* don't mess around with negative coordinates */
+    }
+
+    if (*closest < 0 || dist_squared < *closest) {
+        *closest = dist_squared;
+        return (1);          /* if this is the first point or is the closest yet
+                                set 'closest' equal to this distance^2 */
+    }
+
+    return (0);              /* if it's not the first or closest */
+
+}
+
+static double get_x_coord(const char *args)
+{
+    char *endptr;               /* we want it non-null */
+    double x_coord = -1;        /* -1 is returned if no coordinate is given */
+
+    if (args == NULL) {
+        return (-1);            /* in case we aren't passed anything */
+    }
+
+    while (*args && !apr_isdigit(*args) && *args != ',') {
+        args++;                 /* jump to the first digit, but not past
+                                   a comma or end */
+    }
+
+    x_coord = strtod(args, &endptr);
+
+    if (endptr > args) {        /* if a conversion was made */
+        return (x_coord);
+    }
+
+    return (-1);                /* else if no conversion was made,
+                                   or if no args was given */
+}
+
+static double get_y_coord(const char *args)
+{
+    char *endptr;               /* we want it non-null */
+    const char *start_of_y = NULL;
+    double y_coord = -1;        /* -1 is returned on error */
+
+    if (args == NULL) {
+        return (-1);            /* in case we aren't passed anything */
+    }
+
+    start_of_y = ap_strchr_c(args, ',');     /* the comma */
+
+    if (start_of_y) {
+
+        start_of_y++;           /* start looking at the character after
+                                   the comma */
+
+        while (*start_of_y && !apr_isdigit(*start_of_y)) {
+            start_of_y++;       /* jump to the first digit, but not
+                                   past the end */
+        }
+
+        y_coord = strtod(start_of_y, &endptr);
+
+        if (endptr > start_of_y) {
+            return (y_coord);
+        }
+    }
+
+    return (-1);                /* if no conversion was made, or
+                                   no comma was found in args */
+}
+
+
+/* See if string has a "quoted part", and if so set *quoted_part to
+ * the first character of the quoted part, then hammer a \0 onto the
+ * trailing quote, and set *string to point at the first character
+ * past the second quote.
+ *
+ * Otherwise set *quoted_part to NULL, and leave *string alone.
+ */
+static void read_quoted(char **string, char **quoted_part)
+{
+    char *strp = *string;
+
+    /* assume there's no quoted part */
+    *quoted_part = NULL;
+
+    while (apr_isspace(*strp)) {
+        strp++;                 /* go along string until non-whitespace */
+    }
+
+    if (*strp == '"') {         /* if that character is a double quote */
+        strp++;                 /* step over it */
+        *quoted_part = strp;    /* note where the quoted part begins */
+
+        while (*strp && *strp != '"') {
+            ++strp;             /* skip the quoted portion */
+        }
+
+        *strp = '\0';           /* end the string with a NUL */
+
+        strp++;                 /* step over the last double quote */
+        *string = strp;
+    }
+}
+
+/*
+ * returns the mapped URL or NULL.
+ */
+static const char *imap_url(request_rec *r, const char *base, const char *value)
+{
+/* translates a value into a URL. */
+    int slen, clen;
+    char *string_pos = NULL;
+    const char *string_pos_const = NULL;
+    char *directory = NULL;
+    const char *referer = NULL;
+    char *my_base;
+
+    if (!strcasecmp(value, "map") || !strcasecmp(value, "menu")) {
+        return ap_construct_url(r->pool, r->uri, r);
+    }
+
+    if (!strcasecmp(value, "nocontent") || !strcasecmp(value, "error")) {
+        return apr_pstrdup(r->pool, value);      /* these are handled elsewhere,
+                                                so just copy them */
+    }
+
+    if (!strcasecmp(value, "referer")) {
+        referer = apr_table_get(r->headers_in, "Referer");
+        if (referer && *referer) {
+            return referer;
+        }
+        else {
+            /* XXX:  This used to do *value = '\0'; ... which is totally bogus
+             * because it hammers the passed in value, which can be a string
+             * constant, or part of a config, or whatever.  Total garbage.
+             * This works around that without changing the rest of this
+             * code much
+             */
+            value = "";      /* if 'referer' but no referring page,
+                                null the value */
+        }
+    }
+
+    string_pos_const = value;
+    while (apr_isalpha(*string_pos_const)) {
+        string_pos_const++;           /* go along the URL from the map
+                                         until a non-letter */
+    }
+    if (*string_pos_const == ':') {
+        /* if letters and then a colon (like http:) */
+        /* it's an absolute URL, so use it! */
+        return apr_pstrdup(r->pool, value);
+    }
+
+    if (!base || !*base) {
+        if (value && *value) {
+            return apr_pstrdup(r->pool, value); /* no base: use what is given */
+        }
+        /* no base, no value: pick a simple default */
+        return ap_construct_url(r->pool, "/", r);
+    }
+
+    /* must be a relative URL to be combined with base */
+    if (ap_strchr_c(base, '/') == NULL && (!strncmp(value, "../", 3)
+        || !strcmp(value, ".."))) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00677)
+                    "invalid base directive in map file: %s", r->uri);
+        return NULL;
+    }
+    my_base = apr_pstrdup(r->pool, base);
+    string_pos = my_base;
+    while (*string_pos) {
+        if (*string_pos == '/' && *(string_pos + 1) == '/') {
+            string_pos += 2;    /* if there are two slashes, jump over them */
+            continue;
+        }
+        if (*string_pos == '/') {       /* the first single slash */
+            if (value[0] == '/') {
+                *string_pos = '\0';
+            }                   /* if the URL from the map starts from root,
+                                   end the base URL string at the first single
+                                   slash */
+            else {
+                directory = string_pos;         /* save the start of
+                                                   the directory portion */
+
+                string_pos = strrchr(string_pos, '/');  /* now reuse
+                                                           string_pos */
+                string_pos++;   /* step over that last slash */
+                *string_pos = '\0';
+            }                   /* but if the map url is relative, leave the
+                                   slash on the base (if there is one) */
+            break;
+        }
+        string_pos++;           /* until we get to the end of my_base without
+                                   finding a slash by itself */
+    }
+
+    while (!strncmp(value, "../", 3) || !strcmp(value, "..")) {
+
+        if (directory && (slen = strlen(directory))) {
+
+            /* for each '..',  knock a directory off the end
+               by ending the string right at the last slash.
+               But only consider the directory portion: don't eat
+               into the server name.  And only try if a directory
+               portion was found */
+
+            clen = slen - 1;
+
+            while ((slen - clen) == 1) {
+
+                if ((string_pos = strrchr(directory, '/'))) {
+                    *string_pos = '\0';
+                }
+                clen = strlen(directory);
+                if (clen == 0) {
+                    break;
+                }
+            }
+
+            value += 2;         /* jump over the '..' that we found in the
+                                   value */
+        }
+        else if (directory) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00678)
+                        "invalid directory name in map file: %s", r->uri);
+            return NULL;
+        }
+
+        if (!strncmp(value, "/../", 4) || !strcmp(value, "/..")) {
+            value++;            /* step over the '/' if there are more '..'
+                                   to do.  This way, we leave the starting
+                                   '/' on value after the last '..', but get
+                                   rid of it otherwise */
+        }
+
+    }                           /* by this point, value does not start
+                                   with '..' */
+
+    if (value && *value) {
+        return apr_pstrcat(r->pool, my_base, value, NULL);
+    }
+    return my_base;
+}
+
+static int imap_reply(request_rec *r, const char *redirect)
+{
+    if (!strcasecmp(redirect, "error")) {
+        /* they actually requested an error! */
+        return HTTP_INTERNAL_SERVER_ERROR;
+    }
+    if (!strcasecmp(redirect, "nocontent")) {
+        /* tell the client to keep the page it has */
+        return HTTP_NO_CONTENT;
+    }
+    if (redirect && *redirect) {
+        /* must be a URL, so redirect to it */
+        apr_table_setn(r->headers_out, "Location", redirect);
+        return HTTP_MOVED_TEMPORARILY;
+    }
+    return HTTP_INTERNAL_SERVER_ERROR;
+}
+
+static void menu_header(request_rec *r, char *menu)
+{
+    ap_set_content_type(r, "text/html; charset=ISO-8859-1");
+
+    ap_rvputs(r, DOCTYPE_HTML_3_2, "<html><head>\n<title>Menu for ",
+              ap_escape_html(r->pool, r->uri),
+              "</title>\n</head><body>\n", NULL);
+
+    if (!strcasecmp(menu, "formatted")) {
+        ap_rvputs(r, "<h1>Menu for ",
+                  ap_escape_html(r->pool, r->uri),
+                  "</h1>\n<hr />\n\n", NULL);
+    }
+}
+
+static void menu_blank(request_rec *r, char *menu)
+{
+    if (!strcasecmp(menu, "formatted")) {
+        ap_rputs("\n", r);
+    }
+    else if (!strcasecmp(menu, "semiformatted")) {
+        ap_rputs("<br />\n", r);
+    }
+    else if (!strcasecmp(menu, "unformatted")) {
+        ap_rputs("\n", r);
+    }
+}
+
+static void menu_comment(request_rec *r, char *menu, char *comment)
+{
+    /* comments are ignored in the 'formatted' form */
+    if (!strcasecmp(menu, "formatted")) {
+        ap_rputs("\n", r);         /* print just a newline if 'formatted' */
+    }
+    else if (!strcasecmp(menu, "semiformatted") && *comment) {
+        ap_rvputs(r, comment, "\n", NULL);
+    }
+    else if (!strcasecmp(menu, "unformatted") && *comment) {
+        ap_rvputs(r, comment, "\n", NULL);
+    }
+}
+
+static void menu_default(request_rec *r, const char *menu, const char *href, const char *text)
+{
+    char *ehref, *etext;
+    if (!strcasecmp(href, "error") || !strcasecmp(href, "nocontent")) {
+        return;                 /* don't print such lines, these aren't
+                                   really href's */
+    }
+
+    ehref = ap_escape_uri(r->pool, href);
+    etext = ap_escape_html(r->pool, text);
+
+    if (!strcasecmp(menu, "formatted")) {
+        ap_rvputs(r, "<pre>(Default) <a href=\"", ehref, "\">", etext,
+                     "</a></pre>\n", NULL);
+    }
+    else if (!strcasecmp(menu, "semiformatted")) {
+        ap_rvputs(r, "<pre>(Default) <a href=\"", ehref, "\">", etext,
+               "</a></pre>\n", NULL);
+    }
+    else if (!strcasecmp(menu, "unformatted")) {
+        ap_rvputs(r, "<a href=\"", ehref, "\">", etext, "</a>", NULL);
+    }
+}
+
+static void menu_directive(request_rec *r, const char *menu, const char *href, const char *text)
+{
+    char *ehref, *etext;
+    if (!strcasecmp(href, "error") || !strcasecmp(href, "nocontent")) {
+        return;                 /* don't print such lines, as this isn't
+                                   really an href */
+    }
+
+    ehref = ap_escape_uri(r->pool, href);
+    etext = ap_escape_html(r->pool, text);
+
+    if (!strcasecmp(menu, "formatted")) {
+        ap_rvputs(r, "<pre>          <a href=\"", ehref, "\">", etext,
+               "</a></pre>\n", NULL);
+    }
+    else if (!strcasecmp(menu, "semiformatted")) {
+        ap_rvputs(r, "<pre>          <a href=\"", ehref, "\">", etext,
+               "</a></pre>\n", NULL);
+    }
+    else if (!strcasecmp(menu, "unformatted")) {
+        ap_rvputs(r, "<a href=\"", ehref, "\">", etext, "</a>", NULL);
+    }
+}
+
+static void menu_footer(request_rec *r)
+{
+    ap_rputs("\n\n</body>\n</html>\n", r);         /* finish the menu */
+}
+
+static int imap_handler_internal(request_rec *r)
+{
+    char input[MAX_STRING_LEN];
+    char *directive;
+    char *value;
+    char *href_text;
+    const char *base;
+    const char *redirect;
+    const char *mapdflt;
+    char *closest = NULL;
+    double closest_yet = -1;
+    apr_status_t status;
+
+    double testpoint[2];
+    double pointarray[MAXVERTS + 1][2];
+    int vertex;
+
+    char *string_pos;
+    int showmenu = 0;
+
+    imap_conf_rec *icr;
+
+    char *imap_menu;
+    char *imap_default;
+    char *imap_base;
+
+    ap_configfile_t *imap;
+
+    icr = ap_get_module_config(r->per_dir_config, &imagemap_module);
+
+    imap_menu = icr->imap_menu ? icr->imap_menu : IMAP_MENU_DEFAULT;
+    imap_default = icr->imap_default
+      ?  icr->imap_default : IMAP_DEFAULT_DEFAULT;
+    imap_base = icr->imap_base ? icr->imap_base : IMAP_BASE_DEFAULT;
+
+    status = ap_pcfg_openfile(&imap, r->pool, r->filename);
+
+    if (status != APR_SUCCESS) {
+        return HTTP_NOT_FOUND;
+    }
+
+    base = imap_url(r, NULL, imap_base);         /* set base according
+                                                    to default */
+    if (!base) {
+        return HTTP_INTERNAL_SERVER_ERROR;
+    }
+    mapdflt = imap_url(r, NULL, imap_default);   /* and default to
+                                                    global default */
+    if (!mapdflt) {
+        return HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    testpoint[X] = get_x_coord(r->args);
+    testpoint[Y] = get_y_coord(r->args);
+
+    if ((testpoint[X] == -1 || testpoint[Y] == -1) ||
+        (testpoint[X] == 0 && testpoint[Y] == 0)) {
+        /* if either is -1 or if both are zero (new Lynx) */
+        /* we don't have valid coordinates */
+        testpoint[X] = -1;
+        testpoint[Y] = -1;
+        if (strncasecmp(imap_menu, "none", 2)) {
+            showmenu = 1;       /* show the menu _unless_ ImapMenu is
+                                   'none' or 'no' */
+        }
+    }
+
+    if (showmenu) {             /* send start of imagemap menu if
+                                   we're going to */
+        menu_header(r, imap_menu);
+    }
+
+    while (!ap_cfg_getline(input, sizeof(input), imap)) {
+        if (!input[0]) {
+            if (showmenu) {
+                menu_blank(r, imap_menu);
+            }
+            continue;
+        }
+
+        if (input[0] == '#') {
+            if (showmenu) {
+                menu_comment(r, imap_menu, input + 1);
+            }
+            continue;
+        }                       /* blank lines and comments are ignored
+                                   if we aren't printing a menu */
+
+        /* find the first two space delimited fields, recall that
+         * ap_cfg_getline has removed leading/trailing whitespace.
+         *
+         * note that we're tokenizing as we go... if we were to use the
+         * ap_getword() class of functions we would end up allocating extra
+         * memory for every line of the map file
+         */
+        string_pos = input;
+        if (!*string_pos) {   /* need at least two fields */
+            goto need_2_fields;
+        }
+
+        directive = string_pos;
+        while (*string_pos && !apr_isspace(*string_pos)) {   /* past directive */
+            ++string_pos;
+        }
+        if (!*string_pos) {   /* need at least two fields */
+            goto need_2_fields;
+        }
+        *string_pos++ = '\0';
+
+        if (!*string_pos) {   /* need at least two fields */
+            goto need_2_fields;
+        }
+        while (apr_isspace(*string_pos)) { /* past whitespace */
+            ++string_pos;
+        }
+
+        value = string_pos;
+        while (*string_pos && !apr_isspace(*string_pos)) {   /* past value */
+            ++string_pos;
+        }
+        if (apr_isspace(*string_pos)) {
+            *string_pos++ = '\0';
+        }
+        else {
+            /* end of input, don't advance past it */
+            *string_pos = '\0';
+        }
+
+        if (!strncasecmp(directive, "base", 4)) {       /* base, base_uri */
+            base = imap_url(r, NULL, value);
+            if (!base) {
+                goto menu_bail;
+            }
+            continue;           /* base is never printed to a menu */
+        }
+
+        read_quoted(&string_pos, &href_text);
+
+        if (!strcasecmp(directive, "default")) {        /* default */
+            mapdflt = imap_url(r, NULL, value);
+            if (!mapdflt) {
+                goto menu_bail;
+            }
+            if (showmenu) {     /* print the default if there's a menu */
+                redirect = imap_url(r, base, mapdflt);
+                if (!redirect) {
+                    goto menu_bail;
+                }
+                menu_default(r, imap_menu, redirect,
+                             href_text ? href_text : mapdflt);
+            }
+            continue;
+        }
+
+        vertex = 0;
+        while (vertex < MAXVERTS &&
+               sscanf(string_pos, "%lf%*[, ]%lf",
+                      &pointarray[vertex][X], &pointarray[vertex][Y]) == 2) {
+            /* Now skip what we just read... we can't use ANSIism %n */
+            while (apr_isspace(*string_pos)) {      /* past whitespace */
+                string_pos++;
+            }
+            while (apr_isdigit(*string_pos)) {      /* and the 1st number */
+                string_pos++;
+            }
+            string_pos++;       /* skip the ',' */
+            while (apr_isspace(*string_pos)) {      /* past any more whitespace */
+                string_pos++;
+            }
+            while (apr_isdigit(*string_pos)) {      /* 2nd number */
+                string_pos++;
+            }
+            vertex++;
+        }                       /* so long as there are more vertices to
+                                   read, and we have room, read them in.
+                                   We start where we left off of the last
+                                   sscanf, not at the beginning. */
+
+        pointarray[vertex][X] = -1;     /* signals the end of vertices */
+
+        if (showmenu) {
+            if (!href_text) {
+                read_quoted(&string_pos, &href_text);     /* href text could
+                                                             be here instead */
+            }
+            redirect = imap_url(r, base, value);
+            if (!redirect) {
+                goto menu_bail;
+            }
+            menu_directive(r, imap_menu, redirect,
+                           href_text ? href_text : value);
+            continue;
+        }
+        /* note that we don't make it past here if we are making a menu */
+
+        if (testpoint[X] == -1 || pointarray[0][X] == -1) {
+            continue;           /* don't try the following tests if testpoints
+                                   are invalid, or if there are no
+                                   coordinates */
+        }
+
+        if (!strcasecmp(directive, "poly")) {   /* poly */
+
+            if (pointinpoly(testpoint, pointarray)) {
+                ap_cfg_closefile(imap);
+                redirect = imap_url(r, base, value);
+                if (!redirect) {
+                    return HTTP_INTERNAL_SERVER_ERROR;
+                }
+                return (imap_reply(r, redirect));
+            }
+            continue;
+        }
+
+        if (!strcasecmp(directive, "circle")) {         /* circle */
+
+            if (pointincircle(testpoint, pointarray)) {
+                ap_cfg_closefile(imap);
+                redirect = imap_url(r, base, value);
+                if (!redirect) {
+                    return HTTP_INTERNAL_SERVER_ERROR;
+                }
+                return (imap_reply(r, redirect));
+            }
+            continue;
+        }
+
+        if (!strcasecmp(directive, "rect")) {   /* rect */
+
+            if (pointinrect(testpoint, pointarray)) {
+                ap_cfg_closefile(imap);
+                redirect = imap_url(r, base, value);
+                if (!redirect) {
+                    return HTTP_INTERNAL_SERVER_ERROR;
+                }
+                return (imap_reply(r, redirect));
+            }
+            continue;
+        }
+
+        if (!strcasecmp(directive, "point")) {  /* point */
+
+            if (is_closer(testpoint, pointarray, &closest_yet)) {
+                closest = apr_pstrdup(r->pool, value);
+            }
+
+            continue;
+        }                       /* move on to next line whether it's
+                                   closest or not */
+
+    }                           /* nothing matched, so we get another line! */
+
+    ap_cfg_closefile(imap);        /* we are done with the map file; close it */
+
+    if (showmenu) {
+        menu_footer(r);         /* finish the menu and we are done */
+        return OK;
+    }
+
+    if (closest) {             /* if a 'point' directive has been seen */
+        redirect = imap_url(r, base, closest);
+        if (!redirect) {
+            return HTTP_INTERNAL_SERVER_ERROR;
+        }
+        return (imap_reply(r, redirect));
+    }
+
+    if (mapdflt) {             /* a default should be defined, even if
+                                  only 'nocontent' */
+        redirect = imap_url(r, base, mapdflt);
+        if (!redirect) {
+            return HTTP_INTERNAL_SERVER_ERROR;
+        }
+        return (imap_reply(r, redirect));
+    }
+
+    return HTTP_INTERNAL_SERVER_ERROR;        /* If we make it this far,
+                                                 we failed. They lose! */
+
+need_2_fields:
+    ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00679)
+                "map file %s, line %d syntax error: requires at "
+                "least two fields", r->uri, imap->line_number);
+    /* fall through */
+menu_bail:
+    ap_cfg_closefile(imap);
+    if (showmenu) {
+        /* There's not much else we can do ... we've already sent the headers
+         * to the client.
+         */
+        ap_rputs("\n\n[an internal server error occured]\n", r);
+        menu_footer(r);
+        return OK;
+    }
+    return HTTP_INTERNAL_SERVER_ERROR;
+}
+
+static int imap_handler(request_rec *r)
+{
+    /* Optimization: skip the allocation of large local variables on the
+     * stack (in imap_handler_internal()) on requests that aren't using
+     * imagemaps
+     */
+    if (r->method_number != M_GET || (strcmp(r->handler,IMAP_MAGIC_TYPE)
+                                      && strcmp(r->handler, "imap-file"))) {
+        return DECLINED;
+    }
+    else {
+        return imap_handler_internal(r);
+    }
+}
+
+static void register_hooks(apr_pool_t *p)
+{
+    ap_hook_handler(imap_handler,NULL,NULL,APR_HOOK_MIDDLE);
+}
+
+AP_DECLARE_MODULE(imagemap) =
+{
+    STANDARD20_MODULE_STUFF,
+    create_imap_dir_config,     /* dir config creater */
+    merge_imap_dir_configs,     /* dir merger --- default is to override */
+    NULL,                       /* server config */
+    NULL,                       /* merge server config */
+    imap_cmds,                  /* command apr_table_t */
+    register_hooks              /* register hooks */
+};