开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Web服务器 > 查看源码
url.c
资源名称：phttpd-1.10.04.tar.gz　[点击查看]
上传用户：ladybrid91
上传日期：2007-01-04
资源大小：287k
文件大小：14k
源码类别：

Web服务器

开发平台：

Unix_Linux

url.c：源码内容
  1. /*
  2. ** url.c
  3. **
  4. ** Copyright (c) 1994-1997 Peter Eriksson <pen@signum.se>
  5. **
  6. ** This program is free software; you can redistribute it and/or modify
  7. ** it under the terms of the GNU General Public License as published by
  8. ** the Free Software Foundation; either version 2 of the License, or
  9. ** (at your option) any later version.
  10. **
  11. ** This program is distributed in the hope that it will be useful,
  12. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. ** GNU General Public License for more details.
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software
  17. ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  20. #include <stdio.h>
  21. #include <alloca.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <pwd.h>
  25. #include <unistd.h>
  26. #include <errno.h>
  27. #include <syslog.h>
  29. #include <sys/types.h>
  30. #include <sys/stat.h>
  32. #define IN_DNS_C
  33. #include "phttpd.h"
  36. #define HTOI(c) (((c) >= 'A') ? (((c) & 0xDF) - 'A') + 10 : (c) - '0')
  39. struct table *url_handlers_table = NULL;
  40. struct table *url_redirects_table = NULL;
  41. struct table *url_predirects_table = NULL;
  42. struct table *url_rewrites_table = NULL;
  43. struct table *read_authenticate_table = NULL;
  44. struct table *write_authenticate_table = NULL;
  45. struct table *host_access_table = NULL;
  46. struct table *url_expand_table = NULL;
  47. struct table *content_language_table = NULL;
  50. char *expand_symlink(const char *path,
  51.      char *realpath,
  52.      int maxsize)
  53. {
  54.     char *buf;
  55.     char *cp;
  56.     int len;
  57.     
  59.     buf = (char *) alloca(maxsize+1);
  60.     if (buf == NULL)
  61. return NULL;
  62.     
  63.     if ((len = s_readlink(path, buf, maxsize)) < 0)
  64.     {
  65. if (errno == EINVAL)
  66. {
  67.     s_strcpy(realpath, maxsize, path);
  68.     return realpath;
  69. }
  70. return NULL;
  71.     }
  72.     
  73.     buf[len] = '';
  75.     if (buf[0] == '/')
  76. s_strcpy(realpath, maxsize, buf);
  77.     else
  78.     {
  79. cp = strrchr(path, '/'); /* Find last / in filename */
  80. if (cp)
  81. {
  82.     s_strcpy(realpath, maxsize, path);
  83.     s_strcpy(realpath + (cp - path) + 1, maxsize, buf);
  84. }
  85. else
  86.     s_strcpy(realpath, maxsize, buf);
  87.     }
  89.     return realpath;
  90. }
  93. char *url_expand(const char *path,
  94.  char *realpath,
  95.  int maxsize,
  96.  struct stat *sp,
  97.  uid_t *uid,
  98.  gid_t *gid)
  99. {
  100.     const char *cp;
  101.     char *outpath;
  102.     struct passwd *pwp;
  103.     void *uc_key;
  104.     char buf[2048];
  105.     char name[64];
  106.     char *end;
  107.     int len;
  108.     int i;
  110.     outpath = (char *) alloca(maxsize);
  111.     if (outpath == NULL)
  112. return NULL;
  114.     /* An URL must begin with a '/' */
  115.     if (*path++ != '/')
  116. return NULL;
  118.     /* And the second character must NOT be a '/' */
  119.     if (*path == '/')
  120. return NULL;
  121.     
  122.     /* "/../" is not allowed in the path */
  123.     for (cp = path-1; *cp; cp++)
  124. if (cp[0] == '/' && cp[1] == '.' && cp[2] == '.' &&
  125.     (cp[3] == '/' || cp[3] == ''))
  126. {
  127.     return NULL;
  128. }
  130.     /* Handle ~user expansion */
  131.     if (*path == '~')
  132.     {
  133. /* Locate end of username */
  134. end = strchr(++path, '/');
  135. if (end)
  136. {
  137.     len = end - path;
  138.     if (len+1 > sizeof(buf))
  139. len = sizeof(buf)-1;
  140. }
  141. else
  142.     len = strlen(path);
  143.     
  144. s_strncpy(name, sizeof(name), path, len);
  146. if ((uc_key = usercache_lookup(name, 0, &pwp)) == NULL)
  147.     return NULL;
  149. if (pwp == NULL || pwp->pw_dir == NULL)
  150. {
  151.     usercache_release(uc_key);
  152.     return NULL;
  153. }
  155. if (uid)
  156.     *uid = pwp->pw_uid;
  157. if (gid)
  158.     *gid = pwp->pw_gid;
  160. if (user_basedir)
  161. {
  162.     len = s_strcpy(outpath, maxsize, user_basedir);
  163.     if (len > 0 && outpath[len-1] != '/')
  164. s_strcat(outpath, maxsize, "/");
  165.     len = s_strcat(outpath, maxsize, name);
  166. }
  167. else
  168.     len = s_strcpy(outpath, maxsize, pwp->pw_dir);
  170. if (user_dir && user_dir[0])
  171. {
  172.     if (len > 0 && outpath[len-1] != '/')
  173. len = s_strcat(outpath, maxsize, "/");
  174.     
  175.     s_strcat(outpath, maxsize, user_dir);
  176. }
  178. if (end)
  179.     s_strcat(outpath, maxsize, end);
  181. usercache_release(uc_key);
  182.     }
  183.     else
  184. s_strcpy(outpath, maxsize, path);
  185.     
  186.     i = strlen(outpath) - 1;
  187.     while (i >= 0 && outpath[i] == '/')
  188. i--;
  190.     outpath[i+1] = '';
  192.     if (outpath[0] == '')
  193. s_strcpy(outpath, maxsize, ".");
  194.     
  195.     if (sp && s_stat(outpath, sp) < 0)
  196. return NULL;
  198.     s_strcpy(realpath, maxsize, outpath);
  199.     return realpath;
  200. }
  204. char *url_getparent(const char *path, char *buf, int bufsize)
  205. {
  206.     char *cp;
  208.     
  209.     s_strcpy(buf, bufsize, path);
  211.     cp = strrchr(buf, '/');
  212.     if (cp && cp > buf)
  213.     {
  214. /* Remove trailing '/' */
  215. *cp = '';
  217. cp = strrchr(buf, '/');
  218. if (cp)
  219.     *++cp = '';
  220. else
  221. {
  222.     s_strcpy(buf, bufsize, "/");
  223.     return buf;
  224. }
  226. return buf;
  227.     }
  228.     else
  229.     {
  230. s_strcpy(buf, bufsize, "/");
  231. return buf;
  232.     }
  233. }
  236. char *url_quote(const char *from,
  237. char *to,
  238. int size,
  239. char *quotemap,
  240. int only_qm)
  241. {
  242.     static const char bin2hex[] = "0123456789ABCDEF";
  243.     char *retval;
  244.     const unsigned char *fp;
  245.     
  247.     fp = (const unsigned char *) from;
  248.     retval = to;
  250.     if (quotemap == NULL)
  251. quotemap = ""+?& ";
  252.     
  253.     while (*fp)
  254.     {
  255. if (only_qm ?
  256.     (strchr(quotemap, *fp) != NULL) :
  257.     (*fp == '%' ||
  258.      *fp == '"' ||
  259.      *fp <= ' ' ||
  260.      strchr(quotemap, *fp) != NULL ||
  261.      (*fp >= 127 && 
  262.       *fp <= (unsigned char) (128+(unsigned char)' ')) ||
  263.      *fp == 255))
  264. {
  265.     if ((to-retval) < size-3)
  266.     {
  267. *to++ = '%';
  268. *to++ = bin2hex[((*fp) >> 4) & 0x0F];
  269. *to++ = bin2hex[(*fp) & 0x0F];
  270. ++fp;
  271.     }
  272.     else
  273. break;
  274. }
  275. else
  276.     if ((to-retval) < size-1)
  277. *to++ = *fp++;
  278.     else
  279. break;
  280. }
  282.     *to = '';
  283.     /* to=retval; */
  285.     return retval;
  286. }
  290. void url_unquote(char *str, int plus_flag)
  291. {
  292.     char *to;
  293.     int val;
  294.     
  296.     to = str;
  297.     
  298.     while (*str)
  299. switch (*str)
  300. {
  301.   case '+':
  302.     if (plus_flag)
  303. *to++ = ' ';
  304.     else
  305. *to++ = '+';
  306.     
  307.     ++str;
  308.     break;
  309.     
  310.   case '%':
  311.     ++str;
  312.     val = 0;
  313.     
  314.     if (*str && s_isxdigit(*str))
  315.     {
  316. val = HTOI(*str);
  317. ++str;
  318.     }
  320.     if (*str && s_isxdigit(*str))
  321.     {
  322. val *= 16;
  323. val += HTOI(*str);
  324. ++str;
  325.     }
  326.     *to++ = val;
  327.     
  328.     break;
  329.     
  330.   default:
  331.     *to++ = *str++;
  332. }
  334.     *to = '';
  335. }
  337. /* this will strip // -> /, /./ -> /  and /dir/../ -> /dir/.
  338.  */
  339. void url_cleanup(char *str)
  340. {
  341.     char *to;
  342.     char *start;
  343.     char *back=NULL;
  345.     to = str;
  346.     start=to;
  348.     while (*str)
  349. {
  350.   if ( strncmp(str,"//",2) == 0 ) { str++; }
  351.           else if ( strncmp(str,"/./",3) == 0 ) { str++; str++; }
  352.   else if ( strncmp(str,"/../",4) == 0 )
  353. {
  354. if ( to!=start) 
  355. { 
  356. back=to-1;
  357. while ( back!=start && *back!='/' ) back--;
  358. }
  359. if ( back != NULL ) to=back;
  360. str=str+3;
  361. }
  362.   else
  363.   { *to++ = *str++; }
  364. }
  366.     *to = '';
  367. }
  370. const char *url_gethandler(char *url)
  371. {
  372.     int i;
  373.     int len;
  374.     
  376.     len = strlen(url);
  377.     
  378.     if (url_handlers_table)
  379.     {
  380. for (i = 0; i < url_handlers_table->length; i++)
  381. {
  382.     char **pair = url_handlers_table->value[i];
  383.     
  384.     if (debug > 3)
  385. fprintf(stderr, "       (Checking URL %s vs %s)n",
  386. url, pair[0]);
  388.     if (strmatch(url, pair[0]))
  389.     {
  390.         if (debug > 1)
  391.     fprintf(stderr, "      (URL %s -> Handler %s)n",
  392.     url, pair[1]);
  393.     
  394. return pair[1];
  395.     }
  396.   }
  397.     }
  398.     
  399.     if (len > 0 && url[len-1] == '/')
  400.     {
  401. if (debug > 1)
  402.     fprintf(stderr, "      (URL %s -> Handler %s)n",
  403.     url, default_dir_handler);
  405. return default_dir_handler;
  406.     }
  407.     else
  408.     {
  409. if (debug > 1)
  410.     fprintf(stderr, "      (URL %s -> Handler %s)n",
  411.     url, default_file_handler);
  413. return default_file_handler;
  414.     }
  415. }
  419. char *url_match(struct table *tp,
  420. const char *url,
  421. char *result,
  422. int size)
  423. {
  424.     int i;
  425.     
  427.     if (tp == NULL)
  428. return NULL;
  429.     
  430.     for (i = 0; i < tp->length; i++)
  431.     {
  432. char **pair = tp->value[i];
  434. if (strmatch(url, pair[0]))
  435. {
  436.     s_strcpy(result, size, pair[1]);
  437.     return result;
  438. }
  439.     }
  441.     return NULL;
  442. }
  445. char *url_getredirect(const char *url,
  446.       char *out_url,
  447.       int size)
  448. {
  449.     char rewrite_pattern[256];
  450.     
  451.     if (url_match(url_redirects_table, url, 
  452.   rewrite_pattern, sizeof(rewrite_pattern)))
  453.     {
  454. if (url_rewrite(url, rewrite_pattern, out_url, size))
  455.     return out_url;
  456.     }
  458.     return NULL;
  459. }
  464. char *url_getpredirect(const char *url,
  465.        char *out_url,
  466.        int size)
  467. {
  468.     char rewrite_pattern[256];
  469.     
  470.     if (url_match(url_predirects_table, url, 
  471.   rewrite_pattern, sizeof(rewrite_pattern)))
  472.     {
  473. if (url_rewrite(url, rewrite_pattern, out_url, size))
  474.     return out_url;
  475.     }
  477.     return NULL;
  478. }
  481. char *url_getrewrite(const char *url,
  482.      char *out_url,
  483.      int url_size)
  484. {
  485.     char rewrite_pattern[1024];
  487.     
  488.     if (url_match(url_rewrites_table, url,
  489.   rewrite_pattern, sizeof(rewrite_pattern)))
  490.     {
  491. return url_rewrite(url, rewrite_pattern,
  492.    out_url, url_size);
  493.     }
  495.     return NULL;
  496. }
  498. /* added RK */
  499. char *write_getauthenticate(const char *url,
  500.   char *out_url,
  501.   int size)
  502. {
  503.     char auth_buf[1024];
  505.     
  506.     if (url_match(write_authenticate_table, url, 
  507.   auth_buf, sizeof(auth_buf)))
  508.     {
  509. s_strcpy(out_url, size, auth_buf);
  510. return out_url;
  511.     }
  513.     return NULL;
  514. }
  518. char *read_getauthenticate(const char *url,
  519.   char *out_url,
  520.   int size)
  521. {
  522.     char auth_buf[1024];
  524.     
  525.     if (url_match(read_authenticate_table, url, 
  526.   auth_buf, sizeof(auth_buf)))
  527.     {
  528. s_strcpy(out_url, size, auth_buf);
  529. return out_url;
  530.     }
  532.     return NULL;
  533. }
  536. char *host_getaccess(const char *url,
  537.     char *out_url,
  538.     int size)
  539. {
  540.     return url_match(host_access_table, url, out_url, size);
  541. }
  544. static int get_num(char **cp)
  545. {
  546.     int val = 0;
  547.     
  548.     while (s_isdigit(**cp))
  549.     {
  550. val *= 10;
  551. val += (**cp - '0');
  553. ++*cp;
  554.     }
  556.     return val;
  557. }
  559. static int get_args(char **cp, int *v1, int *v2)
  560. {
  561.     if (**cp != '{')
  562. return 0;
  564.     ++*cp;
  565.     
  566.     if (s_isdigit(**cp))
  567.     {
  568. *v1 = get_num(cp);
  570. if (**cp == '}') /* %{99} */
  571. {
  572.     *v2 = *v1;
  574.     ++*cp;
  575.     
  576.     return 1;
  577. }
  579. else if (**cp == '-')
  580. {
  581.     ++*cp;
  582.     
  583.     if (s_isdigit(**cp)) /* %{1-99} */
  584.     {
  585. *v2 = get_num(cp);
  587. if (**cp == '}')
  588. {
  589.     ++*cp;
  591.     return 1;
  592. }
  593.     }
  595.     else if (**cp == '}')
  596.     {
  597. *v2 = 99999;
  599. ++*cp;
  601. return 1;
  602.     }
  604.     return 0;
  605. }
  606. else
  607. {
  608.     return 0;
  609. }
  610.     }
  611.     
  612.     else if ((*cp)[0] == '*' && (*cp)[1] == '}') /* %{*} */
  613.     {
  614. *v1 = 0;
  615. *v2 = 999999; /* Some huge number */
  617. ++*cp;
  618. ++*cp;
  620. return 1;
  621.     }
  622.     
  623.     else if (**cp == '-') /* %{-99} */
  624.     {
  625. *v1 = 0;
  626. ++*cp;
  628. if (s_isdigit(**cp))
  629. {
  630.     *v2 = get_num(cp);
  631.     
  632.     if (**cp == '}')
  633.     {
  634. ++*cp;
  636. return 1;
  637.     }
  638.     else
  639.     {
  640. return 0;
  641.     }
  642. }
  644. else if (**cp == '}') /* %{-} */
  645. {
  646.     *v2 = -1;
  647.     ++*cp;
  648.     
  649.     return 1;
  650. }
  652. return 0;
  653.     }
  654.     else
  655. return 0;
  656. }
  660. /*
  661. ** Yuk! This code is _ugly_! Can't someone rewrite it to be nicer
  662. ** to read, and have more features?
  663. **
  664. ** TODO: Fix the handling of the "?request" part.
  665. */
  666. char *url_rewrite(const char *url,
  667.   const char *pattern,
  668.   char *buf,
  669.   int size)
  670. {
  671.     char **argv;
  672.     char *start = buf;
  673.     const char *ppos = pattern;
  674.     char *cp;
  675.     int i;
  676.     int argc;
  677.     char *tmp, *qtmp;
  678.     int tlen,xlen;
  680.     
  681.     if (debug > 2)
  682. fprintf(stderr, "url_rewrite("%s", "%s", ..., %d)n",
  683. url, pattern, size);
  685.     tlen = strlen(url)+1;
  686.     tmp = (char *) alloca(tlen);
  687.     if (tmp == NULL)
  688.     {
  689. if (debug > 2)
  690.     fprintf(stderr, "t-> NULLn");
  692. return NULL;
  693.     }
  695.     s_strcpy(tmp, tlen, url+1);
  698.     qtmp= strchr(tmp,'?'); /* encoding ?? RK */
  699.     if ( qtmp != NULL ) { *qtmp=0x00; qtmp++; } 
  701.     argv = strsplit(tmp, '/', 0);
  702.     
  703.     for (argc = 0; argv[argc]; argc++)
  704. ;
  706.     while ((cp = strchr(ppos, '%')) != NULL)
  707.     {
  708. int len = cp - ppos;
  709. int v1, v2;
  712. if (len > 0)
  713. {
  714.     s_strncpy(buf, size, ppos, len);
  715.     buf += len;
  716.     size -= len;
  717. }
  719. ++cp;
  721. if (get_args(&cp, &v1, &v2))
  722. {
  723.     for (i = v1; i <= v2 && i < argc; i++)
  724.     {
  725. s_strcpy(buf, size, argv[i]);
  726.     
  727. while (*buf)
  728. {
  729.     ++buf;
  730.     --size;
  731. }
  733. if (i < v2 && i + 1< argc)
  734. {
  735.     *buf++ = '/';
  736.     --size;
  737. }
  738.     }
  739. }
  741. ppos = cp;
  742.     }
  743.     xlen=strlen(ppos);
  744.     s_strncpy(buf, size, ppos,xlen);
  745.     buf += xlen;
  746.     size -= xlen;
  748.     if ( qtmp != NULL )
  749.     { s_strncpy(buf, size, "?" , 1 );
  750.       buf++; size--;
  751.       if ( *qtmp != 0x00 )
  752.       s_strncpy(buf, size, qtmp , strlen(qtmp));
  753.     }
  755.     s_free(argv);
  757.     if (debug > 2)
  758. fprintf(stderr, "t-> "%s"n", start);
  759.     
  760.     return start;
  761. }
  764. /* In case of mulitmode or SVS, we need to build cip->sip->url (http://server.name.domain/) */
  765. /* from the data we got. This is needed in file.c, error.c dir.c and may be some more. */
  766. /* Added RK@netuse.de */
  768. char *make_sip_url(struct connectioninfo *cip, char *extname, int retsize )
  769. {
  770.    char *hnl,*surl;
  772. /* ADDED RK: we need to get the servername for corect redirects here manual :-( */
  773.         if ( softvirtserver == 0 )
  774.          {
  775.           if (rkmultimode==0)
  776. /* Standart mode, only copy url. */
  777.             s_strcpy(extname, retsize, cip->sip->url);
  778.           else
  779.           {
  780. /* If we run rkmultimode, we need to do a reverse lookup to our socket, since we */
  781. /* do not have a table. For performance reasons, a reverse lookup it not done on */
  782. /* every request near the accept, but only here in case of a redirect, since */
  783. /* that case happens fewer times :-( (and DNS is not MT-Safe, */
  784. /* thus the call may block */
  785.             hnl=dns_lookup_servername(cip->server);
  786.             if ( hnl==NULL ) hnl=s_strdup(inet_ntoa(cip->server->sin.sin_addr));
  787.             surl=make_server_url(hnl,cip->sip->port);
  788.             s_strcpy(extname, retsize, surl);
  789.             s_free(surl);
  790.           }
  791.          }
  792.         else
  793. /* we have softvirtserver: Easy-we got the Servername in the Request */
  794.           {
  795.             surl=make_server_url(cip->hip->svsname,cip->sip->port);
  796.             s_strcpy(extname, retsize, surl);
  797.             s_free(surl);
  798.           }
  799.     return (extname);
  800. }