home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 8 / CDACTUAL8.iso / share / os2 / varios / apache / util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-25  |  28.0 KB  |  1,197 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.  * ITS 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. /*
  56.  * str.c: string utility things
  57.  * 
  58.  * 3/21/93 Rob McCool
  59.  * 
  60.  */
  61.  
  62.  
  63. #include "httpd.h"
  64. #include "http_conf_globals.h"    /* for user_id & group_id */
  65. #ifdef QNX
  66. #include <time.h>
  67. #endif
  68.  
  69. #ifdef NOTDEF
  70. extern char** environ;
  71.  
  72. /* taken from bdflush-1.5 for Linux source code */
  73. void inststr(char *dst[], int argc, char *src)
  74. {
  75.     if (strlen(src) <= strlen(dst[0]))
  76.     {
  77.         char *ptr;
  78.  
  79.         for (ptr = dst[0]; *ptr; *(ptr++) = '\0');
  80.  
  81.         strcpy(dst[0], src);
  82.     } else
  83.     {
  84.         /* stolen from the source to perl 4.036 (assigning to $0) */
  85.         char *ptr, *ptr2;
  86.         int count;
  87.         ptr = dst[0] + strlen(dst[0]);
  88.         for (count = 1; count < argc; count++) {
  89.             if (dst[count] == ptr + 1)
  90.                 ptr += strlen(++ptr);
  91.         }
  92.         if (environ[0] == ptr + 1) {
  93.             for (count = 0; environ[count]; count++)
  94.                 if (environ[count] == ptr + 1)
  95.                     ptr += strlen(++ptr);
  96.         }
  97.         count = 0;
  98.         for (ptr2 = dst[0]; ptr2 <= ptr; ptr2++) {
  99.             *ptr2 = '\0';
  100.             count++;
  101.         }
  102.         strncpy(dst[0], src, count);
  103.     }
  104. }
  105. #endif
  106.  
  107. char *get_time() {
  108.     time_t t;
  109.     char *time_string;
  110.  
  111.     t=time(NULL);
  112.     time_string = ctime(&t);
  113.     time_string[strlen(time_string) - 1] = '\0';
  114.     return (time_string);
  115. }
  116.  
  117. char *ht_time(pool *p, time_t t, char *fmt, int gmt) {
  118.     char ts[MAX_STRING_LEN];
  119.     struct tm *tms;
  120.  
  121.     tms = (gmt ? gmtime(&t) : localtime(&t));
  122.  
  123.     /* check return code? */
  124.     strftime(ts,MAX_STRING_LEN,fmt,tms);
  125.     return pstrdup (p, ts);
  126. }
  127.  
  128. char *gm_timestr_822(pool *p, time_t sec) {
  129.     static const char *const days[7]=
  130.        {"Sun","Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  131.     char ts[50];
  132.     struct tm *tms;
  133.  
  134.     tms = gmtime(&sec);
  135.  
  136. /* RFC date format; as strftime '%a, %d %b %Y %T GMT' */
  137.     sprintf(ts, "%s, %.2d %s %d %.2d:%.2d:%.2d GMT", days[tms->tm_wday],
  138.         tms->tm_mday, month_snames[tms->tm_mon], tms->tm_year + 1900,
  139.         tms->tm_hour, tms->tm_min, tms->tm_sec);
  140.  
  141.     return pstrdup (p, ts);
  142. }
  143.  
  144. /* What a pain in the ass. */
  145. struct tm *get_gmtoff(long *tz) {
  146.     time_t tt;
  147.     struct tm *t;
  148.  
  149.     tt = time(NULL);
  150.     t = localtime(&tt);
  151. #if defined(HAS_GMTOFF)
  152.     *tz = t->tm_gmtoff;
  153. #elif !defined(NO_TIMEZONE)
  154.     *tz = - timezone;
  155.     if(t->tm_isdst)
  156.         *tz += 3600;
  157. #else
  158.   {
  159.     static struct tm loc_t;
  160.  
  161.     loc_t = *t;   /* save it */
  162.     t = gmtime(&tt);
  163.     *tz = mktime(&loc_t) - mktime(t);
  164.     t = &loc_t; /* return pointer to saved time */
  165.   }
  166. #endif
  167.     return t;
  168. }
  169.  
  170.  
  171. /* Match = 0, NoMatch = 1, Abort = -1 */
  172. /* Based loosely on sections of wildmat.c by Rich Salz
  173.  * Hmmm... shouldn't this really go component by component?
  174.  */
  175. int strcmp_match(char *str, char *exp) {
  176.     int x,y;
  177.  
  178.     for(x=0,y=0;exp[y];++y,++x) {
  179.         if((!str[x]) && (exp[y] != '*'))
  180.             return -1;
  181.         if(exp[y] == '*') {
  182.             while(exp[++y] == '*');
  183.             if(!exp[y])
  184.                 return 0;
  185.             while(str[x]) {
  186.                 int ret;
  187.                 if((ret = strcmp_match(&str[x++],&exp[y])) != 1)
  188.                     return ret;
  189.             }
  190.             return -1;
  191.         } else 
  192.             if((exp[y] != '?') && (str[x] != exp[y]))
  193.                 return 1;
  194.     }
  195.     return (str[x] != '\0');
  196. }
  197.  
  198. int strcasecmp_match(char *str, char *exp) {
  199.     int x,y;
  200.  
  201.     for(x=0,y=0;exp[y];++y,++x) {
  202.         if((!str[x]) && (exp[y] != '*'))
  203.             return -1;
  204.         if(exp[y] == '*') {
  205.             while(exp[++y] == '*');
  206.             if(!exp[y])
  207.                 return 0;
  208.             while(str[x]) {
  209.                 int ret;
  210.                 if((ret = strcasecmp_match(&str[x++],&exp[y])) != 1)
  211.                     return ret;
  212.             }
  213.             return -1;
  214.         } else 
  215.             if((exp[y] != '?') && (tolower(str[x]) != tolower(exp[y])))
  216.                 return 1;
  217.     }
  218.     return (str[x] != '\0');
  219. }
  220.  
  221. int is_matchexp(char *str) {
  222.     register int x;
  223.  
  224.     for(x=0;str[x];x++)
  225.         if((str[x] == '*') || (str[x] == '?'))
  226.             return 1;
  227.     return 0;
  228. }
  229.  
  230. /*
  231.  * Parse .. so we don't compromise security
  232.  */
  233. void getparents(char *name)
  234. {
  235.     int l, w;
  236.  
  237.     /* Four paseses, as per RFC 1808 */
  238.     /* a) remove ./ path segments */
  239.  
  240.     for (l=0, w=0; name[l] != '\0';)
  241.     {
  242.     if (name[l] == '.' && name[l+1] == '/' && (l == 0 || name[l-1] == '/'))
  243.         l += 2;
  244.     else
  245.         name[w++] = name[l++];
  246.     }
  247.  
  248.     /* b) remove trailing . path, segment */
  249.     if (w == 1 && name[0] == '.') w--;
  250.     else if (w > 1 && name[w-1] == '.' && name[w-2] == '/') w--;
  251.     name[w] = '\0';
  252.  
  253.     /* c) remove all xx/../ segments. (including leading ../ and /../) */
  254.     l = 0;
  255.  
  256.     while(name[l]!='\0') {
  257.         if(name[l] == '.' && name[l+1] == '.' && name[l+2] == '/' &&
  258.         (l == 0 || name[l-1] == '/')) {
  259.         register int m=l+3,n;
  260.  
  261.         l=l-2;
  262.         if(l>=0) {
  263.             while(l >= 0 && name[l] != '/') l--;
  264.             l++;
  265.         }
  266.         else l=0;
  267.         n=l;
  268.         while((name[n]=name[m])) (++n,++m);
  269.             }
  270.     else ++l;
  271.     }
  272.  
  273.     /* d) remove trailing xx/.. segment. */
  274.     if (l == 2 && name[0] == '.' && name[1] == '.') name[0] = '\0';
  275.     else if (l > 2 && name[l-1] == '.' && name[l-2] == '.' && name[l-3] == '/')
  276.     {
  277.     l = l - 4;
  278.     if (l >= 0)
  279.     {
  280.         while (l >= 0 && name[l] != '/') l--;
  281.         l++;
  282.     }
  283.     else l = 0;
  284.     name[l] = '\0';
  285.     }
  286. } 
  287.  
  288. void no2slash(char *name) {
  289.     register int x,y;
  290.  
  291.     for(x=0; name[x];)
  292.         if(x && (name[x-1] == '/') && (name[x] == '/'))
  293.             for(y=x+1;name[y-1];y++)
  294.                 name[y-1] = name[y];
  295.     else x++;
  296. }
  297.  
  298. char *make_dirstr(pool *p, char *s, int n) {
  299.     register int x,f;
  300.     char *res;
  301.  
  302.     for(x=0,f=0;s[x];x++) {
  303.         if(s[x] == '/')
  304.             if((++f) == n) {
  305.         res = palloc(p, x + 2);
  306.         strncpy (res, s, x);
  307.         res[x] = '/';
  308.         res[x+1] = '\0';
  309.                 return res;
  310.             }
  311.     }
  312.  
  313.     if (s[strlen(s) - 1] == '/')
  314.         return pstrdup (p, s);
  315.     else
  316.         return pstrcat (p, s, "/", NULL);
  317. }
  318.  
  319. int count_dirs(char *path) {
  320.     register int x,n;
  321.  
  322.     for(x=0,n=0;path[x];x++)
  323.         if(path[x] == '/') n++;
  324.     return n;
  325. }
  326.  
  327.  
  328. void chdir_file(char *file) {
  329.     int i;
  330.  
  331.     if((i = rind(file,'/')) == -1)
  332.         return;
  333.     file[i] = '\0';
  334.     chdir(file);
  335.     file[i] = '/';
  336. }
  337.  
  338. char *getword(pool* atrans, char **line, char stop) {
  339.     int pos = ind(*line, stop);
  340.     char *res;
  341.  
  342.     if (pos == -1) {
  343.         res = pstrdup (atrans, *line);
  344.     *line += strlen (*line);
  345.     return res;
  346.     }
  347.   
  348.     res = palloc(atrans, pos + 1);
  349.     strncpy (res, *line, pos);
  350.     res[pos] = '\0';
  351.     
  352.     while ((*line)[pos] == stop) ++pos;
  353.     
  354.     *line += pos;
  355.     
  356.     return res;
  357. }
  358. char *getword_nulls(pool* atrans, char **line, char stop) {
  359.     int pos = ind(*line, stop);
  360.     char *res;
  361.  
  362.     if (pos == -1) {
  363.         res = pstrdup (atrans, *line);
  364.     *line += strlen (*line);
  365.     return res;
  366.     }
  367.   
  368.     res = palloc(atrans, pos + 1);
  369.     strncpy (res, *line, pos);
  370.     res[pos] = '\0';
  371.     
  372.     ++pos;
  373.     
  374.     *line += pos;
  375.     
  376.     return res;
  377. }
  378.  
  379. /* Get a word, (new) config-file style --- quoted strings and backslashes
  380.  * all honored
  381.  */
  382.  
  383. char *substring_conf (pool *p, char *start, int len)
  384. {
  385.     char *result = palloc (p, len + 2);
  386.     char *resp = result;
  387.     int i;
  388.  
  389.     for (i = 0; i < len; ++i) {
  390.         if (start[i] == '\\') 
  391.         *resp++ = start[++i];
  392.     else
  393.         *resp++ = start[i];
  394.     }
  395.  
  396.     *resp++ = '\0';
  397.     return result;
  398. }
  399.  
  400. char *getword_conf(pool* p, char **line) {
  401.     char *str = *line, *strend, *res;
  402.     char quote;
  403.  
  404.     while (*str && isspace (*str))
  405.         ++str;
  406.  
  407.     if (!*str) {
  408.         *line = str;
  409.         return "";
  410.     }
  411.  
  412.     if ((quote = *str) == '"' || quote == '\'') {
  413.         strend = str + 1;
  414.     while (*strend && *strend != quote) {
  415.         if (*strend == '\\' && strend[1]) strend += 2;
  416.         else ++strend;
  417.     }
  418.     res = substring_conf (p, str + 1, strend - str - 1);
  419.  
  420.     if (*strend == quote) ++strend;
  421.     } else {
  422.         strend = str;
  423.     while (*strend && !isspace (*strend))
  424.         if (*strend == '\\' && strend[1]) strend += 2;
  425.         else ++strend;
  426.  
  427.     res = substring_conf (p, str, strend - str);
  428.     }
  429.  
  430.     while (*strend && isspace(*strend)) ++ strend;
  431.     *line = strend;
  432.     return res;
  433. }
  434.  
  435. void cfg_getword(char *word, char *line) {
  436.     int x=0,y;
  437.     
  438.     for(x=0;line[x] && isspace(line[x]);x++);
  439.     y=0;
  440.     while(1) {
  441.         if(!(word[y] = line[x]))
  442.             break;
  443.         if(isspace(line[x]))
  444.             if((!x) || (line[x-1] != '\\'))
  445.                 break;
  446.         if(line[x] != '\\') ++y;
  447.         ++x;
  448.     }
  449.     word[y] = '\0';
  450.     while(line[x] && isspace(line[x])) ++x;
  451.     for(y=0;(line[y] = line[x]);++x,++y);
  452. }
  453.  
  454. int
  455. cfg_getline(char *s, int n, FILE *f) {
  456.     register int i=0, c;
  457.  
  458.     s[0] = '\0';
  459.     /* skip leading whitespace */
  460.     do {
  461.         c = getc(f);
  462.     } while (c == '\t' || c == ' ');
  463.  
  464.     while(1) {
  465.         if((c == '\t') || (c == ' ')) {
  466.             s[i++] = ' ';
  467.             while((c == '\t') || (c == ' ')) 
  468.                 c = getc(f);
  469.         }
  470.         if(c == CR) {
  471.             c = getc(f);
  472.         }
  473.         if(c == EOF || c == 0x4 || c == LF || i == (n-1)) {
  474.             /* blast trailing whitespace */
  475.             while(i && (s[i-1] == ' ')) --i;
  476.             s[i] = '\0';
  477.             return (feof(f) ? 1 : 0);
  478.         }
  479.         s[i] = c;
  480.         ++i;
  481.         c = getc(f);
  482.     }
  483. }
  484.  
  485. /* Retrieve a token, spacing over it and returning a pointer to
  486.  * the first non-white byte afterwards.  Note that these tokens
  487.  * are delimited by semis and commas; and can also be delimited
  488.  * by whitespace at the caller's option.
  489.  */
  490.  
  491. char *get_token (pool *p, char **accept_line, int accept_white)
  492. {
  493.     char *ptr = *accept_line;
  494.     char *tok_start;
  495.     char *token;
  496.     int tok_len;
  497.   
  498.     /* Find first non-white byte */
  499.     
  500.     while (*ptr && isspace(*ptr))
  501.       ++ptr;
  502.  
  503.     tok_start = ptr;
  504.     
  505.     /* find token end, skipping over quoted strings.
  506.      * (comments are already gone).
  507.      */
  508.     
  509.     while (*ptr && (accept_white || !isspace(*ptr))
  510.        && *ptr != ';' && *ptr != ',')
  511.     {
  512.     if (*ptr++ == '"')
  513.         while (*ptr)
  514.             if (*ptr++ == '"') break;
  515.     }
  516.       
  517.     tok_len = ptr - tok_start;
  518.     token = palloc (p, tok_len + 1);
  519.     strncpy (token, tok_start, tok_len);
  520.     token[tok_len] = '\0';
  521.     
  522.     /* Advance accept_line pointer to the next non-white byte */
  523.  
  524.     while (*ptr && isspace(*ptr))
  525.       ++ptr;
  526.  
  527.     *accept_line = ptr;
  528.     return token;
  529. }
  530.  
  531. char *escape_shell_cmd(pool *p, char *s) {
  532.     register int x,y,l;
  533.     char *cmd;
  534.  
  535.     l=strlen(s);
  536.     cmd = palloc (p, 2 * l + 1); /* Be safe */
  537.     strcpy (cmd, s);
  538.     
  539.     for(x=0;cmd[x];x++) {
  540.     
  541. #ifdef __EMX__
  542.         /* Don't allow '&' in parameters under OS/2. */
  543.         /* This can be used to send commands to the shell. */
  544.         if (cmd[x] == '&') {
  545.             cmd[x] = ' ';
  546.         }
  547. #endif
  548.  
  549.         if(ind("&;`'\"|*?~<>^()[]{}$\\\n",cmd[x]) != -1){
  550.             for(y=l+1;y>x;y--)
  551.                 cmd[y] = cmd[y-1];
  552.             l++; /* length has been increased */
  553.             cmd[x] = '\\';
  554.             x++; /* skip the character */
  555.         }
  556.     }
  557.  
  558.     return cmd;
  559. }
  560.  
  561. void plustospace(char *str) {
  562.     register int x;
  563.  
  564.     for(x=0;str[x];x++) if(str[x] == '+') str[x] = ' ';
  565. }
  566.  
  567. void spacetoplus(char *str) {
  568.     register int x;
  569.  
  570.     for(x=0;str[x];x++) if(str[x] == ' ') str[x] = '+';
  571. }
  572.  
  573. char x2c(char *what) {
  574.     register char digit;
  575.  
  576.     digit = ((what[0] >= 'A') ? ((what[0] & 0xdf) - 'A')+10 : (what[0] - '0'));
  577.     digit *= 16;
  578.     digit += (what[1] >= 'A' ? ((what[1] & 0xdf) - 'A')+10 : (what[1] - '0'));
  579.     return(digit);
  580. }
  581.  
  582. /*
  583.  * Unescapes a URL.
  584.  * Returns 0 on success, non-zero on error
  585.  * Failure is due to
  586.  *   bad % escape       returns BAD_REQUEST
  587.  *
  588.  *   decoding %00 -> \0
  589.  *   decoding %2f -> /   (a special character)
  590.  *                      returns NOT_FOUND
  591.  */
  592. int
  593. unescape_url(char *url) {
  594.     register int x,y, badesc, badpath;
  595.  
  596.     badesc = 0;
  597.     badpath = 0;
  598.     for(x=0,y=0;url[y];++x,++y) {
  599.     if (url[y] != '%') url[x] = url[y];
  600.     else
  601.     {
  602.         if (!isxdigit(url[y+1]) || !isxdigit(url[y+2]))
  603.         {
  604.         badesc = 1;
  605.         url[x] = '%';
  606.         } else
  607.         {
  608.         url[x] = x2c(&url[y+1]);
  609.         y += 2;
  610.         if (url[x] == '/' || url[x] == '\0') badpath = 1;
  611.         }
  612.         }
  613.     }
  614.     url[x] = '\0';
  615.     if (badesc) return BAD_REQUEST;
  616.     else if (badpath) return NOT_FOUND;
  617.     else return OK;
  618. }
  619.  
  620. char *construct_url(pool *p, char *uri, server_rec *s) {
  621.     char portnum[10];        /* Long enough.  Really! */
  622.   
  623.     if (s->port == 80) {
  624.         return pstrcat (p, "http://", s->server_hostname, uri, NULL);
  625.     } else {
  626.         sprintf (portnum, "%d", s->port);
  627.     return pstrcat (p, "http://", s->server_hostname, ":", portnum, uri,
  628.             NULL);
  629.     }
  630. }
  631.  
  632. #define c2x(what,where) sprintf(where,"%%%02x",what)
  633.  
  634. /*
  635. escape_path_segment() escapes a path segment, as defined in RFC 1808. This
  636. routine is (should be) OS independent.
  637.  
  638. os_escape_path() converts an OS path to a URL, in an OS dependent way. In all
  639. cases if a ':' occurs before the first '/' in the URL, the URL should be
  640. prefixed with "./" (or the ':' escaped). In the case of Unix, this means
  641. leaving '/' alone, but otherwise doing what escape_path_segment() does. For
  642. efficiency reasons, we don't use escape_path_segment(), which is provided for
  643. reference. Again, RFC 1808 is where this stuff is defined.
  644.  
  645. If partial is set, os_escape_path() assumes that the path will be appended to
  646. something with a '/' in it (and thus does not prefix "./").
  647. */
  648.  
  649. char *escape_path_segment(pool *p, const char *segment) {
  650.     register int x,y;
  651.     char *copy = palloc (p, 3 * strlen (segment) + 1);
  652.             
  653.     for(x=0,y=0; segment[x]; x++,y++) {
  654.       char c=segment[x];
  655.       if((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c >'9')
  656.      && ind("$-_.+!*'(),:@&=~",c) == -1)
  657.     {
  658.       c2x(c,©[y]);
  659.       y+=2;
  660.     }
  661.       else
  662.     copy[y]=c;
  663.     }
  664.     copy[y] = '\0';
  665.     return copy;
  666. }
  667.  
  668. char *os_escape_path(pool *p,const char *path,int partial) {
  669.   char *copy=palloc(p,3*strlen(path)+3);
  670.   char *s=copy;
  671.  
  672.   if(!partial)
  673.     {
  674.       int colon=ind(path,':');
  675.       int slash=ind(path,'/');
  676.  
  677.       if(colon >= 0 && (colon < slash || slash < 0))
  678.     {
  679.       *s++='.';
  680.       *s++='/';
  681.     }
  682.     }
  683.   for( ; *path ; ++path)
  684.     {
  685.       char c=*path;
  686.       if((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c >'9')
  687.      && ind("$-_.+!*'(),:@&=/~",c) == -1)
  688.     {
  689.       c2x(c,s);
  690.       s+=3;
  691.     }
  692.       else
  693.     *s++=c;
  694.     }
  695.   *s='\0';
  696.   return copy;
  697. }
  698.  
  699. char *escape_uri(pool *p, char *uri) {
  700.     register int x,y;
  701.     char *copy = palloc (p, 3 * strlen (uri) + 1);
  702.             
  703.     for(x=0,y=0; uri[x]; x++,y++) {
  704.         if (ind (":% ?+&",(copy[y] = uri[x])) != -1) {
  705.             c2x(uri[x],©[y]);
  706.             y+=2;
  707.         }
  708.     }
  709.     copy[y] = '\0';
  710.     return copy;
  711. }
  712.  
  713. char *
  714. escape_html(pool *p, const char *s)
  715. {
  716.     int i, j;
  717.     char *x;
  718.  
  719. /* first, count the number of extra characters */
  720.     for (i=0, j=0; s[i] != '\0'; i++)
  721.     if (s[i] == '<' || s[i] == '>') j += 3;
  722.     else if (s[i] == '&') j += 4;
  723.  
  724.     if (j == 0) return pstrdup(p, s);
  725.     x = palloc(p, i + j + 1);
  726.     for (i=0, j=0; s[i] != '\0'; i++, j++)
  727.     if (s[i] == '<')
  728.     {
  729.         memcpy(&x[j], "<", 4);
  730.         j += 3;
  731.     } else if (s[i] == '>')
  732.     {
  733.         memcpy(&x[j], ">", 4);
  734.         j += 3;
  735.     } else if (s[i] == '&')
  736.     {
  737.         memcpy(&x[j], "&", 5);
  738.         j += 4;
  739.     } else
  740.             x[j] = s[i];
  741.  
  742.     x[j] = '\0';
  743.     return x;
  744. }
  745.  
  746. #ifdef NOTDEF
  747.  
  748. void escape_url(char *url) {
  749.     register int x,y;
  750.     register char digit;
  751.     char *copy;
  752.  
  753.     copy = strdup(url);
  754.             
  755.     for(x=0,y=0;copy[x];x++,y++) {
  756.         if(ind("% ?+&",url[y] = copy[x]) != -1) {
  757.             c2x(copy[x],&url[y]);
  758.             y+=2;
  759.         }
  760.     }
  761.     url[y] = '\0';
  762.     free(copy);
  763. }
  764.  
  765. #endif
  766.  
  767. int is_directory(char *path) {
  768.     struct stat finfo;
  769.  
  770.     if(stat(path,&finfo) == -1)
  771.         return 0; /* in error condition, just return no */
  772.  
  773.     return(S_ISDIR(finfo.st_mode));
  774. }
  775.  
  776. char *make_full_path(pool *a, char *src1,char *src2) {
  777.     register int x;
  778.  
  779.     x = strlen(src1);
  780.     if (x == 0) return pstrcat (a, "/", src2, NULL);
  781.  
  782.     if (src1[x - 1] != '/') return pstrcat (a, src1, "/", src2, NULL);
  783.     else return pstrcat (a, src1, src2, NULL);
  784. }
  785.  
  786. int is_url(char *u) {
  787.     register int x;
  788.  
  789.     for(x=0;u[x] != ':';x++)
  790.         if((!u[x]) || (!isalpha(u[x])))
  791.             return 0;
  792.  
  793.     if((u[x+1] == '/') && (u[x+2] == '/'))
  794.         return 1;
  795.     else return 0;
  796. }
  797.  
  798. int can_exec(struct stat *finfo) {
  799. #ifdef __EMX__
  800.     /* OS/2 dosen't have Users and Groups */
  801.     return (finfo->st_mode & S_IEXEC);
  802. #else    
  803.     if(user_id == finfo->st_uid)
  804.         if(finfo->st_mode & S_IXUSR)
  805.             return 1;
  806.     if(group_id == finfo->st_gid)
  807.         if(finfo->st_mode & S_IXGRP)
  808.             return 1;
  809.     return (finfo->st_mode & S_IXOTH);
  810. #endif    
  811. }
  812.  
  813. #ifdef NEED_STRDUP
  814. char *strdup (char *str)
  815. {
  816.   char *dup;
  817.  
  818.   if(!(dup = (char *)malloc (strlen (str) + 1)))
  819.       return NULL;
  820.   dup = strcpy (dup, str);
  821.  
  822.   return dup;
  823. }
  824. #endif
  825.  
  826. /* The following two routines were donated for SVR4 by Andreas Vogel */
  827. #ifdef NEED_STRCASECMP
  828. int strcasecmp (const char *a, const char *b)
  829. {
  830.     const char *p = a;
  831.     const char *q = b;
  832.     for (p = a, q = b; *p && *q; p++, q++)
  833.     {
  834.       int diff = tolower(*p) - tolower(*q);
  835.       if (diff) return diff;
  836.     }
  837.     if (*p) return 1;       /* p was longer than q */
  838.     if (*q) return -1;      /* p was shorter than q */
  839.     return 0;               /* Exact match */
  840. }
  841.  
  842. #endif
  843.  
  844. #ifdef NEED_STRNCASECMP
  845. int strncasecmp (const char *a, const char *b, int n)
  846. {
  847.     const char *p = a;
  848.     const char *q = b;
  849.  
  850.     for (p = a, q = b; /*NOTHING*/; p++, q++)
  851.     {
  852.       int diff;
  853.       if (p == a + n) return 0;     /*   Match up to n characters */
  854.       if (!(*p && *q)) return *p - *q;
  855.       diff = tolower(*p) - tolower(*q);
  856.       if (diff) return diff;
  857.     }
  858.     /*NOTREACHED*/
  859. }
  860. #endif
  861.  
  862.  
  863.  
  864. #ifdef NEED_INITGROUPS
  865. int initgroups(const char *name, gid_t basegid)
  866. {
  867. #ifdef QNX
  868. /* QNX does not appear to support supplementary groups.
  869. Ben <ben@algroup.co.uk> */
  870.     return 0;
  871. #else /* ndef QNX */
  872.   gid_t groups[NGROUPS_MAX];
  873.   struct group *g;
  874.   int index = 0;
  875.  
  876.   setgrent();
  877.  
  878.   groups[index++] = basegid;
  879.  
  880.   while (index < NGROUPS_MAX && ((g = getgrent()) != NULL))
  881.     if (g->gr_gid != basegid)
  882.     {
  883.       char **names;
  884.  
  885.       for (names = g->gr_mem; *names != NULL; ++names)
  886.         if (!strcmp(*names, name))
  887.           groups[index++] = g->gr_gid;
  888.     }
  889.  
  890.   endgrent();
  891.  
  892.   return setgroups(index, groups);
  893. #endif /* def QNX */
  894. }
  895. #endif /* def NEED_INITGROUPS */
  896.  
  897. #ifdef NEED_WAITPID
  898. /* From ikluft@amdahl.com */
  899. /* this is not ideal but it works for SVR3 variants */
  900. /* httpd does not use the options so this doesn't implement them */
  901. int waitpid(pid_t pid, int *statusp, int options)
  902. {
  903.     int tmp_pid;
  904.     if ( kill ( pid,0 ) == -1) {
  905.         errno=ECHILD;
  906.         return -1;
  907.     }
  908.     while ((( tmp_pid = wait(statusp)) != pid) && ( tmp_pid != -1 ));
  909.     return tmp_pid;
  910. }
  911. #endif
  912.  
  913. int ind(const char *s, char c) {
  914.     register int x;
  915.  
  916.     for(x=0;s[x];x++)
  917.         if(s[x] == c) return x;
  918.  
  919.     return -1;
  920. }
  921.  
  922. int rind(const char *s, char c) {
  923.     register int x;
  924.  
  925.     for(x=strlen(s)-1;x != -1;x--)
  926.         if(s[x] == c) return x;
  927.  
  928.     return -1;
  929. }
  930.  
  931. void str_tolower(char *str) {
  932.     while(*str) {
  933.         *str = tolower(*str);
  934.         ++str;
  935.     }
  936. }
  937.         
  938. uid_t uname2id(char *name) {
  939.     struct passwd *ent;
  940.  
  941.     if(name[0] == '#') 
  942.         return(atoi(&name[1]));
  943.  
  944.     if(!(ent = getpwnam(name))) {
  945.         fprintf(stderr,"httpd: bad user name %s\n",name);
  946.         exit(1);
  947.     }
  948.     else return(ent->pw_uid);
  949. }
  950.  
  951. gid_t gname2id(char *name) {
  952.     struct group *ent;
  953.  
  954.     if(name[0] == '#') 
  955.         return(atoi(&name[1]));
  956.  
  957.     if(!(ent = getgrnam(name))) {
  958.         fprintf(stderr,"httpd: bad group name %s\n",name);
  959.         exit(1);
  960.     }
  961.     else return(ent->gr_gid);
  962. }
  963.  
  964. #if 0
  965. int get_portnum(int sd) {
  966.     struct sockaddr addr;
  967.     int len;
  968.  
  969.     len = sizeof(struct sockaddr);
  970.     if(getsockname(sd,&addr,&len) < 0)
  971.         return -1;
  972.     return ntohs(((struct sockaddr_in *)&addr)->sin_port);
  973. }
  974.  
  975. struct in_addr get_local_addr(int sd) {
  976.     struct sockaddr addr;
  977.     int len;
  978.  
  979.     len = sizeof(struct sockaddr);
  980.     if(getsockname(sd,&addr,&len) < 0) {
  981.         fprintf (stderr, "Can't get local host address!\n");
  982.     perror ("getsockname");
  983.     exit(1);
  984.     }
  985.          
  986.     return ((struct sockaddr_in *)&addr)->sin_addr;
  987. }
  988. #endif
  989.  
  990. /*
  991.  * Parses a host of the form <address>[:port]
  992.  * :port is permitted if 'port' is not NULL
  993.  */
  994. unsigned long get_virthost_addr (char *w, short int *ports) {
  995.     struct hostent *hep;
  996.     unsigned long my_addr;
  997.     char *p;
  998.  
  999.     p = strchr(w, ':');
  1000.     if (ports != NULL)
  1001.     {
  1002.     *ports = 0;
  1003.     if (p != NULL && strcmp(p+1, "*") != 0) *ports = atoi(p+1);
  1004.     }
  1005.  
  1006.     if (p != NULL) *p = '\0';
  1007.     if (strcmp(w, "*") == 0)
  1008.     {
  1009.     if (p != NULL) *p = ':';
  1010.     return htonl(INADDR_ANY);
  1011.     }
  1012.     
  1013. #ifdef DGUX
  1014.     my_addr = inet_network(w);
  1015. #else
  1016.     my_addr = inet_addr(w);
  1017. #endif
  1018.     if (my_addr != ((unsigned long) 0xffffffff))
  1019.     {
  1020.     if (p != NULL) *p = ':';
  1021.     return my_addr;
  1022.     }
  1023.  
  1024.     hep = gethostbyname(w);
  1025.         
  1026.     if ((!hep) || (hep->h_addrtype != AF_INET || !hep->h_addr_list[0])) {
  1027.     fprintf (stderr, "Cannot resolve host name %s --- exiting!\n", w);
  1028.     exit(1);
  1029.     }
  1030.         
  1031.     if (hep->h_addr_list[1]) {
  1032.     fprintf(stderr, "Host %s has multiple addresses ---\n", w);
  1033.     fprintf(stderr, "you must choose one explicitly for use as\n");
  1034.     fprintf(stderr, "a virtual host.  Exiting!!!\n");
  1035.     exit(1);
  1036.     }
  1037.         
  1038.     if (p != NULL) *p = ':';
  1039.  
  1040.     return ((struct in_addr *)(hep->h_addr))->s_addr;
  1041. }
  1042.  
  1043.  
  1044. #ifdef NOTDEF    
  1045.     
  1046. char *get_remote_logname(FILE *fd) {
  1047.     int len;
  1048.     char *result;
  1049. #if defined(NEXT) || defined(BSD4_4) || defined(SOLARIS2) || defined(LINUX) || defined(__EMX__)
  1050.     struct sockaddr sa_server, sa_client;
  1051. #else
  1052.     struct sockaddr_in sa_server,sa_client;
  1053. #endif
  1054.  
  1055.     len = sizeof(sa_client);
  1056.     if(getpeername(fileno(stdout),&sa_client,&len) != -1) {
  1057.         len = sizeof(sa_server);
  1058.         if(getsockname(fileno(stdout),&sa_server,&len) == -1)
  1059.             result = "unknown";
  1060.         else
  1061.             result = rfc931((struct sockaddr_in *) & sa_client,
  1062.                                     (struct sockaddr_in *) & sa_server);
  1063.     }
  1064.     else result = "unknown";
  1065.  
  1066.     return result; /* robm=pinhead */
  1067. }
  1068. #endif    
  1069.  
  1070. static char *find_fqdn(pool *a, struct hostent *p) {
  1071.     int x;
  1072.  
  1073.     if(ind(p->h_name,'.') == -1) {
  1074.         for(x=0;p->h_aliases[x];++x) {
  1075.             if((ind(p->h_aliases[x],'.') != -1) && 
  1076.                (!strncmp(p->h_aliases[x],p->h_name,strlen(p->h_name))))
  1077.                 return pstrdup(a, p->h_aliases[x]);
  1078.         }
  1079.         return NULL;
  1080.     } else return pstrdup(a, (void *)p->h_name);
  1081. }
  1082.  
  1083. char *get_local_host(pool *a)
  1084. {
  1085.     char str[128];
  1086.     int len = 128;
  1087.     char *server_hostname;
  1088.  
  1089.     struct hostent *p;
  1090.     gethostname(str, len);
  1091.     if((!(p=gethostbyname(str))) || (!(server_hostname = find_fqdn(a, p)))) {
  1092.         fprintf(stderr,"httpd: cannot determine local host name.\n");
  1093.     fprintf(stderr,"Use ServerName to set it manually.\n");
  1094.     exit(1);
  1095.     }
  1096.  
  1097.     return server_hostname;
  1098. }
  1099.  
  1100. /* aaaack but it's fast and const should make it shared text page. */
  1101. const int pr2six[256]={
  1102.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1103.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,62,64,64,64,63,
  1104.     52,53,54,55,56,57,58,59,60,61,64,64,64,64,64,64,64,0,1,2,3,4,5,6,7,8,9,
  1105.     10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,64,64,64,64,64,64,26,27,
  1106.     28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
  1107.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1108.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1109.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1110.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1111.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1112.     64,64,64,64,64,64,64,64,64,64,64,64,64
  1113. };
  1114.  
  1115. char *uudecode(pool *p, char *bufcoded) {
  1116.     int nbytesdecoded;
  1117.     register unsigned char *bufin;
  1118.     register char *bufplain;
  1119.     register unsigned char *bufout;
  1120.     register int nprbytes;
  1121.     
  1122.     /* Strip leading whitespace. */
  1123.     
  1124.     while(*bufcoded==' ' || *bufcoded == '\t') bufcoded++;
  1125.     
  1126.     /* Figure out how many characters are in the input buffer.
  1127.      * Allocate this many from the per-transaction pool for the result.
  1128.      */
  1129.     bufin = (unsigned char *)bufcoded;
  1130.     while(pr2six[*(bufin++)] <= 63);
  1131.     nprbytes = (char *)bufin - bufcoded - 1;
  1132.     nbytesdecoded = ((nprbytes+3)/4) * 3;
  1133.  
  1134.     bufplain = palloc(p, nbytesdecoded + 1);
  1135.     bufout = (unsigned char *)bufplain;
  1136.     
  1137.     bufin = (unsigned char *)bufcoded;
  1138.     
  1139.     while (nprbytes > 0) {
  1140.         *(bufout++) = 
  1141.             (unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
  1142.         *(bufout++) = 
  1143.             (unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
  1144.         *(bufout++) = 
  1145.             (unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
  1146.         bufin += 4;
  1147.         nprbytes -= 4;
  1148.     }
  1149.     
  1150.     if(nprbytes & 03) {
  1151.         if(pr2six[bufin[-2]] > 63)
  1152.             nbytesdecoded -= 2;
  1153.         else
  1154.             nbytesdecoded -= 1;
  1155.     }
  1156.     bufplain[nbytesdecoded] = '\0';
  1157.     return bufplain;
  1158. }
  1159.  
  1160. #ifdef __EMX__
  1161. void os2pathname(char *path) {
  1162.     char newpath[MAX_STRING_LEN];
  1163.     int loop;
  1164.     int offset;
  1165.  
  1166.     offset = 0;
  1167.     for (loop=0; loop < (strlen(path) + 1); loop++) {
  1168.         if (path[loop] == '/') {
  1169.             newpath[offset] = '\\';
  1170.             /*
  1171.             offset = offset + 1;
  1172.             newpath[offset] = '\\';
  1173.             */
  1174.         } else
  1175.             newpath[offset] = path[loop];
  1176.         offset = offset + 1;
  1177.     };
  1178.     /* Debugging code */
  1179.     /* fprintf(stderr, "%s \n", newpath); */
  1180.  
  1181.     strcpy(path, newpath);
  1182. };
  1183. #endif
  1184.  
  1185.  
  1186. #ifdef NEED_STRERROR
  1187. char *
  1188. strerror (int err) {
  1189.  
  1190.     char *p;
  1191.     extern char *const sys_errlist[];
  1192.  
  1193.     p = sys_errlist[err];
  1194.     return (p);
  1195. }
  1196. #endif
  1197.