home *** CD-ROM | disk | FTP | other *** search
/ Big Green CD 8 / BGCD_8_Dev.iso / NEXTSTEP / UNIX / Web / Servers / apache-1.2.4-MIHS / original-source / src / util.c < prev   
Encoding:
C/C++ Source or Header  |  1997-06-26  |  31.7 KB  |  1,356 lines
  1. /* ====================================================================
  2.  * Copyright (c) 1995-1997 The Apache Group.  All rights reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer. 
  10.  *
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in
  13.  *    the documentation and/or other materials provided with the
  14.  *    distribution.
  15.  *
  16.  * 3. All advertising materials mentioning features or use of this
  17.  *    software must display the following acknowledgment:
  18.  *    "This product includes software developed by the Apache Group
  19.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  20.  *
  21.  * 4. The names "Apache Server" and "Apache Group" must not be used to
  22.  *    endorse or promote products derived from this software without
  23.  *    prior written permission.
  24.  *
  25.  * 5. Redistributions of any form whatsoever must retain the following
  26.  *    acknowledgment:
  27.  *    "This product includes software developed by the Apache Group
  28.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  29.  *
  30.  * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
  31.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  33.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
  34.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  35.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  36.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  37.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  40.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  41.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  42.  * ====================================================================
  43.  *
  44.  * This software consists of voluntary contributions made by many
  45.  * individuals on behalf of the Apache Group and was originally based
  46.  * on public domain software written at the National Center for
  47.  * Supercomputing Applications, University of Illinois, Urbana-Champaign.
  48.  * For more information on the Apache Group and the Apache HTTP server
  49.  * project, please see <http://www.apache.org/>.
  50.  *
  51.  */
  52.  
  53. /*
  54.  * util.c: string utility things
  55.  * 
  56.  * 3/21/93 Rob McCool
  57.  * 1995-96 Many changes by the Apache Group
  58.  * 
  59.  */
  60.  
  61. #include "httpd.h"
  62. #include "http_conf_globals.h"    /* for user_id & group_id */
  63.  
  64. const char month_snames[12][4] = {
  65.     "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
  66. };
  67.  
  68. char *get_time() {
  69.     time_t t;
  70.     char *time_string;
  71.  
  72.     t=time(NULL);
  73.     time_string = ctime(&t);
  74.     time_string[strlen(time_string) - 1] = '\0';
  75.     return (time_string);
  76. }
  77.  
  78. char *ht_time(pool *p, time_t t, const char *fmt, int gmt) {
  79.     char ts[MAX_STRING_LEN];
  80.     struct tm *tms;
  81.  
  82.     tms = (gmt ? gmtime(&t) : localtime(&t));
  83.  
  84.     /* check return code? */
  85.     strftime(ts,MAX_STRING_LEN,fmt,tms);
  86.     return pstrdup (p, ts);
  87. }
  88.  
  89. char *gm_timestr_822(pool *p, time_t sec) {
  90.     static const char *const days[7]=
  91.        {"Sun","Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  92.     char ts[50];
  93.     struct tm *tms;
  94.  
  95.     tms = gmtime(&sec);
  96.  
  97. /* RFC date format; as strftime '%a, %d %b %Y %T GMT' */
  98.     ap_snprintf(ts, sizeof(ts), 
  99.         "%s, %.2d %s %d %.2d:%.2d:%.2d GMT", days[tms->tm_wday],
  100.         tms->tm_mday, month_snames[tms->tm_mon], tms->tm_year + 1900,
  101.         tms->tm_hour, tms->tm_min, tms->tm_sec);
  102.  
  103.     return pstrdup (p, ts);
  104. }
  105.  
  106. /* What a pain in the ass. */
  107. #if defined(HAVE_GMTOFF)
  108. struct tm *get_gmtoff(int *tz) {
  109.     time_t tt = time(NULL);
  110.     struct tm *t;
  111.  
  112.     t = localtime(&tt);
  113.     *tz = (int) (t->tm_gmtoff / 60);
  114.     return t;
  115. }
  116. #else
  117. struct tm *get_gmtoff(int *tz) {
  118.     time_t tt = time(NULL);
  119.     struct tm gmt;
  120.     struct tm *t;
  121.     int days, hours, minutes;
  122.  
  123.     /* Assume we are never more than 24 hours away. */
  124.     gmt = *gmtime(&tt); /* remember gmtime/localtime return ptr to static */
  125.     t = localtime(&tt); /* buffer... so be careful */
  126.     days = t->tm_yday - gmt.tm_yday;
  127.     hours = ((days < -1 ? 24 : 1 < days ? -24 : days * 24)
  128.          + t->tm_hour - gmt.tm_hour);
  129.     minutes = hours * 60 + t->tm_min - gmt.tm_min;
  130.     *tz = minutes;
  131.     return t;
  132. }
  133. #endif
  134.  
  135.  
  136. /* Match = 0, NoMatch = 1, Abort = -1 */
  137. /* Based loosely on sections of wildmat.c by Rich Salz
  138.  * Hmmm... shouldn't this really go component by component?
  139.  */
  140. int strcmp_match(const char *str, const char *exp) {
  141.     int x,y;
  142.  
  143.     for(x=0,y=0;exp[y];++y,++x) {
  144.         if((!str[x]) && (exp[y] != '*'))
  145.             return -1;
  146.         if(exp[y] == '*') {
  147.             while(exp[++y] == '*');
  148.             if(!exp[y])
  149.                 return 0;
  150.             while(str[x]) {
  151.                 int ret;
  152.                 if((ret = strcmp_match(&str[x++],&exp[y])) != 1)
  153.                     return ret;
  154.             }
  155.             return -1;
  156.         } else 
  157.             if((exp[y] != '?') && (str[x] != exp[y]))
  158.                 return 1;
  159.     }
  160.     return (str[x] != '\0');
  161. }
  162.  
  163. int strcasecmp_match(const char *str, const 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 = strcasecmp_match(&str[x++],&exp[y])) != 1)
  176.                     return ret;
  177.             }
  178.             return -1;
  179.         } else 
  180.             if((exp[y] != '?') && (tolower(str[x]) != tolower(exp[y])))
  181.                 return 1;
  182.     }
  183.     return (str[x] != '\0');
  184. }
  185.  
  186. int is_matchexp(const 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. /* This function substitutes for $0-$9, filling in regular expression
  196.  * submatches. Pass it the same nmatch and pmatch arguments that you
  197.  * passed regexec(). pmatch should not be greater than the maximum number
  198.  * of subexpressions - i.e. one more than the re_nsub member of regex_t.
  199.  *
  200.  * input should be the string with the $-expressions, source should be the
  201.  * string that was matched against.
  202.  *
  203.  * It returns the substituted string, or NULL on error.
  204.  *
  205.  * Parts of this code are based on Henry Spencer's regsub(), from his
  206.  * AT&T V8 regexp package.
  207.  */
  208.  
  209. char *pregsub(pool *p, const char *input, const char *source,
  210.           size_t nmatch, regmatch_t pmatch[]) {
  211.     const char *src = input;
  212.     char *dest, *dst;
  213.     char c;
  214.     int no, len;
  215.  
  216.     if (!source) return NULL;
  217.     if (!nmatch) return pstrdup(p, src);
  218.  
  219.     /* First pass, find the size */
  220.  
  221.     len = 0;
  222.  
  223.     while ((c = *src++) != '\0') {
  224.     if (c == '&')
  225.         no = 0;
  226.     else if (c == '$' && isdigit(*src))
  227.         no = *src++ - '0';
  228.     else
  229.         no = -1;
  230.     
  231.     if (no < 0) {   /* Ordinary character. */
  232.         if (c == '\\' && (*src == '$' || *src == '&'))
  233.         c = *src++;
  234.         len++;
  235.     } else if (no < nmatch && pmatch[no].rm_so < pmatch[no].rm_eo) {
  236.         len += pmatch[no].rm_eo - pmatch[no].rm_so;
  237.     }
  238.  
  239.     }
  240.  
  241.     dest = dst = pcalloc(p, len + 1);
  242.  
  243.     /* Now actually fill in the string */
  244.  
  245.     src = input;
  246.  
  247.     while ((c = *src++) != '\0') {
  248.     if (c == '&')
  249.         no = 0;
  250.     else if (c == '$' && isdigit(*src))
  251.         no = *src++ - '0';
  252.     else
  253.         no = -1;
  254.     
  255.     if (no < 0) {   /* Ordinary character. */
  256.         if (c == '\\' && (*src == '$' || *src == '&'))
  257.         c = *src++;
  258.         *dst++ = c;
  259.     } else if (no < nmatch && pmatch[no].rm_so < pmatch[no].rm_eo) {
  260.         len = pmatch[no].rm_eo - pmatch[no].rm_so;
  261.         strncpy(dst, source + pmatch[no].rm_so, len);
  262.         dst += len;
  263.         if (*(dst-1) == '\0') /* strncpy hit NULL. */
  264.         return NULL;
  265.     }
  266.  
  267.     }
  268.     *dst = '\0';
  269.     
  270.     return dest;
  271. }
  272.  
  273. /*
  274.  * Parse .. so we don't compromise security
  275.  */
  276. void getparents(char *name)
  277. {
  278.     int l, w;
  279.  
  280.     /* Four paseses, as per RFC 1808 */
  281.     /* a) remove ./ path segments */
  282.  
  283.     for (l=0, w=0; name[l] != '\0';)
  284.     {
  285.     if (name[l] == '.' && name[l+1] == '/' && (l == 0 || name[l-1] == '/'))
  286.         l += 2;
  287.     else
  288.         name[w++] = name[l++];
  289.     }
  290.  
  291.     /* b) remove trailing . path, segment */
  292.     if (w == 1 && name[0] == '.') w--;
  293.     else if (w > 1 && name[w-1] == '.' && name[w-2] == '/') w--;
  294.     name[w] = '\0';
  295.  
  296.     /* c) remove all xx/../ segments. (including leading ../ and /../) */
  297.     l = 0;
  298.  
  299.     while(name[l]!='\0') {
  300.         if(name[l] == '.' && name[l+1] == '.' && name[l+2] == '/' &&
  301.         (l == 0 || name[l-1] == '/')) {
  302.         register int m=l+3,n;
  303.  
  304.         l=l-2;
  305.         if(l>=0) {
  306.             while(l >= 0 && name[l] != '/') l--;
  307.             l++;
  308.         }
  309.         else l=0;
  310.         n=l;
  311.         while((name[n]=name[m])) (++n,++m);
  312.             }
  313.     else ++l;
  314.     }
  315.  
  316.     /* d) remove trailing xx/.. segment. */
  317.     if (l == 2 && name[0] == '.' && name[1] == '.') name[0] = '\0';
  318.     else if (l > 2 && name[l-1] == '.' && name[l-2] == '.' && name[l-3] == '/')
  319.     {
  320.     l = l - 4;
  321.     if (l >= 0)
  322.     {
  323.         while (l >= 0 && name[l] != '/') l--;
  324.         l++;
  325.     }
  326.     else l = 0;
  327.     name[l] = '\0';
  328.     }
  329. } 
  330.  
  331. void no2slash(char *name) {
  332.     register int x,y;
  333.  
  334.     for(x=0; name[x];)
  335.         if(x && (name[x-1] == '/') && (name[x] == '/'))
  336.             for(y=x+1;name[y-1];y++)
  337.                 name[y-1] = name[y];
  338.     else x++;
  339. }
  340.  
  341. char *make_dirstr(pool *p, const char *s, int n) {
  342.     register int x,f;
  343.     char *res;
  344.  
  345.     for(x=0,f=0;s[x];x++) {
  346.         if(s[x] == '/')
  347.             if((++f) == n) {
  348.         res = palloc(p, x + 2);
  349.         strncpy (res, s, x);
  350.         res[x] = '/';
  351.         res[x+1] = '\0';
  352.                 return res;
  353.             }
  354.     }
  355.  
  356.     if (s[strlen(s) - 1] == '/')
  357.         return pstrdup (p, s);
  358.     else
  359.         return pstrcat (p, s, "/", NULL);
  360. }
  361.  
  362. int count_dirs(const char *path) {
  363.     register int x,n;
  364.  
  365.     for(x=0,n=0;path[x];x++)
  366.         if(path[x] == '/') n++;
  367.     return n;
  368. }
  369.  
  370.  
  371. void chdir_file(const char *file) {
  372.     int i;
  373.  
  374.     if((i = rind(file,'/')) == -1)
  375.         return;
  376.     ((char *)file)[i] = '\0';
  377.     chdir(file);
  378.     ((char *)file)[i] = '/';
  379. }
  380.  
  381. char *getword_nc(pool* atrans, char **line, char stop)
  382.     {
  383.     return getword(atrans,(const char **)line,stop);
  384.     }
  385.  
  386. char *getword(pool* atrans, const char **line, char stop) {
  387.     int pos = ind(*line, stop);
  388.     char *res;
  389.  
  390.     if (pos == -1) {
  391.         res = pstrdup (atrans, *line);
  392.     *line += strlen (*line);
  393.     return res;
  394.     }
  395.   
  396.     res = palloc(atrans, pos + 1);
  397.     strncpy (res, *line, pos);
  398.     res[pos] = '\0';
  399.     
  400.     while ((*line)[pos] == stop) ++pos;
  401.     
  402.     *line += pos;
  403.     
  404.     return res;
  405. }
  406.  
  407. char *getword_white_nc(pool* atrans, char **line)
  408. {
  409.     return getword_white(atrans,(const char **)line);
  410. }
  411.  
  412. char *getword_white(pool* atrans, const char **line) {
  413.     int pos = -1, x;
  414.     char *res;
  415.  
  416.     for(x=0;(*line)[x];x++) {
  417.         if (isspace((*line)[x])) {
  418.           pos=x;
  419.           break;
  420.       }
  421.    }
  422.  
  423.     if (pos == -1) {
  424.         res = pstrdup (atrans, *line);
  425.       *line += strlen (*line);
  426.       return res;
  427.     }
  428.  
  429.     res = palloc(atrans, pos + 1);
  430.     strncpy (res, *line, pos);
  431.     res[pos] = '\0';
  432.  
  433.     while (isspace((*line)[pos])) ++pos;
  434.  
  435.     *line += pos;
  436.  
  437.     return res;
  438. }
  439.  
  440. char *getword_nulls_nc(pool* atrans, char **line, char stop)
  441. {
  442.     return getword_nulls(atrans,(const char **)line,stop);
  443. }
  444.  
  445. char *getword_nulls(pool* atrans, const char **line, char stop) {
  446.     int pos = ind(*line, stop);
  447.     char *res;
  448.  
  449.     if (pos == -1) {
  450.         res = pstrdup (atrans, *line);
  451.     *line += strlen (*line);
  452.     return res;
  453.     }
  454.   
  455.     res = palloc(atrans, pos + 1);
  456.     strncpy (res, *line, pos);
  457.     res[pos] = '\0';
  458.     
  459.     ++pos;
  460.     
  461.     *line += pos;
  462.     
  463.     return res;
  464. }
  465.  
  466. /* Get a word, (new) config-file style --- quoted strings and backslashes
  467.  * all honored
  468.  */
  469.  
  470. static char *substring_conf (pool *p, const char *start, int len, char quote)
  471. {
  472.     char *result = palloc (p, len + 2);
  473.     char *resp = result;
  474.     int i;
  475.  
  476.     for (i = 0; i < len; ++i) {
  477.         if (start[i] == '\\' && (start[i+1] == '/'
  478.                  || (quote && start[i+1] == quote)))
  479.         *resp++ = start[++i];
  480.     else
  481.         *resp++ = start[i];
  482.     }
  483.  
  484.     *resp++ = '\0';
  485.     return result;
  486. }
  487.  
  488. char *getword_conf_nc(pool* p, char **line) {
  489.     return getword_conf(p,(const char **)line);
  490. }
  491.  
  492. char *getword_conf(pool* p, const char **line) {
  493.     const char *str = *line, *strend;
  494.     char *res;
  495.     char quote;
  496.  
  497.     while (*str && isspace (*str))
  498.         ++str;
  499.  
  500.     if (!*str) {
  501.         *line = str;
  502.         return "";
  503.     }
  504.  
  505.     if ((quote = *str) == '"' || quote == '\'') {
  506.         strend = str + 1;
  507.     while (*strend && *strend != quote) {
  508.         if (*strend == '\\' && strend[1] && strend[1] == quote)
  509.         strend += 2;
  510.         else ++strend;
  511.     }
  512.     res = substring_conf (p, str + 1, strend - str - 1, quote);
  513.  
  514.     if (*strend == quote) ++strend;
  515.     } else {
  516.         strend = str;
  517.     while (*strend && !isspace (*strend))
  518.         ++strend;
  519.  
  520.     res = substring_conf (p, str, strend - str, 0);
  521.     }
  522.  
  523.     while (*strend && isspace(*strend)) ++ strend;
  524.     *line = strend;
  525.     return res;
  526. }
  527.  
  528. #ifdef UNDEF
  529. /* this function is dangerous, and superceded by getword_white, so don't use it
  530.  */
  531. void cfg_getword(char *word, char *line) {
  532.     int x=0,y;
  533.     
  534.     for(x=0;line[x] && isspace(line[x]);x++);
  535.     y=0;
  536.     while(1) {
  537.         if(!(word[y] = line[x]))
  538.             break;
  539.         if(isspace(line[x]))
  540.             if((!x) || (line[x-1] != '\\'))
  541.                 break;
  542.         if(line[x] != '\\') ++y;
  543.         ++x;
  544.     }
  545.     word[y] = '\0';
  546.     while(line[x] && isspace(line[x])) ++x;
  547.     for(y=0;(line[y] = line[x]);++x,++y);
  548. }
  549. #endif
  550.  
  551. int
  552. cfg_getline(char *s, int n, FILE *f) {
  553.     register int i=0, c;
  554.  
  555.     s[0] = '\0';
  556.     /* skip leading whitespace */
  557.     do {
  558.         c = getc(f);
  559.     } while (c == '\t' || c == ' ');
  560.  
  561.     if(c == EOF)
  562.     return 1;
  563.  
  564.     while(1) {
  565.         if((c == '\t') || (c == ' ')) {
  566.             s[i++] = ' ';
  567.             while((c == '\t') || (c == ' ')) 
  568.                 c = getc(f);
  569.         }
  570.         if(c == CR) {
  571.             c = getc(f);
  572.         }
  573.         if(c == EOF || c == 0x4 || c == LF || i == (n-1)) {
  574.             /* blast trailing whitespace */
  575.             while(i && (s[i-1] == ' ')) --i;
  576.             s[i] = '\0';
  577.         return 0;
  578.         }
  579.         s[i] = c;
  580.         ++i;
  581.         c = getc(f);
  582.     }
  583. }
  584.  
  585. /* Retrieve a token, spacing over it and returning a pointer to
  586.  * the first non-white byte afterwards.  Note that these tokens
  587.  * are delimited by semis and commas; and can also be delimited
  588.  * by whitespace at the caller's option.
  589.  */
  590.  
  591. char *get_token (pool *p, char **accept_line, int accept_white)
  592. {
  593.     char *ptr = *accept_line;
  594.     char *tok_start;
  595.     char *token;
  596.     int tok_len;
  597.   
  598.     /* Find first non-white byte */
  599.     
  600.     while (*ptr && isspace(*ptr))
  601.       ++ptr;
  602.  
  603.     tok_start = ptr;
  604.     
  605.     /* find token end, skipping over quoted strings.
  606.      * (comments are already gone).
  607.      */
  608.     
  609.     while (*ptr && (accept_white || !isspace(*ptr))
  610.        && *ptr != ';' && *ptr != ',')
  611.     {
  612.     if (*ptr++ == '"')
  613.         while (*ptr)
  614.             if (*ptr++ == '"') break;
  615.     }
  616.       
  617.     tok_len = ptr - tok_start;
  618.     token = palloc (p, tok_len + 1);
  619.     strncpy (token, tok_start, tok_len);
  620.     token[tok_len] = '\0';
  621.     
  622.     /* Advance accept_line pointer to the next non-white byte */
  623.  
  624.     while (*ptr && isspace(*ptr))
  625.       ++ptr;
  626.  
  627.     *accept_line = ptr;
  628.     return token;
  629. }
  630.  
  631. static char* tspecials = " \t()<>@,;:\\/[]?={}";
  632.  
  633. /* Next HTTP token from a header line.  Warning --- destructive!
  634.  * Use only with a copy!
  635.  */
  636.  
  637. static char *next_token (char **toks) {
  638.     char *cp = *toks;
  639.     char *ret;
  640.  
  641.     while (*cp && (iscntrl (*cp) || strchr (tspecials, *cp))) {
  642.         if (*cp == '"')
  643.       while (*cp && (*cp != '"')) ++cp;
  644.     else
  645.       ++cp;
  646.     }
  647.  
  648.     if (!*cp) ret = NULL;
  649.     else {
  650.         ret = cp;
  651.  
  652.         while (*cp && !iscntrl(*cp) && !strchr (tspecials, *cp))
  653.             ++cp;
  654.  
  655.         if (*cp) {
  656.             *toks = cp + 1;
  657.             *cp = '\0';
  658.     }
  659.         else *toks = cp;
  660.     }
  661.  
  662.     return ret;
  663. }
  664.  
  665. int find_token (pool *p, const char *line, const char *tok) {
  666.     char *ltok;
  667.     char *lcopy;
  668.  
  669.     if (!line) return 0;
  670.  
  671.     lcopy = pstrdup (p, line);
  672.     while ((ltok = next_token (&lcopy)))
  673.         if (!strcasecmp (ltok, tok))
  674.             return 1;
  675.  
  676.     return 0;
  677. }
  678.  
  679. int find_last_token (pool *p, const char *line, const char *tok)
  680. {
  681.     int llen, tlen, lidx;
  682.  
  683.     if (!line) return 0;
  684.  
  685.     llen = strlen(line);
  686.     tlen = strlen(tok);
  687.     lidx = llen - tlen;
  688.  
  689.     if ((lidx < 0) ||
  690.         ((lidx > 0) && !(isspace(line[lidx-1]) || line[lidx-1] == ',')))
  691.         return 0;
  692.  
  693.     return (strncasecmp(&line[lidx], tok, tlen) == 0);
  694. }
  695.  
  696. char *escape_shell_cmd(pool *p, const char *s) {
  697.     register int x,y,l;
  698.     char *cmd;
  699.  
  700.     l=strlen(s);
  701.     cmd = palloc (p, 2 * l + 1); /* Be safe */
  702.     strcpy (cmd, s);
  703.     
  704.     for(x=0;cmd[x];x++) {
  705.     
  706. #ifdef __EMX__
  707.         /* Don't allow '&' in parameters under OS/2. */
  708.         /* This can be used to send commands to the shell. */
  709.         if (cmd[x] == '&') {
  710.             cmd[x] = ' ';
  711.         }
  712. #endif
  713.  
  714.         if(ind("&;`'\"|*?~<>^()[]{}$\\\n",cmd[x]) != -1){
  715.             for(y=l+1;y>x;y--)
  716.                 cmd[y] = cmd[y-1];
  717.             l++; /* length has been increased */
  718.             cmd[x] = '\\';
  719.             x++; /* skip the character */
  720.         }
  721.     }
  722.  
  723.     return cmd;
  724. }
  725.  
  726. void plustospace(char *str) {
  727.     register int x;
  728.  
  729.     for(x=0;str[x];x++) if(str[x] == '+') str[x] = ' ';
  730. }
  731.  
  732. void spacetoplus(char *str) {
  733.     register int x;
  734.  
  735.     for(x=0;str[x];x++) if(str[x] == ' ') str[x] = '+';
  736. }
  737.  
  738. static char x2c(const char *what) {
  739.     register char digit;
  740.  
  741.     digit = ((what[0] >= 'A') ? ((what[0] & 0xdf) - 'A')+10 : (what[0] - '0'));
  742.     digit *= 16;
  743.     digit += (what[1] >= 'A' ? ((what[1] & 0xdf) - 'A')+10 : (what[1] - '0'));
  744.     return(digit);
  745. }
  746.  
  747. /*
  748.  * Unescapes a URL.
  749.  * Returns 0 on success, non-zero on error
  750.  * Failure is due to
  751.  *   bad % escape       returns BAD_REQUEST
  752.  *
  753.  *   decoding %00 -> \0
  754.  *   decoding %2f -> /   (a special character)
  755.  *                      returns NOT_FOUND
  756.  */
  757. int
  758. unescape_url(char *url) {
  759.     register int x,y, badesc, badpath;
  760.  
  761.     badesc = 0;
  762.     badpath = 0;
  763.     for(x=0,y=0;url[y];++x,++y) {
  764.     if (url[y] != '%') url[x] = url[y];
  765.     else
  766.     {
  767.         if (!isxdigit(url[y+1]) || !isxdigit(url[y+2]))
  768.         {
  769.         badesc = 1;
  770.         url[x] = '%';
  771.         } else
  772.         {
  773.         url[x] = x2c(&url[y+1]);
  774.         y += 2;
  775.         if (url[x] == '/' || url[x] == '\0') badpath = 1;
  776.         }
  777.         }
  778.     }
  779.     url[x] = '\0';
  780.     if (badesc) return BAD_REQUEST;
  781.     else if (badpath) return NOT_FOUND;
  782.     else return OK;
  783. }
  784.  
  785. char *construct_server(pool *p, const char *hostname, unsigned port) {
  786.     char portnum[22];        
  787.     /* Long enough, even if port > 16 bits for some reason */
  788.   
  789.     if (port == DEFAULT_PORT)
  790.     return (char *)hostname;
  791.     else {
  792.         ap_snprintf (portnum, sizeof(portnum), "%u", port);
  793.     return pstrcat (p, hostname, ":", portnum, NULL);
  794.     }
  795. }
  796.  
  797. char *construct_url(pool *p, const char *uri, const server_rec *s) {
  798.     return pstrcat (p, "http://",
  799.             construct_server(p, s->server_hostname, s->port),
  800.             uri, NULL);
  801. }
  802.  
  803. #define c2x(what,where) sprintf(where,"%%%02x",(unsigned char)what)
  804.  
  805. /*
  806. escape_path_segment() escapes a path segment, as defined in RFC 1808. This
  807. routine is (should be) OS independent.
  808.  
  809. os_escape_path() converts an OS path to a URL, in an OS dependent way. In all
  810. cases if a ':' occurs before the first '/' in the URL, the URL should be
  811. prefixed with "./" (or the ':' escaped). In the case of Unix, this means
  812. leaving '/' alone, but otherwise doing what escape_path_segment() does. For
  813. efficiency reasons, we don't use escape_path_segment(), which is provided for
  814. reference. Again, RFC 1808 is where this stuff is defined.
  815.  
  816. If partial is set, os_escape_path() assumes that the path will be appended to
  817. something with a '/' in it (and thus does not prefix "./").
  818. */
  819.  
  820. char *escape_path_segment(pool *p, const char *segment) {
  821.     register int x,y;
  822.     char *copy = palloc (p, 3 * strlen (segment) + 1);
  823.             
  824.     for(x=0,y=0; segment[x]; x++,y++) {
  825.       char c=segment[x];
  826.       if((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c >'9')
  827.      && ind("$-_.+!*'(),:@&=~",c) == -1)
  828.     {
  829.       c2x(c,©[y]);
  830.       y+=2;
  831.     }
  832.       else
  833.     copy[y]=c;
  834.     }
  835.     copy[y] = '\0';
  836.     return copy;
  837. }
  838.  
  839. char *os_escape_path(pool *p,const char *path,int partial) {
  840.   char *copy=palloc(p,3*strlen(path)+3);
  841.   char *s=copy;
  842.  
  843.   if(!partial)
  844.     {
  845.       int colon=ind(path,':');
  846.       int slash=ind(path,'/');
  847.  
  848.       if(colon >= 0 && (colon < slash || slash < 0))
  849.     {
  850.       *s++='.';
  851.       *s++='/';
  852.     }
  853.     }
  854.   for( ; *path ; ++path)
  855.     {
  856.       char c=*path;
  857.       if((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c >'9')
  858.      && ind("$-_.+!*'(),:@&=/~",c) == -1)
  859.     {
  860.       c2x(c,s);
  861.       s+=3;
  862.     }
  863.       else
  864.     *s++=c;
  865.     }
  866.   *s='\0';
  867.   return copy;
  868. }
  869.  
  870. /* escape_uri is now a macro for os_escape_path */
  871.  
  872. char *escape_html(pool *p, const char *s)
  873. {
  874.     int i, j;
  875.     char *x;
  876.  
  877. /* first, count the number of extra characters */
  878.     for (i=0, j=0; s[i] != '\0'; i++)
  879.     if (s[i] == '<' || s[i] == '>') j += 3;
  880.     else if (s[i] == '&') j += 4;
  881.  
  882.     if (j == 0) return pstrdup(p, s);
  883.     x = palloc(p, i + j + 1);
  884.     for (i=0, j=0; s[i] != '\0'; i++, j++)
  885.     if (s[i] == '<')
  886.     {
  887.         memcpy(&x[j], "<", 4);
  888.         j += 3;
  889.     } else if (s[i] == '>')
  890.     {
  891.         memcpy(&x[j], ">", 4);
  892.         j += 3;
  893.     } else if (s[i] == '&')
  894.     {
  895.         memcpy(&x[j], "&", 5);
  896.         j += 4;
  897.     } else
  898.             x[j] = s[i];
  899.  
  900.     x[j] = '\0';
  901.     return x;
  902. }
  903.  
  904. int is_directory(const char *path) {
  905.     struct stat finfo;
  906.  
  907.     if(stat(path,&finfo) == -1)
  908.         return 0; /* in error condition, just return no */
  909.  
  910.     return(S_ISDIR(finfo.st_mode));
  911. }
  912.  
  913. char *make_full_path(pool *a, const char *src1, const char *src2) {
  914.     register int x;
  915.  
  916.     x = strlen(src1);
  917.     if (x == 0) return pstrcat (a, "/", src2, NULL);
  918.  
  919.     if (src1[x - 1] != '/') return pstrcat (a, src1, "/", src2, NULL);
  920.     else return pstrcat (a, src1, src2, NULL);
  921. }
  922.  
  923. /*
  924.  * Check for an absoluteURI syntax (see section 3.2 in RFC2068).
  925.  */
  926. int is_url(const char *u) {
  927.     register int x;
  928.  
  929.     for (x = 0; u[x] != ':'; x++) {
  930.         if ((! u[x]) ||
  931.         ((! isalpha(u[x])) && (! isdigit(u[x])) &&
  932.          (u[x] != '+') && (u[x] != '-') && (u[x] != '.'))) {
  933.             return 0;
  934.     }
  935.     }
  936.  
  937.     return (x ? 1 : 0);  /* If the first character is ':', it's broken, too */
  938. }
  939.  
  940. int can_exec(const struct stat *finfo) {
  941. #ifdef MULTIPLE_GROUPS
  942.   int cnt;
  943. #endif
  944. #ifdef __EMX__
  945.     /* OS/2 dosen't have Users and Groups */
  946.     return 1;
  947. #else    
  948.     if(user_id == finfo->st_uid)
  949.         if(finfo->st_mode & S_IXUSR)
  950.             return 1;
  951.     if(group_id == finfo->st_gid)
  952.         if(finfo->st_mode & S_IXGRP)
  953.             return 1;
  954. #ifdef MULTIPLE_GROUPS
  955.     for(cnt=0; cnt < NGROUPS_MAX; cnt++) {
  956.         if(group_id_list[cnt] == finfo->st_gid)
  957.             if(finfo->st_mode & S_IXGRP)
  958.                 return 1;
  959.     }
  960. #endif
  961.     return (finfo->st_mode & S_IXOTH);
  962. #endif    
  963. }
  964.  
  965. #ifdef NEED_STRDUP
  966. char *strdup (const char *str)
  967. {
  968.   char *dup;
  969.  
  970.   if(!(dup = (char *)malloc (strlen (str) + 1)))
  971.       return NULL;
  972.   dup = strcpy (dup, str);
  973.  
  974.   return dup;
  975. }
  976. #endif
  977.  
  978. /* The following two routines were donated for SVR4 by Andreas Vogel */
  979. #ifdef NEED_STRCASECMP
  980. int strcasecmp (const char *a, const char *b)
  981. {
  982.     const char *p = a;
  983.     const char *q = b;
  984.     for (p = a, q = b; *p && *q; p++, q++)
  985.     {
  986.       int diff = tolower(*p) - tolower(*q);
  987.       if (diff) return diff;
  988.     }
  989.     if (*p) return 1;       /* p was longer than q */
  990.     if (*q) return -1;      /* p was shorter than q */
  991.     return 0;               /* Exact match */
  992. }
  993.  
  994. #endif
  995.  
  996. #ifdef NEED_STRNCASECMP
  997. int strncasecmp (const char *a, const char *b, int n)
  998. {
  999.     const char *p = a;
  1000.     const char *q = b;
  1001.  
  1002.     for (p = a, q = b; /*NOTHING*/; p++, q++)
  1003.     {
  1004.       int diff;
  1005.       if (p == a + n) return 0;     /*   Match up to n characters */
  1006.       if (!(*p && *q)) return *p - *q;
  1007.       diff = tolower(*p) - tolower(*q);
  1008.       if (diff) return diff;
  1009.     }
  1010.     /*NOTREACHED*/
  1011. }
  1012. #endif
  1013.  
  1014.  
  1015.  
  1016. #ifdef NEED_INITGROUPS
  1017. int initgroups(const char *name, gid_t basegid)
  1018. {
  1019. #if defined(QNX) || defined(MPE)
  1020. /* QNX and MPE do not appear to support supplementary groups. */
  1021.     return 0;
  1022. #else /* ndef QNX */
  1023.   gid_t groups[NGROUPS_MAX];
  1024.   struct group *g;
  1025.   int index = 0;
  1026.  
  1027.   setgrent();
  1028.  
  1029.   groups[index++] = basegid;
  1030.  
  1031.   while (index < NGROUPS_MAX && ((g = getgrent()) != NULL))
  1032.     if (g->gr_gid != basegid)
  1033.     {
  1034.       char **names;
  1035.  
  1036.       for (names = g->gr_mem; *names != NULL; ++names)
  1037.         if (!strcmp(*names, name))
  1038.           groups[index++] = g->gr_gid;
  1039.     }
  1040.  
  1041.   endgrent();
  1042.  
  1043.   return setgroups(index, groups);
  1044. #endif /* def QNX */
  1045. }
  1046. #endif /* def NEED_INITGROUPS */
  1047.  
  1048. #ifdef NEED_WAITPID
  1049. /* From ikluft@amdahl.com */
  1050. /* this is not ideal but it works for SVR3 variants */
  1051. /* httpd does not use the options so this doesn't implement them */
  1052. int waitpid(pid_t pid, int *statusp, int options)
  1053. {
  1054.     int tmp_pid;
  1055.     if ( kill ( pid,0 ) == -1) {
  1056.         errno=ECHILD;
  1057.         return -1;
  1058.     }
  1059.     while ((( tmp_pid = wait(statusp)) != pid) && ( tmp_pid != -1 ));
  1060.     return tmp_pid;
  1061. }
  1062. #endif
  1063.  
  1064. int ind(const char *s, char c) {
  1065.     register int x;
  1066.  
  1067.     for(x=0;s[x];x++)
  1068.         if(s[x] == c) return x;
  1069.  
  1070.     return -1;
  1071. }
  1072.  
  1073. int rind(const char *s, char c) {
  1074.     register int x;
  1075.  
  1076.     for(x=strlen(s)-1;x != -1;x--)
  1077.         if(s[x] == c) return x;
  1078.  
  1079.     return -1;
  1080. }
  1081.  
  1082. void str_tolower(char *str) {
  1083.     while(*str) {
  1084.         *str = tolower(*str);
  1085.         ++str;
  1086.     }
  1087. }
  1088.         
  1089. uid_t uname2id(const char *name) {
  1090.     struct passwd *ent;
  1091.  
  1092.     if(name[0] == '#') 
  1093.         return(atoi(&name[1]));
  1094.  
  1095.     if(!(ent = getpwnam(name))) {
  1096.         fprintf(stderr,"httpd: bad user name %s\n",name);
  1097.         exit(1);
  1098.     }
  1099.     return(ent->pw_uid);
  1100. }
  1101.  
  1102. gid_t gname2id(const char *name) {
  1103.     struct group *ent;
  1104.  
  1105.     if(name[0] == '#') 
  1106.         return(atoi(&name[1]));
  1107.  
  1108.     if(!(ent = getgrnam(name))) {
  1109.         fprintf(stderr,"httpd: bad group name %s\n",name);
  1110.         exit(1);
  1111.     }
  1112.     return(ent->gr_gid);
  1113. }
  1114.  
  1115. #if 0
  1116. int get_portnum(int sd) {
  1117.     struct sockaddr addr;
  1118.     int len;
  1119.  
  1120.     len = sizeof(struct sockaddr);
  1121.     if(getsockname(sd,&addr,&len) < 0)
  1122.         return -1;
  1123.     return ntohs(((struct sockaddr_in *)&addr)->sin_port);
  1124. }
  1125.  
  1126. struct in_addr get_local_addr(int sd) {
  1127.     struct sockaddr addr;
  1128.     int len;
  1129.  
  1130.     len = sizeof(struct sockaddr);
  1131.     if(getsockname(sd,&addr,&len) < 0) {
  1132.     perror ("getsockname");
  1133.         fprintf (stderr, "Can't get local host address!\n");
  1134.     exit(1);
  1135.     }
  1136.          
  1137.     return ((struct sockaddr_in *)&addr)->sin_addr;
  1138. }
  1139. #endif
  1140.  
  1141. /*
  1142.  * Parses a host of the form <address>[:port]
  1143.  * :port is permitted if 'port' is not NULL
  1144.  */
  1145. unsigned long get_virthost_addr (const char *w, unsigned short *ports) {
  1146.     struct hostent *hep;
  1147.     unsigned long my_addr;
  1148.     char *p;
  1149.  
  1150.     p = strchr(w, ':');
  1151.     if (ports != NULL)
  1152.     {
  1153.     *ports = 0;
  1154.     if (p != NULL && strcmp(p+1, "*") != 0) *ports = atoi(p+1);
  1155.     }
  1156.  
  1157.     if (p != NULL) *p = '\0';
  1158.     if (strcmp(w, "*") == 0)
  1159.     {
  1160.     if (p != NULL) *p = ':';
  1161.     return htonl(INADDR_ANY);
  1162.     }
  1163.     
  1164. #ifdef DGUX
  1165.     my_addr = inet_network(w);
  1166. #else
  1167.     my_addr = inet_addr(w);
  1168. #endif
  1169.     if (my_addr != INADDR_NONE)
  1170.     {
  1171.     if (p != NULL) *p = ':';
  1172.     return my_addr;
  1173.     }
  1174.  
  1175.     hep = gethostbyname(w);
  1176.         
  1177.     if ((!hep) || (hep->h_addrtype != AF_INET || !hep->h_addr_list[0])) {
  1178.     fprintf (stderr, "Cannot resolve host name %s --- exiting!\n", w);
  1179.     exit(1);
  1180.     }
  1181.         
  1182.     if (hep->h_addr_list[1]) {
  1183.     fprintf(stderr, "Host %s has multiple addresses ---\n", w);
  1184.     fprintf(stderr, "you must choose one explicitly for use as\n");
  1185.     fprintf(stderr, "a virtual host.  Exiting!!!\n");
  1186.     exit(1);
  1187.     }
  1188.         
  1189.     if (p != NULL) *p = ':';
  1190.  
  1191.     return ((struct in_addr *)(hep->h_addr))->s_addr;
  1192. }
  1193.  
  1194.  
  1195. static char *find_fqdn(pool *a, struct hostent *p) {
  1196.     int x;
  1197.  
  1198.     if(ind(p->h_name,'.') == -1) {
  1199.         for(x=0;p->h_aliases[x];++x) {
  1200.             if((ind(p->h_aliases[x],'.') != -1) && 
  1201.                (!strncmp(p->h_aliases[x],p->h_name,strlen(p->h_name))))
  1202.                 return pstrdup(a, p->h_aliases[x]);
  1203.         }
  1204.         return NULL;
  1205.     }
  1206.     return pstrdup(a, (void *)p->h_name);
  1207. }
  1208.  
  1209. char *get_local_host(pool *a)
  1210. {
  1211. #ifndef MAXHOSTNAMELEN
  1212. #define MAXHOSTNAMELEN 256
  1213. #endif
  1214.     char str[MAXHOSTNAMELEN+1];
  1215.     char *server_hostname;
  1216.     struct hostent *p;
  1217.  
  1218.     if( gethostname( str, sizeof( str ) - 1 ) != 0 ) {
  1219.     perror( "Unable to gethostname" );
  1220.     exit(1);
  1221.     }
  1222.     str[MAXHOSTNAMELEN] = '\0';
  1223.     if((!(p=gethostbyname(str))) || (!(server_hostname = find_fqdn(a, p)))) {
  1224.         fprintf(stderr,"httpd: cannot determine local host name.\n");
  1225.     fprintf(stderr,"Use ServerName to set it manually.\n");
  1226.     exit(1);
  1227.     }
  1228.  
  1229.     return server_hostname;
  1230. }
  1231.  
  1232. /* aaaack but it's fast and const should make it shared text page. */
  1233. const int pr2six[256]={
  1234.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1235.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,62,64,64,64,63,
  1236.     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,
  1237.     10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,64,64,64,64,64,64,26,27,
  1238.     28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
  1239.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1240.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1241.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1242.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1243.     64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
  1244.     64,64,64,64,64,64,64,64,64,64,64,64,64
  1245. };
  1246.  
  1247. char *uudecode(pool *p, const char *bufcoded) {
  1248.     int nbytesdecoded;
  1249.     register unsigned char *bufin;
  1250.     register char *bufplain;
  1251.     register unsigned char *bufout;
  1252.     register int nprbytes;
  1253.     
  1254.     /* Strip leading whitespace. */
  1255.     
  1256.     while(*bufcoded==' ' || *bufcoded == '\t') bufcoded++;
  1257.     
  1258.     /* Figure out how many characters are in the input buffer.
  1259.      * Allocate this many from the per-transaction pool for the result.
  1260.      */
  1261.     bufin = (unsigned char *)bufcoded;
  1262.     while(pr2six[*(bufin++)] <= 63);
  1263.     nprbytes = (char *)bufin - bufcoded - 1;
  1264.     nbytesdecoded = ((nprbytes+3)/4) * 3;
  1265.  
  1266.     bufplain = palloc(p, nbytesdecoded + 1);
  1267.     bufout = (unsigned char *)bufplain;
  1268.     
  1269.     bufin = (unsigned char *)bufcoded;
  1270.     
  1271.     while (nprbytes > 0) {
  1272.         *(bufout++) = 
  1273.             (unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
  1274.         *(bufout++) = 
  1275.             (unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
  1276.         *(bufout++) = 
  1277.             (unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
  1278.         bufin += 4;
  1279.         nprbytes -= 4;
  1280.     }
  1281.     
  1282.     if(nprbytes & 03) {
  1283.         if(pr2six[bufin[-2]] > 63)
  1284.             nbytesdecoded -= 2;
  1285.         else
  1286.             nbytesdecoded -= 1;
  1287.     }
  1288.     bufplain[nbytesdecoded] = '\0';
  1289.     return bufplain;
  1290. }
  1291.  
  1292. #ifdef __EMX__
  1293. void os2pathname(char *path) {
  1294.     char newpath[MAX_STRING_LEN];
  1295.     int loop;
  1296.     int offset;
  1297.  
  1298.     offset = 0;
  1299.     for (loop=0; loop < (strlen(path) + 1) && loop < sizeof(newpath)-1; loop++) {
  1300.         if (path[loop] == '/') {
  1301.             newpath[offset] = '\\';
  1302.             /*
  1303.             offset = offset + 1;
  1304.             newpath[offset] = '\\';
  1305.             */
  1306.         } else
  1307.             newpath[offset] = path[loop];
  1308.         offset = offset + 1;
  1309.     };
  1310.     /* Debugging code */
  1311.     /* fprintf(stderr, "%s \n", newpath); */
  1312.  
  1313.     strcpy(path, newpath);
  1314. };
  1315. #endif
  1316.  
  1317.  
  1318. #ifdef NEED_STRERROR
  1319. char *
  1320. strerror (int err) {
  1321.  
  1322.     char *p;
  1323.     extern char *const sys_errlist[];
  1324.  
  1325.     p = sys_errlist[err];
  1326.     return (p);
  1327. }
  1328. #endif
  1329.  
  1330.  
  1331. int ap_slack (int fd, int line)
  1332. {
  1333. #if !defined(F_DUPFD) || defined(NO_SLACK)
  1334.     return fd;
  1335. #else
  1336.     int new_fd;
  1337.  
  1338. #ifdef HIGH_SLACK_LINE
  1339.     if (line == AP_SLACK_HIGH) {
  1340.     new_fd = fcntl (fd, F_DUPFD, HIGH_SLACK_LINE);
  1341.     if (new_fd != -1) {
  1342.         close (fd);
  1343.         return new_fd;
  1344.     }
  1345.     }
  1346. #endif
  1347.     /* otherwise just assume line == AP_SLACK_LOW */
  1348.     new_fd = fcntl (fd, F_DUPFD, LOW_SLACK_LINE);
  1349.     if (new_fd == -1) {
  1350.       return fd;
  1351.     }
  1352.     close (fd);
  1353.     return new_fd;
  1354. #endif
  1355. }
  1356.