home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 25 / CDROM25.iso / Share / linux / apache / contrib / modules / mod_phantomimap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-11  |  31.4 KB  |  1,048 lines
  1. /* ====================================================================
  2.  * Copyright (c) 1995-1997 The Apache Group.  All rights reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer. 
  10.  *
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in
  13.  *    the documentation and/or other materials provided with the
  14.  *    distribution.
  15.  *
  16.  * 3. All advertising materials mentioning features or use of this
  17.  *    software must display the following acknowledgment:
  18.  *    "This product includes software developed by the Apache Group
  19.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  20.  *
  21.  * 4. The names "Apache Server" and "Apache Group" must not be used to
  22.  *    endorse or promote products derived from this software without
  23.  *    prior written permission.
  24.  *
  25.  * 5. Redistributions of any form whatsoever must retain the following
  26.  *    acknowledgment:
  27.  *    "This product includes software developed by the Apache Group
  28.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  29.  *
  30.  * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
  31.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  33.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
  34.  * IT'S CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  35.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  36.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  37.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  40.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  41.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  42.  * ====================================================================
  43.  *
  44.  * This software consists of voluntary contributions made by many
  45.  * individuals on behalf of the Apache Group and was originally based
  46.  * on public domain software written at the National Center for
  47.  * Supercomputing Applications, University of Illinois, Urbana-Champaign.
  48.  * For more information on the Apache Group and the Apache HTTP server
  49.  * project, please see <http://www.apache.org/>.
  50.  *
  51.  */
  52.  
  53. /*
  54.  * This imagemap module started as a port of the original imagemap.c
  55.  * written by Rob McCool (11/13/93 robm@ncsa.uiuc.edu).
  56.  * This version includes the mapping algorithms found in version 1.3
  57.  * of imagemap.c.
  58.  *
  59.  * Contributors to this code include:
  60.  *
  61.  * Kevin Hughes, kevinh@pulua.hcc.hawaii.edu
  62.  *
  63.  * Eric Haines, erich@eye.com
  64.  * "macmartinized" polygon code copyright 1992 by Eric Haines, erich@eye.com
  65.  *
  66.  * Randy Terbush, randy@zyzzyva.com
  67.  * port to Apache module format, "base_uri" and support for relative URLs
  68.  * 
  69.  * James H. Cloos, Jr., cloos@jhcloos.com
  70.  * Added point datatype, using code in NCSA's version 1.8 imagemap.c
  71.  * program, as distributed with version 1.4.1 of their server.
  72.  * The point code is originally added by Craig Milo Rogers, Rogers@ISI.Edu
  73.  *
  74.  * Nathan Kurz, nate@tripod.com
  75.  * Rewrite/reorganization.  New handling of default, base and relative URLs.  
  76.  * New Configuration directives:
  77.  *    ImapMenu {none, formatted, semiformatted, unformatted}
  78.  *    ImapDefault {error, nocontent, referer, menu, URL}
  79.  *    ImapBase {map, referer, URL}
  80.  * Support for creating non-graphical menu added.  (backwards compatible):
  81.  *    Old:  directive URL [x,y ...]
  82.  *    New:  directive URL "Menu text" [x,y ...]
  83.  *     or:  directive URL x,y ... "Menu text"
  84.  * Map format and menu concept courtesy Joshua Bell, jsbell@acs.ucalgary.ca.
  85.  *
  86.  * Mark Cox, mark@ukweb.com, Allow relative URLs even when no base specified
  87.  *
  88.  * Tim Baverstock, warwick@mmm.co.uk, Interpreted <AREA> tags to .map format.
  89.  *  Added phantom .map file support and <MAP NAME=""> support.
  90.  *  Refer to index.html.map to read index.html's first <MAP></MAP> element.
  91.  *  Refer to index.html.something.map to read <MAP NAME="something"></MAP>
  92.  */
  93.  
  94. #include "httpd.h"
  95. #include "http_config.h"
  96. #include "http_request.h"
  97. #include "http_core.h"
  98. #include "http_protocol.h"
  99. #include "http_main.h"
  100. #include "http_log.h"
  101. #include "util_script.h"
  102.  
  103. #define IMAP_MAGIC_TYPE "application/x-httpd-imap"
  104. #define LARGEBUF 500
  105. #define SMALLBUF 256
  106. #define MAXVERTS 100
  107. #define X 0
  108. #define Y 1
  109.  
  110. #define IMAP_MENU_DEFAULT "formatted"
  111. #define IMAP_DEFAULT_DEFAULT "nocontent"
  112. #define IMAP_BASE_DEFAULT "map"
  113.  
  114. #ifdef SUNOS4
  115. double strtod();   /* SunOS needed this */
  116. #endif
  117.  
  118. module imap_module;
  119.  
  120. typedef struct { 
  121.   char *imap_menu;
  122.   char *imap_default;
  123.   char *imap_base;
  124. } imap_conf_rec;
  125.  
  126. void *create_imap_dir_config (pool *p, char *dummy) { 
  127.   imap_conf_rec *icr = 
  128.     (imap_conf_rec *)palloc(p, sizeof(imap_conf_rec));
  129.  
  130.   icr->imap_menu = NULL;
  131.   icr->imap_default = NULL;
  132.   icr->imap_base = NULL;
  133.  
  134.   return icr;
  135. }
  136.  
  137. void *merge_imap_dir_configs (pool *p, void *basev, void *addv)
  138. {
  139.   imap_conf_rec *new=(imap_conf_rec *)pcalloc (p, sizeof(imap_conf_rec));
  140.   imap_conf_rec *base = (imap_conf_rec *)basev;
  141.   imap_conf_rec *add = (imap_conf_rec *)addv;
  142.  
  143.   new->imap_menu = add->imap_menu ? add->imap_menu : base->imap_menu;
  144.   new->imap_default=add->imap_default ? add->imap_default : base->imap_default;
  145.   new->imap_base =add-> imap_base ? add->imap_base : base->imap_base;
  146.  
  147.   return new;
  148. }
  149.  
  150.  
  151. command_rec imap_cmds[] = {
  152. { "ImapMenu", set_string_slot, 
  153.     (void*)XtOffsetOf(imap_conf_rec, imap_menu), OR_INDEXES, TAKE1,
  154.     "the type of menu generated: none, formatted, semiformatted, unformatted"},
  155. { "ImapDefault", set_string_slot, 
  156.     (void*)XtOffsetOf(imap_conf_rec, imap_default), OR_INDEXES, TAKE1,
  157.     "the action taken if no match: error, nocontent, referer, menu, URL" },
  158. { "ImapBase", set_string_slot, 
  159.     (void*)XtOffsetOf(imap_conf_rec, imap_base), OR_INDEXES, TAKE1,
  160.     "the base for all URL's: map, referer, URL (or start of)" },
  161. { NULL }
  162. };
  163.  
  164. int pointinrect(double point[2], double coords[MAXVERTS][2])
  165. {
  166.     double max[2], min[2];
  167.     if (coords[0][X] > coords[1][X]) {
  168.         max[0] = coords[0][X];
  169.         min[0] = coords[1][X];
  170.     } else {
  171.         max[0] = coords[1][X];
  172.         min[0] = coords[0][X];
  173.     }
  174.  
  175.     if (coords[0][Y] > coords[1][Y]) {
  176.         max[1] = coords[0][Y];
  177.         min[1] = coords[1][Y];
  178.     } else {
  179.         max[1] = coords[1][Y];
  180.         min[1] = coords[0][Y];
  181.     }
  182.  
  183.     return ((point[X] >= min[0] && point[X] <= max[0]) &&
  184.         (point[Y] >= min[1] && point[Y] <= max[1]));
  185. }
  186.  
  187. int pointincircle(double point[2], double coords[MAXVERTS][2])
  188. {
  189.     int radius1, radius2;
  190.  
  191.     radius1 = ((coords[0][Y] - coords[1][Y]) * (coords[0][Y] - coords[1][Y]))
  192.     + ((coords[0][X] - coords[1][X]) * (coords[0][X] - coords[1][X]));
  193.     
  194.     radius2 = ((coords[0][Y] - point[Y]) * (coords[0][Y] - point[Y]))
  195.     + ((coords[0][X] - point[X]) * (coords[0][X] - point[X]));
  196.  
  197.     return (radius2 <= radius1);
  198. }
  199.  
  200. int pointinpoly(double point[2], double pgon[MAXVERTS][2])
  201. {
  202.     int i, numverts, inside_flag, xflag0;
  203.     int crossings;
  204.     double *p, *stop;
  205.     double tx, ty, y;
  206.  
  207.     for (i = 0; pgon[i][X] != -1 && i < MAXVERTS; i++);
  208.  
  209.     numverts = i;
  210.     crossings = 0;
  211.  
  212.     tx = point[X];
  213.     ty = point[Y];
  214.     y = pgon[numverts - 1][Y];
  215.  
  216.     p = (double *) pgon + 1;
  217.     if ((y >= ty) != (*p >= ty)) {
  218.  
  219.     if ((xflag0 = (pgon[numverts - 1][X] >= tx)) == (*(double *) pgon >= tx)) {
  220.         if (xflag0)
  221.         crossings++;
  222.     }
  223.     else {
  224.         crossings += (pgon[numverts - 1][X] - (y - ty) *
  225.               (*(double *) pgon - pgon[numverts - 1][X]) /
  226.               (*p - y)) >= tx;
  227.     }
  228.     }
  229.  
  230.     stop = pgon[numverts];
  231.  
  232.     for (y = *p, p += 2; p < stop; y = *p, p += 2) {
  233.     
  234.     if (y >= ty) {
  235.         
  236.         while ((p < stop) && (*p >= ty))
  237.         p += 2;
  238.         
  239.         if (p >= stop)
  240.         break;
  241.         if ((xflag0 = (*(p - 3) >= tx)) == (*(p - 1) >= tx)) {
  242.         
  243.         if (xflag0)
  244.             crossings++;
  245.         }
  246.         else {
  247.         crossings += (*(p - 3) - (*(p - 2) - ty) *
  248.                   (*(p - 1) - *(p - 3)) / (*p - *(p - 2))) >= tx;
  249.         }
  250.     }
  251.     else {
  252.         while ((p < stop) && (*p < ty))
  253.         p += 2;
  254.  
  255.         if (p >= stop)
  256.         break;
  257.  
  258.         if ((xflag0 = (*(p - 3) >= tx)) == (*(p - 1) >= tx)) {
  259.         if (xflag0)
  260.             crossings++;
  261.         }
  262.         else {
  263.         crossings += (*(p - 3) - (*(p - 2) - ty) *
  264.                   (*(p - 1) - *(p - 3)) / (*p - *(p - 2))) >= tx;
  265.         }
  266.     }
  267.     }
  268.  
  269.     inside_flag = crossings & 0x01;
  270.     return (inside_flag);
  271. }
  272.  
  273.  
  274. int is_closer(double point[2], double coords[MAXVERTS][2], double *closest)
  275. {
  276.   double dist_squared =((point[X] - coords[0][X]) * (point[X] - coords[0][X]))
  277.          + ((point[Y] - coords[0][Y]) * (point[Y] - coords[0][Y]));
  278.  
  279.   if (point[X] < 0 || point[Y] < 0 ) 
  280.     return(0);          /* don't mess around with negative coordinates */
  281.  
  282.   if ( *closest < 0 || dist_squared < *closest ) {
  283.     *closest = dist_squared;
  284.     return(1);         /* if this is the first point or is the closest yet
  285.               set 'closest' equal to this distance^2 */
  286.   }
  287.   
  288.   return(0);           /* if it's not the first or closest */
  289.  
  290. }
  291.  
  292. double get_x_coord(char *args) 
  293. {
  294.   char *endptr;           /* we want it non-null */
  295.   double x_coord = -1;    /* -1 is returned if no coordinate is given */
  296.  
  297.   if (args == NULL)
  298.     return(-1);           /* in case we aren't passed anything */
  299.  
  300.   while( *args && !isdigit(*args) && *args != ',') 
  301.     args++;   /* jump to the first digit, but not past a comma or end */
  302.  
  303.   x_coord = strtod(args, &endptr);
  304.  
  305.   if (endptr > args)   /* if a conversion was made */
  306.     return(x_coord); 
  307.  
  308.   return(-1);  /* else if no conversion was made, or if no args was given */
  309. }
  310.  
  311. double get_y_coord(char *args) 
  312. {
  313.   char *endptr;        /* we want it non-null */
  314.   char *start_of_y = NULL;
  315.   double y_coord = -1;    /* -1 is returned on error */
  316.  
  317.   if (args == NULL)
  318.     return(-1);           /* in case we aren't passed anything */
  319.  
  320.   start_of_y = strchr(args, ',');  /* the comma */
  321.  
  322.   if (start_of_y) {
  323.     
  324.     start_of_y++;    /* start looking at the character after the comma */
  325.  
  326.     while( *start_of_y && !isdigit(*start_of_y))  
  327.       start_of_y++;  /* jump to the first digit, but not past the end */
  328.  
  329.     y_coord = strtod(start_of_y, &endptr);
  330.  
  331.     if (endptr > start_of_y) 
  332.       return(y_coord); 
  333.   }
  334.   
  335.   return(-1);   /* if no conversion was made, or no comma was found in args */
  336. }
  337.   
  338.  
  339. int read_quoted(char *string, char *quoted_part)
  340. { 
  341.   char *starting_pos = string;
  342.   
  343.   while ( isspace(*string) )
  344.     string++;    /* go along string until non-whitespace */
  345.  
  346.   if ( *string == '"' ) { /* if that character is a double quote */
  347.  
  348.     string++;  /* step over it */
  349.  
  350.     while ( *string && *string != '"' ) {
  351.       *quoted_part++ = *string++;  /* copy the quoted portion */
  352.     }
  353.  
  354.     *quoted_part = '\0';  /* end the string with a SNUL */
  355.     
  356.     string++;  /* step over the last double quote */
  357.   }
  358.  
  359.   return(string - starting_pos); /* return the total characters read */
  360. }
  361.  
  362. /*
  363.  * url needs to point to a string with at least SMALLBUF memory allocated
  364.  */
  365. void imap_url(request_rec *r, char *base, char *value, char *url) 
  366. {
  367. /* translates a value into a URL. */
  368.   int slen, clen;
  369.   char *string_pos = NULL;
  370.   char *directory = NULL;
  371.   char *referer = NULL;
  372.   char my_base[SMALLBUF] = {'\0'};
  373.  
  374.   if ( ! strcasecmp(value, "map" ) || ! strcasecmp(value, "menu") ) {
  375.     if (r->server->port == DEFAULT_PORT ) { 
  376.       ap_snprintf(url, SMALLBUF,
  377.         "http://%s%s", r->server->server_hostname, r->uri);
  378.     }
  379.     else {
  380.       ap_snprintf(url, SMALLBUF, "http://%s:%d%s", r->server->server_hostname,
  381.           r->server->port, r->uri);      
  382.     }
  383.     return;  
  384.   }
  385.  
  386.   if ( ! strcasecmp(value, "nocontent") || ! strcasecmp(value, "error") ) {
  387.     strncpy(url, value, SMALLBUF-1);
  388.     url[SMALLBUF-1] = '\0';
  389.     return;    /* these are handled elsewhere, so just copy them */
  390.   }
  391.  
  392.   if ( ! strcasecmp(value, "referer" ) ) {
  393.     referer = table_get(r->headers_in, "Referer");
  394.     if ( referer && *referer ) {
  395.       strncpy(url, referer, SMALLBUF-1);
  396.       url[SMALLBUF-1] = '\0';
  397.       return;
  398.     }
  399.     else {
  400.       *value = '\0';  /* if 'referer' but no referring page, null the value */
  401.     }                 
  402.   }         
  403.  
  404.   string_pos = value;
  405.   while ( isalpha(*string_pos) )
  406.     string_pos++;    /* go along the URL from the map until a non-letter */
  407.   if ( *string_pos == ':' ) { 
  408.     strncpy(url, value, SMALLBUF-1);        /* if letters and then a colon (like http:) */
  409.     url[SMALLBUF-1] = '\0';
  410.     return;                    /* it's an absolute URL, so use it! */
  411.   }
  412.  
  413.   if ( ! base || ! *base ) {
  414.     if ( value && *value ) {  
  415.       strncpy(url, value, SMALLBUF-1);   /* no base: use what is given */
  416.       url[SMALLBUF-1] = '\0';
  417.     }         
  418.     else {                  
  419.       if (r->server->port == DEFAULT_PORT ) {  
  420.     ap_snprintf(url, SMALLBUF, "http://%s/", r->server->server_hostname);
  421.       }            
  422.       if (r->server->port != DEFAULT_PORT ) {
  423.     ap_snprintf(url, SMALLBUF, "http://%s:%d/",
  424.         r->server->server_hostname, r->server->port);
  425.       }                     /* no base, no value: pick a simple default */
  426.     }
  427.     return;  
  428.   }
  429.  
  430.   strncpy(my_base, base, sizeof(my_base)-1);  /* must be a relative URL to be combined with base */
  431.   my_base[sizeof(my_base)-1] = '\0';
  432.   if (strchr(my_base, '/') == NULL && (!strncmp(value, "../", 3) || !strcmp(value, "..")) ) {
  433.     url[0] = '\0';
  434.     log_reason("invalid base directive in map file", r->uri, r);
  435.     return;
  436.   }
  437.   string_pos = my_base; 
  438.   while (*string_pos) {  
  439.     if (*string_pos == '/' && *(string_pos+1) == '/') {
  440.       string_pos += 2;  /* if there are two slashes, jump over them */
  441.       continue;
  442.     }
  443.     if (*string_pos == '/') {  /* the first single slash */
  444.     if ( value[0] == '/' ) {
  445.       *string_pos = '\0';  
  446.     }              /* if the URL from the map starts from root, end the
  447.               base URL string at the first single slash */
  448.     else {
  449.       directory = string_pos; /* save the start of the directory portion */
  450.  
  451.       string_pos = strrchr(string_pos, '/');  /* now reuse string_pos */
  452.       string_pos++;  /* step over that last slash */
  453.       *string_pos = '\0';
  454.     }              /* but if the map url is relative, leave the
  455.             slash on the base (if there is one) */
  456.     break;
  457.       }
  458.     string_pos++;   /* until we get to the end of my_base without finding
  459.                a slash by itself */
  460.   }
  461.  
  462.   while ( ! strncmp(value, "../", 3) || ! strcmp(value, "..") ) { 
  463.  
  464.       if (directory && (slen = strlen (directory))) {
  465.  
  466.       /* for each '..',  knock a directory off the end 
  467.          by ending the string right at the last slash.
  468.          But only consider the directory portion: don't eat
  469.          into the server name.  And only try if a directory
  470.          portion was found */    
  471.       
  472.       clen = slen - 1;
  473.     
  474.       while ((slen - clen) == 1) {
  475.     
  476.           if ((string_pos = strrchr(directory, '/')))
  477.           *string_pos = '\0';
  478.           clen = strlen (directory);
  479.           if (clen == 0) break;
  480.       }
  481.  
  482.       value += 2;      /* jump over the '..' that we found in the value */
  483.       }
  484.       
  485.       if (! strncmp(value, "/../", 4) || ! strcmp(value, "/..") )
  486.  
  487.       value++;       /* step over the '/' if there are more '..' to do.
  488.                this way, we leave the starting '/' on value after
  489.                the last '..', but get rid of it otherwise */ 
  490.      
  491.   }                   /* by this point, value does not start with '..' */
  492.  
  493.   if ( value && *value ) {
  494.     ap_snprintf(url, SMALLBUF, "%s%s", my_base, value);   
  495.   }
  496.   else {
  497.     ap_snprintf(url, SMALLBUF, "%s", my_base);   
  498.   }
  499.   return;
  500. }
  501.  
  502. int imap_reply(request_rec *r, char *redirect)
  503. { 
  504.   if ( ! strcasecmp(redirect, "error") ) {
  505.     return SERVER_ERROR;  /* they actually requested an error! */
  506.   }
  507.   if ( ! strcasecmp(redirect, "nocontent") ) {
  508.     return HTTP_NO_CONTENT; /* tell the client to keep the page it has */
  509.   }
  510.   if (redirect && *redirect ) { 
  511.     table_set(r->headers_out, "Location", redirect);
  512.     return REDIRECT;      /* must be a URL, so redirect to it */
  513.   }    
  514.   return SERVER_ERROR;
  515. }
  516.  
  517. void menu_header(request_rec *r, char *menu)
  518. {
  519.   r->content_type = "text/html";
  520.   send_http_header(r);
  521.   hard_timeout("send menu", r);   /* killed in menu_footer */
  522.  
  523.   rvputs(r, "<html><head>\n<title>Menu for ", r->uri,
  524.         "</title>\n</head><body>\n", NULL);
  525.  
  526.   if (!strcasecmp(menu, "formatted")) {
  527.     rvputs(r, "<h1>Menu for ", r->uri, "</h1>\n<hr>\n\n", NULL);
  528.   } 
  529.  
  530.   return;
  531. }
  532.  
  533. void menu_blank(request_rec *r, char *menu)
  534. {
  535.   if (! strcasecmp(menu, "formatted") ) {
  536.     rputs("\n", r);
  537.   }
  538.   if (! strcasecmp(menu, "semiformatted") ) {
  539.     rputs("<br>\n", r);
  540.   }
  541.   if (! strcasecmp(menu, "unformatted") ) {
  542.     rputs("\n", r);  
  543.   }
  544.   return;  
  545. }
  546.  
  547. void menu_comment(request_rec *r, char *menu, char *comment)
  548. {
  549.   if (! strcasecmp(menu, "formatted") ) {
  550.     rputs("\n", r);  /* print just a newline if 'formatted' */
  551.   }
  552.   if (! strcasecmp(menu, "semiformatted") && *comment ) {
  553.     rvputs(r, comment, "\n", NULL);
  554.   }             
  555.   if (! strcasecmp(menu, "unformatted") && *comment ) {
  556.     rvputs(r, comment, "\n", NULL);
  557.   }             
  558.   return;    /* comments are ignored in the 'formatted' form */
  559. }
  560.  
  561. void menu_default(request_rec *r, char *menu, char *href, char *text)
  562. {
  563.   if ( ! strcasecmp(href, "error") || ! strcasecmp(href, "nocontent") ) {
  564.     return;   /* don't print such lines, these aren'te really href's */
  565.   }
  566.   if ( ! strcasecmp(menu, "formatted" ) ) {
  567.     rvputs(r, "<pre>(Default) <a href=\"", href, "\">", text, "</a></pre>\n",
  568.        NULL);
  569.   }
  570.   if ( ! strcasecmp(menu, "semiformatted" ) ) {
  571.     rvputs(r, "<pre>(Default) <a href=\"", href, "\">", text, "</a></pre>\n",
  572.        NULL);
  573.   }
  574.   if ( ! strcasecmp(menu, "unformatted" ) ) {
  575.     rvputs(r, "<a href=\"", href, "\">", text, "</a>", NULL);
  576.   }
  577.   return;
  578. }
  579.  
  580. void menu_directive(request_rec *r, char *menu, char *href, char *text)
  581. {
  582.   if ( ! strcasecmp(href, "error") || ! strcasecmp(href, "nocontent") ) {
  583.     return;   /* don't print such lines, as this isn't really an href */
  584.   }
  585.   if ( ! strcasecmp(menu, "formatted" ) ) {
  586.     rvputs(r, "<pre>          <a href=\"", href, "\">", text, "</a></pre>\n",
  587.        NULL);
  588.   }
  589.   if ( ! strcasecmp(menu, "semiformatted" ) ) {
  590.     rvputs(r, "<pre>          <a href=\"", href, "\">", text, "</a></pre>\n",
  591.        NULL);
  592.   }
  593.   if ( ! strcasecmp(menu, "unformatted" ) ) {
  594.     rvputs(r, "<a href=\"", href, "\">", text, "</a>", NULL);
  595.   }
  596.   return;
  597. }
  598.  
  599. void menu_footer(request_rec *r)
  600. {
  601.   rputs("\n\n</body>\n</html>\n", r);  /* finish the menu */
  602.   kill_timeout(r);
  603. }
  604.  
  605. /* -------------------------------------------------------------- */
  606.  
  607. /* Return length of this quotedstring/barevalue, and its startpointer */
  608.  
  609. int len_attr ( char *found, char **from ) {
  610.     char rej[]=" \t\n\r>";
  611.     if ( !found || !*found || !from ) return 0;
  612.     if ( *found=='"' || *found=='\'' ) {
  613.         rej[0]=*found; rej[1]=0; *from=found+1;
  614.     }
  615.     else
  616.         *from=found;
  617.     return strcspn(*from,rej);
  618. }
  619.  
  620. /* Find *find, with optional =; return something interesting or NULL */
  621.  
  622. char *find_attr ( char *from, char *find, char equals ) {
  623.     int findlen=strlen(find);
  624.     while ( *from && !isalpha(*from) ) from++;
  625.     while ( *from && strlen(from)>=findlen ) {
  626.         if ( !strncasecmp(from,find,findlen)
  627.              && !isalpha(from[findlen]) ) {        /* isalpha's not really right */
  628.             char *p=from+findlen;
  629.             while ( isspace(*p) ) p++;
  630.             if ( equals ) {
  631.                 if ( *p == '=' ) {
  632.                     p++;
  633.                     while ( isspace(*p) ) p++;
  634.                     return p;
  635.                 }
  636.             }
  637.             else {
  638.                 return p;
  639.             }
  640.         }
  641.         if ( *from ) from++;    /* Eat a char (okayed in while(*from)) */
  642.         while ( isalpha(*from) ) from++;
  643.         while ( isspace(*from) ) from++;
  644.         if ( *from == '=' ) {
  645.             int len; char *p;
  646.             from++;
  647.             while ( isspace(*from) ) from++;
  648.             len=len_attr(from,&p);
  649.             if ( ( *from=='"' || *from=='\'' ) && p[len+1] ) len++;
  650.             from=p+len;
  651.         }
  652.         while ( isspace(*from) ) from++;
  653.     }
  654.     return NULL;
  655. }
  656.  
  657. /* Find *find after *from; copy its attribute to *to, with <nul> term */
  658.  
  659. char *copy_attr ( char *from, char *find, char *to ) {
  660.     char *found=find_attr(from,find,(to?'=':0));
  661.     int len=len_attr(found,&from);
  662.     if ( !len || len>=SMALLBUF ) return NULL;    /* Huh? */
  663.     strncpy(to,from,len); to[len]=0;
  664.     return found;
  665. }
  666.  
  667. /* -------------------------------------------------------------- */
  668.  
  669. int imap_handler(request_rec *r)
  670. {
  671.   char input[LARGEBUF] = {'\0'};
  672.     /* size of input can not be lowered without changing hard-coded
  673.      * checks
  674.      */
  675.   char href_text[SMALLBUF] = {'\0'};
  676.   char base[SMALLBUF] = {'\0'};
  677.   char redirect[SMALLBUF] = {'\0'};
  678.   char directive[SMALLBUF] = {'\0'};
  679.   char value[SMALLBUF] = {'\0'};
  680.   char mapdflt[SMALLBUF] = {'\0'};
  681.   char closest[SMALLBUF] = {'\0'};
  682.   double closest_yet = -1;
  683.  
  684.   double testpoint[2] = { -1,-1 }; 
  685.   double pointarray[MAXVERTS + 1][2] = { {-1,-1} };
  686.   int vertex = 0;
  687.  
  688.   char usemap_only = 0;
  689.   char searching_for_map = 0;
  690.   char usemap_name[SMALLBUF] = {'\0'};
  691.  
  692.   char *string_pos = NULL;
  693.   int chars_read = 0;
  694.   int showmenu = 0;
  695.  
  696.   imap_conf_rec *icr = get_module_config(r->per_dir_config, &imap_module);
  697.  
  698.   char *imap_menu = icr->imap_menu ? 
  699.     icr->imap_menu : IMAP_MENU_DEFAULT;
  700.   char *imap_default = icr->imap_default ? 
  701.     icr->imap_default : IMAP_DEFAULT_DEFAULT;
  702.   char *imap_base = icr->imap_base ?
  703.     icr->imap_base : IMAP_BASE_DEFAULT;
  704.  
  705.   FILE *imap = pfopen(r->pool, r->filename, "r"); 
  706.  
  707. /* Phantom .map files:  
  708.  *    Since imap can now read <AREA> tags, it makes sense to permit it to
  709.  *  read .html files as .map files. Further, since .html files may well
  710.  *  contain multiple <MAP>s, it should be possible to specify which <MAP>
  711.  *  to read.
  712.  *    Specify as index.html.mapname.map or index.html.map: in absence of
  713.  *  mapname, the file will only be read to the first </MAP>
  714.  */
  715.   if ( ! imap && strrchr(r->filename,'.') ) {
  716.     char *p;
  717.     strcpy(input, r->filename);
  718.     *strrchr(input,'.')=0;        /* Remove .map */
  719.     if ( (p=strrchr(input,'.')) ) {
  720.         imap = pfopen(r->pool, input, "r");
  721.         if ( ! imap ) {                /* Not file.html.map */
  722.           strcpy(usemap_name,p+1); *p=0;        /* Try file.html.mapname.map */
  723.           if ( strrchr(input,'.') )
  724.               imap = pfopen(r->pool, input, "r");
  725.         }
  726.     }
  727.     usemap_only=1;        /* Only read <AREA> tags */
  728.     searching_for_map=1;        /* Skip until a suitable <MAP> tag */
  729.   }
  730.   
  731.   if ( ! imap ) 
  732.     return NOT_FOUND;
  733.  
  734.   imap_url(r, NULL, imap_base, base);       /* set base according to default */
  735.   imap_url(r, NULL, imap_default, mapdflt); /* and default to global default */
  736.  
  737.   testpoint[X] = get_x_coord(r->args);
  738.   testpoint[Y] = get_y_coord(r->args);
  739.  
  740.   if ((testpoint[X] == -1 || testpoint[Y] == -1) ||
  741.       (testpoint[X] == 0  && testpoint[Y] == 0) ) {
  742.               /* if either is -1 or if both are zero (new Lynx) */
  743.               /* we don't have valid coordinates */
  744.     testpoint[X] = -1;
  745.     testpoint[Y] = -1;
  746.     if ( strncasecmp(imap_menu, "none", 2) )
  747.       showmenu = 1;    /* show the menu _unless_ ImapMenu is 'none' or 'no' */
  748.   }
  749.  
  750.   if (showmenu) {        /* send start of imagemap menu if we're going to */
  751.     menu_header(r, imap_menu);
  752.   }
  753.  
  754.   while (!cfg_getline(input, LARGEBUF, imap)) {
  755.     string_pos = input;   /* always start at the beginning of line */
  756.  
  757.     directive[0] = '\0';
  758.     value[0] = '\0';  
  759.     href_text[0] = '\0';
  760.     redirect[0] = '\0';
  761.     chars_read = 0; /* clear these before using */
  762.  
  763.     if ( ! input[0] ) {     
  764.       if (showmenu) {
  765.     menu_blank(r, imap_menu);
  766.       }
  767.       continue;                           
  768.     }
  769.  
  770.     if ( input[0] == '#' ) {
  771.       if (showmenu) {
  772.     menu_comment(r, imap_menu, input + 1); 
  773.       }           
  774.       continue;
  775.     } /* blank lines and comments are ignored if we aren't printing a menu */
  776.  
  777.  
  778.  
  779.     if (!strncasecmp(input,"<MAP",4)) {    /* Assume it's a MAP tag on one line */
  780.         usemap_only=1;
  781.         searching_for_map=1;
  782.         if ( ! copy_attr(input,"NAME",directive) ) {
  783.         continue;
  784.         }
  785.         if ( !*usemap_name || !strcmp(usemap_name,directive) ) {
  786.         searching_for_map=0;
  787.         }
  788.         continue;
  789.     }
  790.     else if (!strncasecmp(input,"</MAP",4)) {    /* Assume it's a /MAP tag on one line */
  791.         if ( !searching_for_map ) break;
  792.         searching_for_map=1;
  793.         continue;
  794.     }
  795.  
  796.     if ( searching_for_map ) continue;
  797.     
  798.     if (!strncasecmp(input,"<AREA",5)) {    /* Assume it's an AREA tag on one line */
  799.         /* Translate this into a .map format (gets smaller :) */
  800.         usemap_only=1;
  801.         if ( ! copy_attr(input,"SHAPE",directive) ) {
  802.             
  803.             /* Define a CONTINUE which breaks out of nested loops, on error */
  804. #define CONTINUE goto AREA_CONTINUE
  805. AREA_CONTINUE:
  806.             continue;
  807.             
  808.         }
  809.         if ( ! copy_attr(input,"HREF",value) ) {
  810.             if ( ! find_attr(input,"NOHREF",0) ) CONTINUE;
  811.             strcpy(value,"nocontent");
  812.         }
  813.         { char
  814.             *coords=find_attr(input,"COORDS",'='),
  815.             *alt=find_attr(input,"ALT",'=');
  816.             
  817.             if ( alt && alt < coords ) {    /* "alt" coords appeared first  */
  818.                 char *p; int len=len_attr(alt,&p);
  819.                 input[0]='"';
  820.                 memmove(input+1,p,len);
  821.                 strcpy(input+len+1,"\" ");
  822.                 alt=NULL;
  823.             }
  824.             else
  825.                 input[0]=0;    /* Ripe for strcat() */
  826.             string_pos=input+strlen(input);
  827.             if ( coords ) {            /* Coords. Minor surgery for circles */
  828.                 char quotes=(*coords=='"' || *coords=='\'');
  829.                 char *p=coords+quotes;
  830.                 char *p2;
  831.                 if ( !strcasecmp(directive,"CIRCLE") ) {
  832.                     long x,y,r;
  833.                     p2=p; x=strtol(p,&p,10); if ( p2==p ) CONTINUE;
  834.                     while ( isspace(*p) ) p++; if ( *p++!=',' ) CONTINUE;
  835.                     p2=p; y=strtol(p,&p,10); if ( p2==p ) CONTINUE;
  836.                     while ( isspace(*p) ) p++; if ( *p++!=',' ) CONTINUE;
  837.                     p2=p; r=strtol(p,&p,10); if ( p2==p ) CONTINUE;
  838.                     if ( quotes ) {
  839.                         while ( isspace(*p) ) p++;
  840.                         if ( *p!=*coords ) CONTINUE;
  841.                     }
  842.                     else {
  843.                         if ( *p!='>' || *p!=' ' ) CONTINUE;
  844.                     }
  845.                     /* XX This is dodgy in a totally pathological case */
  846.                     sprintf(string_pos,"%ld,%ld %ld,%ld ",x,y,x,y+r);
  847.                     string_pos+=strlen(string_pos);
  848.                 } 
  849.                 else {    /* Not circle - take n,n,n,n -> n,n n,n */
  850.                     long x,y;
  851.                     do {
  852.                         p2=p; x=strtol(p,&p,10); if ( p2==p ) CONTINUE;
  853.                         while ( isspace(*p) ) p++; if ( *p++!=',' ) CONTINUE;
  854.                         p2=p; y=strtol(p,&p,10); if ( p2==p ) CONTINUE;
  855.                         while ( isspace(*p) ) p++;
  856.                         sprintf(string_pos,"%ld,%ld ",x,y);
  857.                         string_pos+=strlen(string_pos);
  858.                     } while ( *p++==',' );
  859.                     p--;
  860.                     if ( quotes ) {
  861.                         while ( isspace(*p) ) p++;
  862.                         if ( *p!=*coords ) CONTINUE;
  863.                     }
  864.                     else {
  865.                         if ( *p!='>' || *p!=' ' ) CONTINUE;
  866.                     }
  867.                 } /* else (directive!="circle") */
  868.             } /* if (coords) */
  869.             if ( alt ) {        /* coords "alt" */
  870.                 char *p; int len=len_attr(alt,&p);
  871.                 *string_pos++='"';
  872.                 memmove(string_pos,p,len);
  873.                 strcpy(string_pos+len,"\"");
  874.             }
  875.         }
  876.         string_pos=input;
  877.         
  878.         /* Don't need this any more */
  879. #undef CONTINUE
  880.     }
  881.  
  882.  
  883.  
  884.     else {
  885.     
  886.     if ( usemap_only ) {
  887.         continue;    /* Don't read anything if we're in HTML mode */
  888.     }
  889.  
  890.     if (sscanf(input, "%255s %255s", directive, value) != 2) {
  891.       continue;                           /* make sure we read two fields */
  892.     }
  893.     /* Now skip what we just read... we can't use ANSIism %n */
  894.     while (!(isspace(*string_pos)))    /* past directive */
  895.         string_pos++;
  896.     while (isspace(*string_pos))    /* and whitespace */
  897.         string_pos++;
  898.     while (!(isspace(*string_pos)))    /* and value... have to watch it */
  899.         string_pos++;        /* can have punctuation and stuff */
  900.     }
  901.     
  902.     if ( ! strncasecmp(directive, "base", 4 ) ) {       /* base, base_uri */
  903.       imap_url(r, NULL, value, base);
  904.       continue; /* base is never printed to a menu */
  905.     }    
  906.  
  907.     chars_read = read_quoted(string_pos, href_text);
  908.     string_pos += chars_read;      /* read the quoted href text if present */
  909.  
  910.     if ( ! strcasecmp(directive, "default" ) ) {        /* default */
  911.       imap_url(r, NULL, value, mapdflt);
  912.       if (showmenu) {              /* print the default if there's a menu */
  913.     if (! *href_text) {           /* if we didn't find a "href text" */
  914.       strncpy(href_text, mapdflt, sizeof(href_text)-1); /* use the href itself as text */
  915.       href_text[sizeof(href_text)-1] = '\0';
  916.     }
  917.     imap_url(r, base, mapdflt, redirect); 
  918.     menu_default(r, imap_menu, redirect, href_text);
  919.       }
  920.       continue;
  921.     }
  922.  
  923.     vertex = 0;
  924.     while ( vertex < MAXVERTS &&  
  925.      sscanf(string_pos, "%lf, %lf",
  926.      &pointarray[vertex][X], &pointarray[vertex][Y])   == 2)
  927.     {
  928.     /* Now skip what we just read... we can't use ANSIism %n */
  929.     while(isspace(*string_pos))    /* past whitespace */
  930.         string_pos++;
  931.     while(isdigit(*string_pos))    /* and the 1st number */
  932.         string_pos++;
  933.     string_pos++;            /* skip the ',' */
  934.     while(isspace(*string_pos))    /* past any more whitespace */
  935.         string_pos++;
  936.     while(isdigit(*string_pos))    /* 2nd number */
  937.         string_pos++;
  938.     vertex++;
  939.     }                /* so long as there are more vertices to read, and
  940.             we have room, read them in.  We start where we left
  941.             off of the last sscanf, not at the beginning.*/
  942.                   
  943.     pointarray[vertex][X] = -1;  /* signals the end of vertices */
  944.  
  945.     if (showmenu) {
  946.       read_quoted(string_pos, href_text); /* href text could be here instead */
  947.       if (! *href_text) {           /* if we didn't find a "href text" */
  948.     strncpy(href_text, value, sizeof(href_text)-1);  /* use the href itself in the menu */
  949.     href_text[sizeof(href_text)-1] = '\0';
  950.       }
  951.       imap_url(r, base, value, redirect); 
  952.       menu_directive(r, imap_menu, redirect, href_text);
  953.       continue;
  954.     }
  955.     /* note that we don't make it past here if we are making a menu */
  956.  
  957.     if (testpoint[X] == -1 || pointarray[0][X] == -1 )
  958.       continue;    /* don't try the following tests if testpoints
  959.             are invalid, or if there are no coordinates */
  960.  
  961.     if ( ! strcasecmp(directive, "poly" ) ) {        /* poly */
  962.  
  963.       if (pointinpoly (testpoint, pointarray) ) {
  964.     pfclose(r->pool, imap); 
  965.     imap_url(r, base, value, redirect);     
  966.     return (imap_reply(r, redirect));
  967.       }
  968.       continue;
  969.     }
  970.  
  971.     if ( ! strcasecmp(directive, "circle" ) ) {        /* circle */
  972.     
  973.       if (pointincircle (testpoint, pointarray) ) {
  974.     pfclose(r->pool, imap); 
  975.     imap_url(r, base, value, redirect);     
  976.     return (imap_reply(r, redirect));
  977.       }
  978.       continue;
  979.     }
  980.     
  981.     if ( ! strcasecmp(directive, "rect" ) ) {        /* rect */
  982.       
  983.       if (pointinrect (testpoint, pointarray) ) {
  984.     pfclose(r->pool, imap); 
  985.     imap_url(r, base, value, redirect);     
  986.     return (imap_reply(r, redirect));
  987.       }
  988.       continue;
  989.     }
  990.     
  991.     if ( ! strcasecmp(directive, "point" ) ) {         /* point */
  992.       
  993.       if (is_closer(testpoint, pointarray, &closest_yet) ) {
  994.     strncpy(closest, value, sizeof(closest)-1);  /* if the closest point yet save it */
  995.     closest[sizeof(closest)-1] = '\0';
  996.       }
  997.       
  998.       continue;    
  999.     }     /* move on to next line whether it's closest or not */
  1000.     
  1001.   }       /* nothing matched, so we get another line! */
  1002.  
  1003.   pfclose(r->pool, imap);   /* we are done with the map file, so close it */
  1004.  
  1005.   if (showmenu) {
  1006.     menu_footer(r);   /* finish the menu and we are done */
  1007.     return OK;                
  1008.   }
  1009.  
  1010.   if (*closest) {    /* if a 'point' directive has been seen */
  1011.     imap_url(r, base, closest, redirect);     
  1012.     return (imap_reply(r, redirect));
  1013.   }    
  1014.  
  1015.   if (*mapdflt ) {   /* a default should be defined, even if only 'nocontent'*/
  1016.     imap_url(r, base, mapdflt, redirect);
  1017.     return(imap_reply(r, redirect));
  1018.   }    
  1019.  
  1020.   return SERVER_ERROR;   /* If we make it this far, we failed. They lose! */
  1021. }
  1022.  
  1023.  
  1024. handler_rec imap_handlers[] = {
  1025. { IMAP_MAGIC_TYPE, imap_handler },
  1026. { "imap-file", imap_handler },
  1027. { NULL }
  1028. };
  1029.  
  1030. module imap_module = {
  1031.    STANDARD_MODULE_STUFF,
  1032.    NULL,            /* initializer */
  1033.    create_imap_dir_config,    /* dir config creater */
  1034.    merge_imap_dir_configs,    /* dir merger --- default is to override */
  1035.    NULL,            /* server config */
  1036.    NULL,            /* merge server config */
  1037.    imap_cmds,            /* command table */
  1038.    imap_handlers,        /* handlers */
  1039.    NULL,            /* filename translation */
  1040.    NULL,            /* check_user_id */
  1041.    NULL,            /* check auth */
  1042.    NULL,            /* check access */
  1043.    NULL,            /* type_checker */
  1044.    NULL,            /* fixups */
  1045.    NULL,            /* logger */
  1046.    NULL                /* header parser */
  1047. };
  1048.