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