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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
url.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：11k
源码类别：

代理服务器

开发平台：

Unix_Linux

url.c：源码内容
  2. /*
  3.  * $Id: url.c,v 1.113.2.1 1999/02/12 19:38:32 wessels Exp $
  4.  *
  5.  * DEBUG: section 23    URL Parsing
  6.  * AUTHOR: Duane Wessels
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #include "squid.h"
  38. const char *RequestMethodStr[] =
  39. {
  40.     "NONE",
  41.     "GET",
  42.     "POST",
  43.     "PUT",
  44.     "HEAD",
  45.     "CONNECT",
  46.     "TRACE",
  47.     "PURGE"
  48. };
  50. const char *ProtocolStr[] =
  51. {
  52.     "NONE",
  53.     "http",
  54.     "ftp",
  55.     "gopher",
  56.     "wais",
  57.     "cache_object",
  58.     "icp",
  59. #if USE_HTCP
  60.     "htcp",
  61. #endif
  62.     "urn",
  63.     "whois",
  64.     "internal",
  65.     "https",
  66.     "TOTAL"
  67. };
  69. static request_t *urnParse(method_t method, char *urn);
  70. static const char *const valid_hostname_chars =
  71. #if ALLOW_HOSTNAME_UNDERSCORES
  72. "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  73. "abcdefghijklmnopqrstuvwxyz"
  74. "0123456789-._";
  75. #else
  76. "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  77. "abcdefghijklmnopqrstuvwxyz"
  78. "0123456789-.";
  79. #endif
  81. /* convert %xx in url string to a character 
  82.  * Allocate a new string and return a pointer to converted string */
  84. char *
  85. url_convert_hex(char *org_url, int allocate)
  86. {
  87.     static char code[] = "00";
  88.     char *url = NULL;
  89.     char *s = NULL;
  90.     char *t = NULL;
  91.     url = allocate ? (char *) xstrdup(org_url) : org_url;
  92.     if ((int) strlen(url) < 3 || !strchr(url, '%'))
  93. return url;
  94.     for (s = t = url; *(s + 2); s++) {
  95. if (*s == '%') {
  96.     code[0] = *(++s);
  97.     code[1] = *(++s);
  98.     *t++ = (char) strtol(code, NULL, 16);
  99. } else {
  100.     *t++ = *s;
  101. }
  102.     }
  103.     do {
  104. *t++ = *s;
  105.     } while (*s++);
  106.     return url;
  107. }
  109. void
  110. urlInitialize(void)
  111. {
  112.     debug(23, 5) ("urlInitialize: Initializing...n");
  113.     assert(sizeof(ProtocolStr) == (PROTO_MAX + 1) * sizeof(char *));
  114.     memset(&null_request_flags, '', sizeof(null_request_flags));
  115. }
  117. method_t
  118. urlParseMethod(const char *s)
  119. {
  120.     if (strcasecmp(s, "GET") == 0) {
  121. return METHOD_GET;
  122.     } else if (strcasecmp(s, "POST") == 0) {
  123. return METHOD_POST;
  124.     } else if (strcasecmp(s, "PUT") == 0) {
  125. return METHOD_PUT;
  126.     } else if (strcasecmp(s, "HEAD") == 0) {
  127. return METHOD_HEAD;
  128.     } else if (strcasecmp(s, "CONNECT") == 0) {
  129. return METHOD_CONNECT;
  130.     } else if (strcasecmp(s, "TRACE") == 0) {
  131. return METHOD_TRACE;
  132.     } else if (strcasecmp(s, "PURGE") == 0) {
  133. return METHOD_PURGE;
  134.     }
  135.     return METHOD_NONE;
  136. }
  139. protocol_t
  140. urlParseProtocol(const char *s)
  141. {
  142.     /* test common stuff first */
  143.     if (strcasecmp(s, "http") == 0)
  144. return PROTO_HTTP;
  145.     if (strcasecmp(s, "ftp") == 0)
  146. return PROTO_FTP;
  147.     if (strcasecmp(s, "https") == 0)
  148. return PROTO_HTTPS;
  149.     if (strcasecmp(s, "file") == 0)
  150. return PROTO_FTP;
  151.     if (strcasecmp(s, "gopher") == 0)
  152. return PROTO_GOPHER;
  153.     if (strcasecmp(s, "wais") == 0)
  154. return PROTO_WAIS;
  155.     if (strcasecmp(s, "cache_object") == 0)
  156. return PROTO_CACHEOBJ;
  157.     if (strcasecmp(s, "urn") == 0)
  158. return PROTO_URN;
  159.     if (strcasecmp(s, "whois") == 0)
  160. return PROTO_WHOIS;
  161.     if (strcasecmp(s, "internal") == 0)
  162. return PROTO_INTERNAL;
  163.     return PROTO_NONE;
  164. }
  167. int
  168. urlDefaultPort(protocol_t p)
  169. {
  170.     switch (p) {
  171.     case PROTO_HTTP:
  172. return 80;
  173.     case PROTO_HTTPS:
  174. return 443;
  175.     case PROTO_FTP:
  176. return 21;
  177.     case PROTO_GOPHER:
  178. return 70;
  179.     case PROTO_WAIS:
  180. return 210;
  181.     case PROTO_CACHEOBJ:
  182.     case PROTO_INTERNAL:
  183. return CACHE_HTTP_PORT;
  184.     case PROTO_WHOIS:
  185. return 43;
  186.     default:
  187. return 0;
  188.     }
  189. }
  191. request_t *
  192. urlParse(method_t method, char *url)
  193. {
  194.     LOCAL_ARRAY(char, proto, MAX_URL);
  195.     LOCAL_ARRAY(char, login, MAX_URL);
  196.     LOCAL_ARRAY(char, host, MAX_URL);
  197.     LOCAL_ARRAY(char, urlpath, MAX_URL);
  198.     request_t *request = NULL;
  199.     char *t = NULL;
  200.     int port;
  201.     protocol_t protocol = PROTO_NONE;
  202.     int l;
  203.     proto[0] = host[0] = urlpath[0] = login[0] = '';
  205.     if ((l = strlen(url)) + Config.appendDomainLen > (MAX_URL - 1)) {
  206. /* terminate so it doesn't overflow other buffers */
  207. *(url + (MAX_URL >> 1)) = '';
  208. debug(23, 1) ("urlParse: URL too large (%d bytes)n", l);
  209. return NULL;
  210.     }
  211.     if (method == METHOD_CONNECT) {
  212. port = CONNECT_PORT;
  213. if (sscanf(url, "%[^:]:%d", host, &port) < 1)
  214.     return NULL;
  215.     } else if (!strncmp(url, "urn:", 4)) {
  216. return urnParse(method, url);
  217.     } else {
  218. if (sscanf(url, "%[^:]://%[^/]%[^rn]", proto, host, urlpath) < 2)
  219.     return NULL;
  220. protocol = urlParseProtocol(proto);
  221. port = urlDefaultPort(protocol);
  222. /* Is there any login informaiton? */
  223. if ((t = strrchr(host, '@'))) {
  224.     strcpy(login, host);
  225.     t = strrchr(login, '@');
  226.     *t = 0;
  227.     strcpy(host, t + 1);
  228. }
  229. if ((t = strrchr(host, ':'))) {
  230.     *t++ = '';
  231.     if (*t != '')
  232. port = atoi(t);
  233. }
  234.     }
  235.     for (t = host; *t; t++)
  236. *t = xtolower(*t);
  237.     if (strspn(host, valid_hostname_chars) != strlen(host)) {
  238. debug(23, 1) ("urlParse: Illegal character in hostname '%s'n", host);
  239. return NULL;
  240.     }
  241.     /* remove trailing dots from hostnames */
  242.     while ((l = strlen(host)) > 0 && host[--l] == '.')
  243. host[l] = '';
  244.     if (Config.appendDomain && !strchr(host, '.'))
  245. strncat(host, Config.appendDomain, SQUIDHOSTNAMELEN);
  246.     if (port == 0) {
  247. debug(23, 3) ("urlParse: Invalid port == 0n");
  248. return NULL;
  249.     }
  250. #ifdef HARDCODE_DENY_PORTS
  251.     /* These ports are filtered in the default squid.conf, but
  252.      * maybe someone wants them hardcoded... */
  253.     if (port == 7 || port == 9 || port = 19) {
  254. debug(23, 0) ("urlParse: Deny access to port %dn", port);
  255. return NULL;
  256.     }
  257. #endif
  258.     if (stringHasWhitespace(urlpath)) {
  259. debug(23, 2) ("urlParse: URI has whitespace: {%s}n", url);
  260. switch (Config.uri_whitespace) {
  261. case URI_WHITESPACE_DENY:
  262.     return NULL;
  263. case URI_WHITESPACE_ALLOW:
  264.     break;
  265. case URI_WHITESPACE_ENCODE:
  266.     t = rfc1738_escape(urlpath);
  267.     xstrncpy(urlpath, t, MAX_URL);
  268.     break;
  269. case URI_WHITESPACE_CHOP:
  270.     *(urlpath + strcspn(urlpath, w_space)) = '';
  271.     break;
  272. }
  273.     }
  274.     request = requestCreate(method, protocol, urlpath);
  275.     xstrncpy(request->host, host, SQUIDHOSTNAMELEN);
  276.     xstrncpy(request->login, login, MAX_LOGIN_SZ);
  277.     request->port = (u_short) port;
  278.     return request;
  279. }
  281. static request_t *
  282. urnParse(method_t method, char *urn)
  283. {
  284.     debug(50, 5) ("urnParse: %sn", urn);
  285.     return requestCreate(method, PROTO_URN, urn + 4);
  286. }
  288. const char *
  289. urlCanonical(request_t * request)
  290. {
  291.     LOCAL_ARRAY(char, portbuf, 32);
  292.     LOCAL_ARRAY(char, urlbuf, MAX_URL);
  293.     if (request->canonical)
  294. return request->canonical;
  295.     if (request->protocol == PROTO_URN) {
  296. snprintf(urlbuf, MAX_URL, "urn:%s", strBuf(request->urlpath));
  297.     } else {
  298. switch (request->method) {
  299. case METHOD_CONNECT:
  300.     snprintf(urlbuf, MAX_URL, "%s:%d", request->host, request->port);
  301.     break;
  302. default:
  303.     portbuf[0] = '';
  304.     if (request->port != urlDefaultPort(request->protocol))
  305. snprintf(portbuf, 32, ":%d", request->port);
  306.     snprintf(urlbuf, MAX_URL, "%s://%s%s%s%s%s",
  307. ProtocolStr[request->protocol],
  308. request->login,
  309. *request->login ? "@" : null_string,
  310. request->host,
  311. portbuf,
  312. strBuf(request->urlpath));
  313.     break;
  314. }
  315.     }
  316.     return (request->canonical = xstrdup(urlbuf));
  317. }
  319. char *
  320. urlCanonicalClean(const request_t * request)
  321. {
  322.     LOCAL_ARRAY(char, buf, MAX_URL);
  323.     LOCAL_ARRAY(char, portbuf, 32);
  324.     LOCAL_ARRAY(char, loginbuf, MAX_LOGIN_SZ + 1);
  325.     char *t;
  326.     if (request->protocol == PROTO_URN) {
  327. snprintf(buf, MAX_URL, "urn:%s", strBuf(request->urlpath));
  328.     } else {
  329. switch (request->method) {
  330. case METHOD_CONNECT:
  331.     snprintf(buf, MAX_URL, "%s:%d", request->host, request->port);
  332.     break;
  333. default:
  334.     portbuf[0] = '';
  335.     if (request->port != urlDefaultPort(request->protocol))
  336. snprintf(portbuf, 32, ":%d", request->port);
  337.     loginbuf[0] = '';
  338.     if ((int) strlen(request->login) > 0) {
  339. strcpy(loginbuf, request->login);
  340. if ((t = strchr(loginbuf, ':')))
  341.     *t = '';
  342. strcat(loginbuf, "@");
  343.     }
  344.     snprintf(buf, MAX_URL, "%s://%s%s%s%s",
  345. ProtocolStr[request->protocol],
  346. loginbuf,
  347. request->host,
  348. portbuf,
  349. strBuf(request->urlpath));
  350.     /*
  351.      * strip arguments AFTER a question-mark
  352.      */
  353.     if (Config.onoff.strip_query_terms)
  354. if ((t = strchr(buf, '?')))
  355.     *(++t) = '';
  356.     break;
  357. }
  358.     }
  359.     if (stringHasWhitespace(buf))
  360. xstrncpy(buf, rfc1738_escape(buf), MAX_URL);
  361.     return buf;
  362. }
  364. int
  365. matchDomainName(const char *domain, const char *host)
  366. {
  367.     int offset;
  368.     if ((offset = strlen(host) - strlen(domain)) < 0)
  369. return 0; /* host too short */
  370.     if (strcasecmp(domain, host + offset) != 0)
  371. return 0; /* no match at all */
  372.     if (*domain == '.')
  373. return 1;
  374.     if (offset == 0)
  375. return 1;
  376.     if (*(host + offset - 1) == '.')
  377. return 1;
  378.     return 0;
  379. }
  381. int
  382. urlCheckRequest(const request_t * r)
  383. {
  384.     int rc = 0;
  385.     /* protocol "independent" methods */
  386.     if (r->method == METHOD_CONNECT)
  387. return 1;
  388.     if (r->method == METHOD_TRACE)
  389. return 1;
  390.     if (r->method == METHOD_PURGE)
  391. return 1;
  392.     /* does method match the protocol? */
  393.     switch (r->protocol) {
  394.     case PROTO_URN:
  395.     case PROTO_HTTP:
  396.     case PROTO_HTTPS:
  397.     case PROTO_CACHEOBJ:
  398. rc = 1;
  399. break;
  400.     case PROTO_FTP:
  401. if (r->method == METHOD_PUT)
  402.     rc = 1;
  403.     case PROTO_GOPHER:
  404.     case PROTO_WAIS:
  405.     case PROTO_WHOIS:
  406. if (r->method == METHOD_GET)
  407.     rc = 1;
  408. else if (r->method == METHOD_HEAD)
  409.     rc = 1;
  410. break;
  411.     default:
  412. break;
  413.     }
  414.     return rc;
  415. }
  417. /*
  418.  * Quick-n-dirty host extraction from a URL.  Steps:
  419.  *      Look for a colon
  420.  *      Skip any '/' after the colon
  421.  *      Copy the next SQUID_MAXHOSTNAMELEN bytes to host[]
  422.  *      Look for an ending '/' or ':' and terminate
  423.  *      Look for login info preceeded by '@'
  424.  */
  425. char *
  426. urlHostname(const char *url)
  427. {
  428.     LOCAL_ARRAY(char, host, SQUIDHOSTNAMELEN);
  429.     char *t;
  430.     host[0] = '';
  431.     if (NULL == (t = strchr(url, ':')))
  432. return NULL;
  433.     t++;
  434.     while (*t != '' && *t == '/')
  435. t++;
  436.     xstrncpy(host, t, SQUIDHOSTNAMELEN);
  437.     if ((t = strchr(host, '/')))
  438. *t = '';
  439.     if ((t = strchr(host, ':')))
  440. *t = '';
  441.     if ((t = strrchr(host, '@'))) {
  442. t++;
  443. xmemmove(host, t, strlen(t) + 1);
  444.     }
  445.     return host;
  446. }