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