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

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

代理服务器

开发平台：

Unix_Linux

http.c：源码内容
  2. /*
  3.  * $Id: http.c,v 1.346.2.1 1999/02/12 19:38:29 wessels Exp $
  4.  *
  5.  * DEBUG: section 11    Hypertext Transfer Protocol (HTTP)
  6.  * AUTHOR: Harvest Derived
  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. /*
  37.  * Anonymizing patch by lutz@as-node.jena.thur.de
  38.  * have a look into http-anon.c to get more informations.
  39.  */
  41. #include "squid.h"
  43. static const char *const crlf = "rn";
  45. static CNCB httpConnectDone;
  46. static CWCB httpSendComplete;
  47. static CWCB httpSendRequestEntry;
  48. static CWCB httpSendRequestEntryDone;
  50. static PF httpReadReply;
  51. static PF httpSendRequest;
  52. static PF httpStateFree;
  53. static PF httpTimeout;
  54. static void httpCacheNegatively(StoreEntry *);
  55. static void httpMakePrivate(StoreEntry *);
  56. static void httpMakePublic(StoreEntry *);
  57. static int httpCachableReply(HttpStateData *);
  58. static void httpMaybeRemovePublic(StoreEntry *, http_status);
  60. static void
  61. httpStateFree(int fd, void *data)
  62. {
  63.     HttpStateData *httpState = data;
  64. #if DELAY_POOLS
  65.     delayClearNoDelay(fd);
  66. #endif
  67.     if (httpState == NULL)
  68. return;
  69.     storeUnlockObject(httpState->entry);
  70.     if (httpState->reply_hdr) {
  71. memFree(httpState->reply_hdr, MEM_8K_BUF);
  72. httpState->reply_hdr = NULL;
  73.     }
  74.     requestUnlink(httpState->request);
  75.     requestUnlink(httpState->orig_request);
  76.     httpState->request = NULL;
  77.     httpState->orig_request = NULL;
  78.     cbdataFree(httpState);
  79. }
  81. int
  82. httpCachable(method_t method)
  83. {
  84.     /* GET and HEAD are cachable. Others are not. */
  85.     if (method != METHOD_GET && method != METHOD_HEAD)
  86. return 0;
  87.     /* else cachable */
  88.     return 1;
  89. }
  91. static void
  92. httpTimeout(int fd, void *data)
  93. {
  94.     HttpStateData *httpState = data;
  95.     StoreEntry *entry = httpState->entry;
  96.     debug(11, 4) ("httpTimeout: FD %d: '%s'n", fd, storeUrl(entry));
  97.     if (entry->store_status == STORE_PENDING) {
  98. if (entry->mem_obj->inmem_hi == 0) {
  99.     fwdFail(httpState->fwd,
  100. errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
  101. }
  102.     }
  103.     comm_close(fd);
  104. }
  106. /* This object can be cached for a long time */
  107. static void
  108. httpMakePublic(StoreEntry * entry)
  109. {
  110.     if (EBIT_TEST(entry->flags, ENTRY_CACHABLE))
  111. storeSetPublicKey(entry);
  112. }
  114. /* This object should never be cached at all */
  115. static void
  116. httpMakePrivate(StoreEntry * entry)
  117. {
  118.     storeExpireNow(entry);
  119.     storeReleaseRequest(entry); /* delete object when not used */
  120.     /* storeReleaseRequest clears ENTRY_CACHABLE flag */
  121. }
  123. /* This object may be negatively cached */
  124. static void
  125. httpCacheNegatively(StoreEntry * entry)
  126. {
  127.     storeNegativeCache(entry);
  128.     if (EBIT_TEST(entry->flags, ENTRY_CACHABLE))
  129. storeSetPublicKey(entry);
  130. }
  132. static void
  133. httpMaybeRemovePublic(StoreEntry * e, http_status status)
  134. {
  135.     int remove = 0;
  136.     StoreEntry *pe;
  137.     if (!EBIT_TEST(e->flags, KEY_PRIVATE))
  138. return;
  139.     switch (status) {
  140.     case HTTP_OK:
  141.     case HTTP_NON_AUTHORITATIVE_INFORMATION:
  142.     case HTTP_MULTIPLE_CHOICES:
  143.     case HTTP_MOVED_PERMANENTLY:
  144.     case HTTP_MOVED_TEMPORARILY:
  145.     case HTTP_FORBIDDEN:
  146.     case HTTP_NOT_FOUND:
  147.     case HTTP_METHOD_NOT_ALLOWED:
  148.     case HTTP_GONE:
  149. remove = 1;
  150. break;
  151. #if WORK_IN_PROGRESS
  152.     case HTTP_UNAUTHORIZED:
  153. remove = 1;
  154. break;
  155. #endif
  156.     default:
  157. remove = 0;
  158. break;
  159.     }
  160.     if (!remove)
  161. return;
  162.     assert(e->mem_obj);
  163.     if ((pe = storeGetPublic(e->mem_obj->url, e->mem_obj->method)) != NULL) {
  164. assert(e != pe);
  165. storeRelease(pe);
  166.     }
  167.     if (e->mem_obj->method == METHOD_GET) {
  168. /* A fresh GET should eject old HEAD objects */
  169. if ((pe = storeGetPublic(e->mem_obj->url, METHOD_HEAD)) != NULL) {
  170.     assert(e != pe);
  171.     storeRelease(pe);
  172. }
  173.     }
  174. }
  176. static int
  177. httpCachableReply(HttpStateData * httpState)
  178. {
  179.     HttpReply *rep = httpState->entry->mem_obj->reply;
  180.     HttpHeader *hdr = &rep->header;
  181.     const int cc_mask = (rep->cache_control) ? rep->cache_control->mask : 0;
  182.     const char *v;
  183.     if (EBIT_TEST(cc_mask, CC_PRIVATE))
  184. return 0;
  185.     if (EBIT_TEST(cc_mask, CC_NO_CACHE))
  186. return 0;
  187.     if (EBIT_TEST(cc_mask, CC_NO_STORE))
  188. return 0;
  189.     if (httpState->request->flags.auth) {
  190. /*
  191.  * Responses to requests with authorization may be cached
  192.  * only if a Cache-Control: public reply header is present.
  193.  * RFC 2068, sec 14.9.4
  194.  */
  195. if (!EBIT_TEST(cc_mask, CC_PUBLIC))
  196.     return 0;
  197.     }
  198.     /*
  199.      * We don't properly deal with Vary features yet, so we can't
  200.      * cache these
  201.      */
  202.     if (httpHeaderHas(hdr, HDR_VARY))
  203. return 0;
  204.     /* Pragma: no-cache in _replies_ is not documented in HTTP,
  205.      * but servers like "Active Imaging Webcast/2.0" sure do use it */
  206.     if (httpHeaderHas(hdr, HDR_PRAGMA)) {
  207. String s = httpHeaderGetList(hdr, HDR_PRAGMA);
  208. const int no_cache = strListIsMember(&s, "no-cache", ',');
  209. stringClean(&s);
  210. if (no_cache)
  211.     return 0;
  212.     }
  213.     /*
  214.      * The "multipart/x-mixed-replace" content type is used for
  215.      * continuous push replies.  These are generally dynamic and
  216.      * probably should not be cachable
  217.      */
  218.     if ((v = httpHeaderGetStr(hdr, HDR_CONTENT_TYPE)))
  219. if (!strncasecmp(v, "multipart/x-mixed-replace", 25))
  220.     return 0;
  221.     switch (httpState->entry->mem_obj->reply->sline.status) {
  222. /* Responses that are cacheable */
  223.     case HTTP_OK:
  224.     case HTTP_NON_AUTHORITATIVE_INFORMATION:
  225.     case HTTP_MULTIPLE_CHOICES:
  226.     case HTTP_MOVED_PERMANENTLY:
  227.     case HTTP_GONE:
  228. /*
  229.  * Don't cache objects that need to be refreshed on next request,
  230.  * unless we know how to refresh it.
  231.  */
  232. if (!refreshIsCachable(httpState->entry))
  233.     return 0;
  234. /* don't cache objects from peers w/o LMT, Date, or Expires */
  235. /* check that is it enough to check headers @?@ */
  236. if (rep->date > -1)
  237.     return 1;
  238. else if (rep->last_modified > -1)
  239.     return 1;
  240. else if (!httpState->peer)
  241.     return 1;
  242. /* @?@ (here and 302): invalid expires header compiles to squid_curtime */
  243. else if (rep->expires > -1)
  244.     return 1;
  245. else
  246.     return 0;
  247. /* NOTREACHED */
  248. break;
  249. /* Responses that only are cacheable if the server says so */
  250.     case HTTP_MOVED_TEMPORARILY:
  251. if (rep->expires > -1)
  252.     return 1;
  253. else
  254.     return 0;
  255. /* NOTREACHED */
  256. break;
  257. /* Errors can be negatively cached */
  258.     case HTTP_NO_CONTENT:
  259.     case HTTP_USE_PROXY:
  260.     case HTTP_BAD_REQUEST:
  261.     case HTTP_FORBIDDEN:
  262.     case HTTP_NOT_FOUND:
  263.     case HTTP_METHOD_NOT_ALLOWED:
  264.     case HTTP_REQUEST_URI_TOO_LARGE:
  265.     case HTTP_INTERNAL_SERVER_ERROR:
  266.     case HTTP_NOT_IMPLEMENTED:
  267.     case HTTP_BAD_GATEWAY:
  268.     case HTTP_SERVICE_UNAVAILABLE:
  269.     case HTTP_GATEWAY_TIMEOUT:
  270. return -1;
  271. /* NOTREACHED */
  272. break;
  273. /* Some responses can never be cached */
  274.     case HTTP_PARTIAL_CONTENT: /* Not yet supported */
  275.     case HTTP_SEE_OTHER:
  276.     case HTTP_NOT_MODIFIED:
  277.     case HTTP_UNAUTHORIZED:
  278.     case HTTP_PROXY_AUTHENTICATION_REQUIRED:
  279.     case HTTP_INVALID_HEADER: /* Squid header parsing error */
  280.     default: /* Unknown status code */
  281. return 0;
  282. /* NOTREACHED */
  283. break;
  284.     }
  285.     /* NOTREACHED */
  286. }
  288. /* rewrite this later using new interfaces @?@ */
  289. void
  290. httpProcessReplyHeader(HttpStateData * httpState, const char *buf, int size)
  291. {
  292.     char *t = NULL;
  293.     StoreEntry *entry = httpState->entry;
  294.     int room;
  295.     int hdr_len;
  296.     HttpReply *reply = entry->mem_obj->reply;
  297.     debug(11, 3) ("httpProcessReplyHeader: key '%s'n",
  298. storeKeyText(entry->key));
  299.     if (httpState->reply_hdr == NULL)
  300. httpState->reply_hdr = memAllocate(MEM_8K_BUF);
  301.     if (httpState->reply_hdr_state == 0) {
  302. hdr_len = strlen(httpState->reply_hdr);
  303. room = 8191 - hdr_len;
  304. strncat(httpState->reply_hdr, buf, room < size ? room : size);
  305. hdr_len += room < size ? room : size;
  306. if (hdr_len > 4 && strncmp(httpState->reply_hdr, "HTTP/", 5)) {
  307.     debug(11, 3) ("httpProcessReplyHeader: Non-HTTP-compliant header: '%s'n", httpState->reply_hdr);
  308.     httpState->reply_hdr_state += 2;
  309.     reply->sline.status = HTTP_INVALID_HEADER;
  310.     return;
  311. }
  312. t = httpState->reply_hdr + hdr_len;
  313. /* headers can be incomplete only if object still arriving */
  314. if (!httpState->eof) {
  315.     size_t k = headersEnd(httpState->reply_hdr, 8192);
  316.     if (0 == k)
  317. return; /* headers not complete */
  318.     t = httpState->reply_hdr + k;
  319. }
  320. *t = '';
  321. httpState->reply_hdr_state++;
  322.     }
  323.     if (httpState->reply_hdr_state == 1) {
  324. const Ctx ctx = ctx_enter(entry->mem_obj->url);
  325. httpState->reply_hdr_state++;
  326. debug(11, 9) ("GOT HTTP REPLY HDR:n---------n%sn----------n",
  327.     httpState->reply_hdr);
  328. /* Parse headers into reply structure */
  329. /* what happens if we fail to parse here? */
  330. httpReplyParse(reply, httpState->reply_hdr); /* httpState->eof); */
  331. storeTimestampsSet(entry);
  332. /* Check if object is cacheable or not based on reply code */
  333. debug(11, 3) ("httpProcessReplyHeader: HTTP CODE: %dn", reply->sline.status);
  334. if (neighbors_do_private_keys)
  335.     httpMaybeRemovePublic(entry, reply->sline.status);
  336. switch (httpCachableReply(httpState)) {
  337. case 1:
  338.     httpMakePublic(entry);
  339.     break;
  340. case 0:
  341.     httpMakePrivate(entry);
  342.     break;
  343. case -1:
  344.     httpCacheNegatively(entry);
  345.     break;
  346. default:
  347.     assert(0);
  348.     break;
  349. }
  350. if (reply->cache_control) {
  351.     if (EBIT_TEST(reply->cache_control->mask, CC_PROXY_REVALIDATE))
  352. EBIT_SET(entry->flags, ENTRY_REVALIDATE);
  353.     else if (EBIT_TEST(reply->cache_control->mask, CC_MUST_REVALIDATE))
  354. EBIT_SET(entry->flags, ENTRY_REVALIDATE);
  355. }
  356. if (httpState->flags.keepalive)
  357.     if (httpState->peer)
  358. httpState->peer->stats.n_keepalives_sent++;
  359. if (reply->keep_alive)
  360.     if (httpState->peer)
  361. httpState->peer->stats.n_keepalives_recv++;
  362. ctx_exit(ctx);
  363. if (reply->date > -1 && !httpState->peer) {
  364.     int skew = abs(reply->date - squid_curtime);
  365.     if (skew > 86400)
  366. debug(11, 3) ("%s's clock is skewed by %d seconds!n",
  367.     httpState->request->host, skew);
  368. }
  369.     }
  370. }
  372. static int
  373. httpPconnTransferDone(HttpStateData * httpState)
  374. {
  375.     /* return 1 if we got the last of the data on a persistent connection */
  376.     MemObject *mem = httpState->entry->mem_obj;
  377.     HttpReply *reply = mem->reply;
  378.     debug(11, 3) ("httpPconnTransferDone: FD %dn", httpState->fd);
  379.     /*
  380.      * If we didn't send a keep-alive request header, then this
  381.      * can not be a persistent connection.
  382.      */
  383.     if (!httpState->flags.keepalive)
  384. return 0;
  385.     /*
  386.      * What does the reply have to say about keep-alive?
  387.      */
  388.     if (!reply->keep_alive)
  389. return 0;
  390.     debug(11, 5) ("httpPconnTransferDone: content_length=%dn",
  391. reply->content_length);
  392.     /*
  393.      * Deal with gross HTTP stuff
  394.      *    - If we haven't seen the end of the reply headers, we can't
  395.      *      be persistent.
  396.      *    - For HEAD requests we're done.
  397.      *    - For "200 OK" check the content-length in the next block.
  398.      *    - For "204 No Content" (even with content-length) we're done.
  399.      *    - For "304 Not Modified" (even with content-length) we're done.
  400.      *    - 1XX replies never have a body; we're done.
  401.      *    - For all other replies, check content length in next block.
  402.      */
  403.     if (httpState->reply_hdr_state < 2)
  404. return 0;
  405.     else if (httpState->request->method == METHOD_HEAD)
  406. return 1;
  407.     else if (reply->sline.status == HTTP_OK)
  408. (void) 0; /* common case, continue */
  409.     else if (reply->sline.status == HTTP_NO_CONTENT)
  410. return 1;
  411.     else if (reply->sline.status == HTTP_NOT_MODIFIED)
  412. return 1;
  413.     else if (reply->sline.status < HTTP_OK)
  414. return 1;
  415.     /*
  416.      * If there is no content-length, then we can't be
  417.      * persistent.  If there is a content length, then we must
  418.      * wait until we've seen the end of the body.
  419.      */
  420.     if (reply->content_length < 0)
  421. return 0;
  422.     else if (mem->inmem_hi < reply->content_length + reply->hdr_sz)
  423. return 0;
  424.     else
  425. return 1;
  426. }
  428. /* This will be called when data is ready to be read from fd.  Read until
  429.  * error or connection closed. */
  430. /* XXX this function is too long! */
  431. static void
  432. httpReadReply(int fd, void *data)
  433. {
  434.     HttpStateData *httpState = data;
  435.     LOCAL_ARRAY(char, buf, SQUID_TCP_SO_RCVBUF);
  436.     StoreEntry *entry = httpState->entry;
  437.     const request_t *request = httpState->request;
  438.     int len;
  439.     int bin;
  440.     int clen;
  441.     size_t read_sz;
  442. #if DELAY_POOLS
  443.     delay_id delay_id;
  445.     /* special "if" only for http (for nodelay proxy conns) */
  446.     if (delayIsNoDelay(fd))
  447. delay_id = 0;
  448.     else
  449. delay_id = delayMostBytesAllowed(entry->mem_obj);
  450. #endif
  451.     if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
  452. comm_close(fd);
  453. return;
  454.     }
  455.     /* check if we want to defer reading */
  456.     errno = 0;
  457.     read_sz = SQUID_TCP_SO_RCVBUF;
  458. #if DELAY_POOLS
  459.     read_sz = delayBytesWanted(delay_id, 1, read_sz);
  460. #endif
  461.     Counter.syscalls.sock.reads++;
  462.     len = read(fd, buf, read_sz);
  463.     debug(11, 5) ("httpReadReply: FD %d: len %d.n", fd, len);
  464.     if (len > 0) {
  465. fd_bytes(fd, len, FD_READ);
  466. #if DELAY_POOLS
  467. delayBytesIn(delay_id, len);
  468. #endif
  469. kb_incr(&Counter.server.all.kbytes_in, len);
  470. kb_incr(&Counter.server.http.kbytes_in, len);
  471. commSetTimeout(fd, Config.Timeout.read, NULL, NULL);
  472. IOStats.Http.reads++;
  473. for (clen = len - 1, bin = 0; clen; bin++)
  474.     clen >>= 1;
  475. IOStats.Http.read_hist[bin]++;
  476.     }
  477.     if (!httpState->reply_hdr && len > 0) {
  478. /* Skip whitespace */
  479. while (len > 0 && xisspace(*buf))
  480.     xmemmove(buf, buf + 1, len--);
  481. if (len == 0) {
  482.     /* Continue to read... */
  483.     commSetSelect(fd, COMM_SELECT_READ, httpReadReply, httpState, 0);
  484.     return;
  485. }
  486.     }
  487.     if (len < 0) {
  488. debug(50, 2) ("httpReadReply: FD %d: read failure: %s.n",
  489.     fd, xstrerror());
  490. if (ignoreErrno(errno)) {
  491.     commSetSelect(fd, COMM_SELECT_READ, httpReadReply, httpState, 0);
  492. } else if (entry->mem_obj->inmem_hi == 0) {
  493.     ErrorState *err;
  494.     err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
  495.     err->xerrno = errno;
  496.     fwdFail(httpState->fwd, err);
  497.     comm_close(fd);
  498. } else {
  499.     comm_close(fd);
  500. }
  501.     } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
  502. ErrorState *err;
  503. err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE);
  504. err->xerrno = errno;
  505. fwdFail(httpState->fwd, err);
  506. httpState->eof = 1;
  507. comm_close(fd);
  508.     } else if (len == 0) {
  509. /* Connection closed; retrieval done. */
  510. httpState->eof = 1;
  511. if (httpState->reply_hdr_state < 2)
  512.     /*
  513.      * Yes Henrik, there is a point to doing this.  When we
  514.      * called httpProcessReplyHeader() before, we didn't find
  515.      * the end of headers, but now we are definately at EOF, so
  516.      * we want to process the reply headers.
  517.      */
  518.     httpProcessReplyHeader(httpState, buf, len);
  519. fwdComplete(httpState->fwd);
  520. comm_close(fd);
  521.     } else {
  522. if (httpState->reply_hdr_state < 2) {
  523.     httpProcessReplyHeader(httpState, buf, len);
  524.     if (httpState->reply_hdr_state == 2) {
  525. http_status s = entry->mem_obj->reply->sline.status;
  526. /* If its "successful" reply, allow the client
  527.  * to get it
  528.  */
  529. if (s >= 200 && s < 300)
  530.     EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
  531.     }
  532. }
  533. storeAppend(entry, buf, len);
  534. if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
  535.     /*
  536.      * the above storeAppend() call could ABORT this entry,
  537.      * in that case, the server FD should already be closed.
  538.      * there's nothing for us to do.
  539.      */
  540.     (void) 0;
  541. } else if (httpPconnTransferDone(httpState)) {
  542.     /* yes we have to clear all these! */
  543.     commSetDefer(fd, NULL, NULL);
  544.     commSetTimeout(fd, -1, NULL, NULL);
  545.     commSetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0);
  546.     comm_remove_close_handler(fd, httpStateFree, httpState);
  547.     fwdUnregister(fd, httpState->fwd);
  548.     pconnPush(fd, request->host, request->port);
  549.     fwdComplete(httpState->fwd);
  550.     httpState->fd = -1;
  551.     httpStateFree(fd, httpState);
  552. } else {
  553.     /* Wait for EOF condition */
  554.     commSetSelect(fd, COMM_SELECT_READ, httpReadReply, httpState, 0);
  555. }
  556.     }
  557. }
  559. /* This will be called when request write is complete. Schedule read of
  560.  * reply. */
  561. static void
  562. httpSendComplete(int fd, char *bufnotused, size_t size, int errflag, void *data)
  563. {
  564.     HttpStateData *httpState = data;
  565.     StoreEntry *entry = httpState->entry;
  566.     ErrorState *err;
  567.     debug(11, 5) ("httpSendComplete: FD %d: size %d: errflag %d.n",
  568. fd, size, errflag);
  569.     if (size > 0) {
  570. fd_bytes(fd, size, FD_WRITE);
  571. kb_incr(&Counter.server.all.kbytes_out, size);
  572. kb_incr(&Counter.server.http.kbytes_out, size);
  573.     }
  574.     if (errflag == COMM_ERR_CLOSING)
  575. return;
  576.     if (errflag) {
  577. err = errorCon(ERR_WRITE_ERROR, HTTP_INTERNAL_SERVER_ERROR);
  578. err->xerrno = errno;
  579. err->request = requestLink(httpState->orig_request);
  580. errorAppendEntry(entry, err);
  581. comm_close(fd);
  582. return;
  583.     } else {
  584. /* Schedule read reply. */
  585. commSetSelect(fd,
  586.     COMM_SELECT_READ,
  587.     httpReadReply,
  588.     httpState, 0);
  589. commSetDefer(fd, fwdCheckDeferRead, entry);
  590.     }
  591. }
  593. /*
  594.  * build request headers and append them to a given MemBuf 
  595.  * used by httpBuildRequestPrefix()
  596.  * note: calls httpHeaderInit(), the caller is responsible for Clean()-ing
  597.  */
  598. void
  599. httpBuildRequestHeader(request_t * request,
  600.     request_t * orig_request,
  601.     StoreEntry * entry,
  602.     HttpHeader * hdr_out,
  603.     int cfd,
  604.     http_state_flags flags)
  605. {
  606.     /* building buffer for complex strings */
  607. #define BBUF_SZ (MAX_URL+32)
  608.     LOCAL_ARRAY(char, bbuf, BBUF_SZ);
  609.     String strConnection = StringNull;
  610.     const HttpHeader *hdr_in = &orig_request->header;
  611.     int we_do_ranges;
  612.     const HttpHeaderEntry *e;
  613.     HttpHeaderPos pos = HttpHeaderInitPos;
  614.     httpHeaderInit(hdr_out, hoRequest);
  615.     /* append our IMS header */
  616.     if (entry && entry->lastmod > -1 && request->method == METHOD_GET)
  617. httpHeaderPutTime(hdr_out, HDR_IF_MODIFIED_SINCE, entry->lastmod);
  619.     /* decide if we want to do Ranges ourselves 
  620.      * (and fetch the whole object now)
  621.      * We want to handle Ranges ourselves iff
  622.      *    - we can actually parse client Range specs
  623.      *    - the specs are expected to be simple enough (e.g. no out-of-order ranges)
  624.      *    - reply will be cachable
  625.      * (If the reply will be uncachable we have to throw it away after 
  626.      *  serving this request, so it is better to forward ranges to 
  627.      *  the server and fetch only the requested content) 
  628.      */
  629.     we_do_ranges =
  630. orig_request->range && orig_request->flags.cachable && !httpHdrRangeWillBeComplex(orig_request->range) && (Config.rangeOffsetLimit == -1 || httpHdrRangeFirstOffset(orig_request->range) <= Config.rangeOffsetLimit);
  631.     debug(11, 8) ("httpBuildRequestHeader: range specs: %p, cachable: %d; we_do_ranges: %dn",
  632. orig_request->range, orig_request->flags.cachable, we_do_ranges);
  634.     strConnection = httpHeaderGetList(hdr_in, HDR_CONNECTION);
  635.     while ((e = httpHeaderGetEntry(hdr_in, &pos))) {
  636. debug(11, 5) ("httpBuildRequestHeader: %s: %sn",
  637.     strBuf(e->name), strBuf(e->value));
  638. if (!httpRequestHdrAllowed(e, &strConnection))
  639.     continue;
  640. switch (e->id) {
  641. case HDR_PROXY_AUTHORIZATION:
  642.     /* If we're not doing proxy auth, then it must be passed on */
  643.     if (!request->flags.used_proxy_auth)
  644. httpHeaderAddEntry(hdr_out, httpHeaderEntryClone(e));
  645.     break;
  646. case HDR_AUTHORIZATION:
  647.     /* If we're not doing www auth, then it must be passed on */
  648.     if (!request->flags.accelerated || !request->flags.used_proxy_auth)
  649. httpHeaderAddEntry(hdr_out, httpHeaderEntryClone(e));
  650.     else
  651. request->flags.auth = 0; /* We have used the authentication */
  652.     break;
  653. case HDR_HOST:
  654.     /* Don't use client's Host: header for redirected requests */
  655.     if (!request->flags.redirected || !Config.onoff.redir_rewrites_host)
  656. httpHeaderAddEntry(hdr_out, httpHeaderEntryClone(e));
  657.     break;
  658. case HDR_IF_MODIFIED_SINCE:
  659.     /* append unless we added our own;
  660.      * note: at most one client's ims header can pass through */
  661.     if (!httpHeaderHas(hdr_out, HDR_IF_MODIFIED_SINCE))
  662. httpHeaderAddEntry(hdr_out, httpHeaderEntryClone(e));
  663.     break;
  664. case HDR_MAX_FORWARDS:
  665.     if (orig_request->method == METHOD_TRACE) {
  666. /* sacrificing efficiency over clarity, etc. */
  667. const int hops = httpHeaderGetInt(hdr_in, HDR_MAX_FORWARDS);
  668. if (hops > 0)
  669.     httpHeaderPutInt(hdr_out, HDR_MAX_FORWARDS, hops - 1);
  670.     }
  671.     break;
  672. case HDR_RANGE:
  673. case HDR_IF_RANGE:
  674. case HDR_REQUEST_RANGE:
  675.     if (!we_do_ranges)
  676. httpHeaderAddEntry(hdr_out, httpHeaderEntryClone(e));
  677.     break;
  678. case HDR_PROXY_CONNECTION:
  679. case HDR_CONNECTION:
  680. case HDR_VIA:
  681. case HDR_X_FORWARDED_FOR:
  682. case HDR_CACHE_CONTROL:
  683.     /* append these after the loop if needed */
  684.     break;
  685. default:
  686.     /* pass on all other header fields */
  687.     httpHeaderAddEntry(hdr_out, httpHeaderEntryClone(e));
  688. }
  689.     }
  691.     /* append fake user agent if configured and 
  692.      * the real one is not supplied by the client */
  693.     if (Config.fake_ua && !httpHeaderHas(hdr_out, HDR_USER_AGENT))
  694. httpHeaderPutStr(hdr_out, HDR_USER_AGENT, Config.fake_ua);
  696.     /* append Via */
  697.     {
  698. String strVia = httpHeaderGetList(hdr_in, HDR_VIA);
  699. snprintf(bbuf, BBUF_SZ, "%3.1f %s", orig_request->http_ver, ThisCache);
  700. strListAdd(&strVia, bbuf, ',');
  701. httpHeaderPutStr(hdr_out, HDR_VIA, strBuf(strVia));
  702. stringClean(&strVia);
  703.     }
  704.     /* append X-Forwarded-For */
  705.     {
  706. String strFwd = httpHeaderGetList(hdr_in, HDR_X_FORWARDED_FOR);
  707. strListAdd(&strFwd, (cfd < 0 ? "unknown" : fd_table[cfd].ipaddr), ',');
  708. httpHeaderPutStr(hdr_out, HDR_X_FORWARDED_FOR, strBuf(strFwd));
  709. stringClean(&strFwd);
  710.     }
  711.     /* append Host if not there already */
  712.     if (!httpHeaderHas(hdr_out, HDR_HOST)) {
  713. /* use port# only if not default */
  714. if (orig_request->port == urlDefaultPort(orig_request->protocol)) {
  715.     httpHeaderPutStr(hdr_out, HDR_HOST, orig_request->host);
  716. } else {
  717.     httpHeaderPutStrf(hdr_out, HDR_HOST, "%s:%d",
  718. orig_request->host, (int) orig_request->port);
  719. }
  720.     }
  721.     /* append Authorization if known in URL, not in header and going direct */
  722.     if (!httpHeaderHas(hdr_out, HDR_AUTHORIZATION)) {
  723. if (!request->flags.proxying && *request->login) {
  724.     httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
  725. base64_encode(request->login));
  726. }
  727.     }
  728.     /* append Proxy-Authorization if configured for peer, and proxying */
  729.     if (!httpHeaderHas(hdr_out, HDR_PROXY_AUTHORIZATION)) {
  730. if (request->flags.proxying && request->peer_login) {
  731.     httpHeaderPutStrf(hdr_out, HDR_PROXY_AUTHORIZATION, "Basic %s",
  732. base64_encode(request->peer_login));
  733. }
  734.     }
  735.     /* append Cache-Control, add max-age if not there already */
  736.     {
  737. HttpHdrCc *cc = httpHeaderGetCc(hdr_in);
  738. if (!cc)
  739.     cc = httpHdrCcCreate();
  740. if (!EBIT_TEST(cc->mask, CC_MAX_AGE)) {
  741.     const char *url = entry ? storeUrl(entry) : urlCanonical(orig_request);
  742.     httpHdrCcSetMaxAge(cc, getMaxAge(url));
  743.     if (strLen(request->urlpath))
  744. assert(strstr(url, strBuf(request->urlpath)));
  745. }
  746. if (flags.only_if_cached)
  747.     EBIT_SET(cc->mask, CC_ONLY_IF_CACHED);
  748. httpHeaderPutCc(hdr_out, cc);
  749. httpHdrCcDestroy(cc);
  750.     }
  751.     /* maybe append Connection: keep-alive */
  752.     if (flags.keepalive) {
  753. if (flags.proxying) {
  754.     httpHeaderPutStr(hdr_out, HDR_PROXY_CONNECTION, "keep-alive");
  755. } else {
  756.     httpHeaderPutStr(hdr_out, HDR_CONNECTION, "keep-alive");
  757. }
  758.     }
  759.     stringClean(&strConnection);
  760. }
  762. /* build request prefix and append it to a given MemBuf; 
  763.  * return the length of the prefix */
  764. size_t
  765. httpBuildRequestPrefix(request_t * request,
  766.     request_t * orig_request,
  767.     StoreEntry * entry,
  768.     MemBuf * mb,
  769.     int cfd,
  770.     http_state_flags flags)
  771. {
  772.     const int offset = mb->size;
  773.     memBufPrintf(mb, "%s %s HTTP/1.0rn",
  774. RequestMethodStr[request->method],
  775. strLen(request->urlpath) ? strBuf(request->urlpath) : "/");
  776.     /* build and pack headers */
  777.     {
  778. HttpHeader hdr;
  779. Packer p;
  780. httpBuildRequestHeader(request, orig_request, entry, &hdr, cfd, flags);
  781. packerToMemInit(&p, mb);
  782. httpHeaderPackInto(&hdr, &p);
  783. httpHeaderClean(&hdr);
  784. packerClean(&p);
  785.     }
  786.     /* append header terminator */
  787.     memBufAppend(mb, crlf, 2);
  788.     return mb->size - offset;
  789. }
  790. /* This will be called when connect completes. Write request. */
  791. static void
  792. httpSendRequest(int fd, void *data)
  793. {
  794.     HttpStateData *httpState = data;
  795.     MemBuf mb;
  796.     request_t *req = httpState->request;
  797.     StoreEntry *entry = httpState->entry;
  798.     int cfd;
  799.     peer *p = httpState->peer;
  800.     CWCB *sendHeaderDone;
  802.     debug(11, 5) ("httpSendRequest: FD %d: httpState %p.n", fd, httpState);
  804.     if (pumpMethod(req->method))
  805. sendHeaderDone = httpSendRequestEntry;
  806.     else
  807. sendHeaderDone = httpSendComplete;
  809.     if (!opt_forwarded_for)
  810. cfd = -1;
  811.     else if (entry->mem_obj == NULL)
  812. cfd = -1;
  813.     else
  814. cfd = entry->mem_obj->fd;
  815.     assert(-1 == cfd || FD_SOCKET == fd_table[cfd].type);
  816.     if (p != NULL)
  817. httpState->flags.proxying = 1;
  818.     /*
  819.      * Is keep-alive okay for all request methods?
  820.      */
  821.     if (p == NULL)
  822. httpState->flags.keepalive = 1;
  823.     else if (p->stats.n_keepalives_sent < 10)
  824. httpState->flags.keepalive = 1;
  825.     else if ((double) p->stats.n_keepalives_recv / (double) p->stats.n_keepalives_sent > 0.50)
  826. httpState->flags.keepalive = 1;
  827.     if (httpState->peer)
  828. if (neighborType(httpState->peer, httpState->request) == PEER_SIBLING)
  829.     httpState->flags.only_if_cached = 1;
  830.     memBufDefInit(&mb);
  831.     httpBuildRequestPrefix(req,
  832. httpState->orig_request,
  833. entry,
  834. &mb,
  835. cfd,
  836. httpState->flags);
  837.     debug(11, 6) ("httpSendRequest: FD %d:n%sn", fd, mb.buf);
  838.     comm_write_mbuf(fd, mb, sendHeaderDone, httpState);
  839. }
  840. void
  841. httpStart(FwdState * fwd)
  842. {
  843.     int fd = fwd->server_fd;
  844.     HttpStateData *httpState = memAllocate(MEM_HTTP_STATE_DATA);
  845.     request_t *proxy_req;
  846.     request_t *orig_req = fwd->request;
  847.     debug(11, 3) ("httpStart: "%s %s"n",
  848. RequestMethodStr[orig_req->method],
  849. storeUrl(fwd->entry));
  850.     cbdataAdd(httpState, memFree, MEM_HTTP_STATE_DATA);
  851.     storeLockObject(fwd->entry);
  852.     httpState->fwd = fwd;
  853.     httpState->entry = fwd->entry;
  854.     httpState->fd = fd;
  855.     if (fwd->servers)
  856. httpState->peer = fwd->servers->peer; /* might be NULL */
  857.     if (httpState->peer) {
  858. proxy_req = requestCreate(orig_req->method,
  859.     PROTO_NONE, storeUrl(httpState->entry));
  860. xstrncpy(proxy_req->host, httpState->peer->host, SQUIDHOSTNAMELEN);
  861. proxy_req->port = httpState->peer->http_port;
  862. proxy_req->flags = orig_req->flags;
  863. proxy_req->peer_login = httpState->peer->login;
  864. httpState->request = requestLink(proxy_req);
  865. httpState->orig_request = requestLink(orig_req);
  866. proxy_req->flags.proxying = 1;
  867. /*
  868.  * This NEIGHBOR_PROXY_ONLY check probably shouldn't be here.
  869.  * We might end up getting the object from somewhere else if,
  870.  * for example, the request to this neighbor fails.
  871.  */
  872. if (httpState->peer->options.proxy_only)
  873.     storeReleaseRequest(httpState->entry);
  874. #if DELAY_POOLS
  875. assert(delayIsNoDelay(fd) == 0);
  876. if (httpState->peer->options.no_delay)
  877.     delaySetNoDelay(fd);
  878. #endif
  879.     } else {
  880. httpState->request = requestLink(orig_req);
  881. httpState->orig_request = requestLink(orig_req);
  882.     }
  883.     /*
  884.      * register the handler to free HTTP state data when the FD closes
  885.      */
  886.     comm_add_close_handler(fd, httpStateFree, httpState);
  887.     Counter.server.all.requests++;
  888.     Counter.server.http.requests++;
  889.     httpConnectDone(fd, COMM_OK, httpState);
  890. }
  892. static void
  893. httpConnectDone(int fd, int status, void *data)
  894. {
  895.     HttpStateData *httpState = data;
  896.     request_t *request = httpState->request;
  897.     StoreEntry *entry = httpState->entry;
  898.     ErrorState *err;
  899.     if (status == COMM_ERR_DNS) {
  900. debug(11, 4) ("httpConnectDone: Unknown host: %sn", request->host);
  901. err = errorCon(ERR_DNS_FAIL, HTTP_SERVICE_UNAVAILABLE);
  902. err->dnsserver_msg = xstrdup(dns_error_message);
  903. err->request = requestLink(httpState->orig_request);
  904. errorAppendEntry(entry, err);
  905. comm_close(fd);
  906.     } else if (status != COMM_OK) {
  907. err = errorCon(ERR_CONNECT_FAIL, HTTP_SERVICE_UNAVAILABLE);
  908. err->xerrno = errno;
  909. err->host = xstrdup(request->host);
  910. err->port = request->port;
  911. err->request = requestLink(httpState->orig_request);
  912. errorAppendEntry(entry, err);
  913. if (httpState->peer)
  914.     peerCheckConnectStart(httpState->peer);
  915. comm_close(fd);
  916.     } else {
  917. commSetSelect(fd, COMM_SELECT_WRITE, httpSendRequest, httpState, 0);
  918. commSetTimeout(fd, Config.Timeout.read, httpTimeout, httpState);
  919.     }
  920. }
  922. static void
  923. httpSendRequestEntry(int fd, char *bufnotused, size_t size, int errflag, void *data)
  924. {
  925.     HttpStateData *httpState = data;
  926.     StoreEntry *entry = httpState->entry;
  927.     ErrorState *err;
  928.     debug(11, 5) ("httpSendRequestEntry: FD %d: size %d: errflag %d.n",
  929. fd, size, errflag);
  930.     if (size > 0) {
  931. fd_bytes(fd, size, FD_WRITE);
  932. kb_incr(&Counter.server.all.kbytes_out, size);
  933. kb_incr(&Counter.server.http.kbytes_out, size);
  934.     }
  935.     if (errflag == COMM_ERR_CLOSING)
  936. return;
  937.     if (errflag) {
  938. err = errorCon(ERR_WRITE_ERROR, HTTP_INTERNAL_SERVER_ERROR);
  939. err->xerrno = errno;
  940. err->request = requestLink(httpState->orig_request);
  941. errorAppendEntry(entry, err);
  942. comm_close(fd);
  943. return;
  944.     }
  945.     pumpStart(fd, httpState->fwd, httpSendRequestEntryDone, httpState);
  946. }
  948. static void
  949. httpSendRequestEntryDone(int fd, char *bufnotused, size_t size, int errflag, void *data)
  950. {
  951.     HttpStateData *httpState = data;
  952.     StoreEntry *entry = httpState->entry;
  953.     ErrorState *err;
  954.     aclCheck_t ch;
  955.     debug(11, 5) ("httpSendRequestEntryDone: FD %d: size %d: errflag %d.n",
  956. fd, size, errflag);
  957.     if (size > 0) {
  958. fd_bytes(fd, size, FD_WRITE);
  959. kb_incr(&Counter.server.all.kbytes_out, size);
  960. kb_incr(&Counter.server.http.kbytes_out, size);
  961.     }
  962.     if (errflag == COMM_ERR_CLOSING)
  963. return;
  964.     if (errflag) {
  965. err = errorCon(ERR_WRITE_ERROR, HTTP_INTERNAL_SERVER_ERROR);
  966. err->xerrno = errno;
  967. err->request = requestLink(httpState->orig_request);
  968. errorAppendEntry(entry, err);
  969. comm_close(fd);
  970. return;
  971.     }
  972.     memset(&ch, '', sizeof(ch));
  973.     ch.request = httpState->request;
  974.     if (!Config.accessList.brokenPosts) {
  975. debug(11, 5) ("httpSendRequestEntryDone: No brokenPosts listn");
  976. httpSendComplete(fd, NULL, 0, 0, data);
  977.     } else if (!aclCheckFast(Config.accessList.brokenPosts, &ch)) {
  978. debug(11, 5) ("httpSendRequestEntryDone: didn't match brokenPostsn");
  979. httpSendComplete(fd, NULL, 0, 0, data);
  980.     } else {
  981. debug(11, 2) ("httpSendRequestEntryDone: matched brokenPostsn");
  982. comm_write(fd, "rn", 2, httpSendComplete, data, NULL);
  983.     }
  984. }