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

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

代理服务器

开发平台：

Unix_Linux

forward.c：源码内容
  2. /*
  3.  * $Id: forward.c,v 1.54 1999/01/29 23:39:18 wessels Exp $
  4.  *
  5.  * DEBUG: section 17    Request Forwarding
  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.  */
  37. #include "squid.h"
  39. static PSC fwdStartComplete;
  40. static void fwdDispatch(FwdState *);
  41. static void fwdConnectStart(void *); /* should be same as EVH */
  42. static void fwdStateFree(FwdState * fwdState);
  43. static PF fwdConnectTimeout;
  44. static PF fwdServerClosed;
  45. static CNCB fwdConnectDone;
  46. static int fwdCheckRetry(FwdState * fwdState);
  47. static int fwdReforward(FwdState *);
  48. static void fwdStartFail(FwdState *);
  49. static void fwdLogReplyStatus(int tries, http_status status);
  50. static OBJH fwdStats;
  51. static STABH fwdAbort;
  53. #define MAX_FWD_STATS_IDX 9
  54. static int FwdReplyCodes[MAX_FWD_STATS_IDX + 1][HTTP_INVALID_HEADER + 1];
  56. static void
  57. fwdServerFree(FwdServer * fs)
  58. {
  59.     if (fs->peer)
  60. cbdataUnlock(fs->peer);
  61.     memFree(fs, MEM_FWD_SERVER);
  62. }
  64. static void
  65. fwdServersFree(FwdServer ** FS)
  66. {
  67.     FwdServer *fs;
  68.     while ((fs = *FS)) {
  69. *FS = fs->next;
  70. fwdServerFree(fs);
  71.     }
  72. }
  74. static void
  75. fwdStateFree(FwdState * fwdState)
  76. {
  77.     StoreEntry *e = fwdState->entry;
  78.     int sfd;
  79.     debug(17, 3) ("fwdStateFree: %pn", fwdState);
  80.     assert(e->mem_obj);
  81.     if (e->store_status == STORE_PENDING) {
  82. if (e->mem_obj->inmem_hi == 0) {
  83.     assert(fwdState->err);
  84.     errorAppendEntry(e, fwdState->err);
  85. } else {
  86.     EBIT_CLR(e->flags, ENTRY_FWD_HDR_WAIT);
  87.     storeComplete(e);
  88.     storeReleaseRequest(e);
  89. }
  90.     }
  91.     if (storePendingNClients(e) > 0)
  92. assert(!EBIT_TEST(e->flags, ENTRY_FWD_HDR_WAIT));
  93.     fwdServersFree(&fwdState->servers);
  94.     requestUnlink(fwdState->request);
  95.     fwdState->request = NULL;
  96.     storeUnregisterAbort(e);
  97.     storeUnlockObject(e);
  98.     fwdState->entry = NULL;
  99.     sfd = fwdState->server_fd;
  100.     if (sfd > -1) {
  101. comm_remove_close_handler(sfd, fwdServerClosed, fwdState);
  102. fwdState->server_fd = -1;
  103. debug(17, 3) ("fwdStateFree: closing FD %dn", sfd);
  104. comm_close(sfd);
  105.     }
  106.     cbdataFree(fwdState);
  107. }
  109. static int
  110. fwdCheckRetry(FwdState * fwdState)
  111. {
  112.     if (fwdState->entry->store_status != STORE_PENDING)
  113. return 0;
  114.     if (fwdState->entry->mem_obj->inmem_hi > 0)
  115. return 0;
  116.     if (fwdState->n_tries > 10)
  117. return 0;
  118.     if (squid_curtime - fwdState->start > 120)
  119. return 0;
  120.     if (fwdState->flags.dont_retry)
  121. return 0;
  122.     if (pumpMethod(fwdState->request->method))
  123. if (0 == pumpRestart(fwdState->request))
  124.     return 0;
  125.     return 1;
  126. }
  128. static void
  129. fwdServerClosed(int fd, void *data)
  130. {
  131.     FwdState *fwdState = data;
  132.     debug(17, 2) ("fwdServerClosed: FD %d %sn", fd, storeUrl(fwdState->entry));
  133.     assert(fwdState->server_fd == fd);
  134.     fwdState->server_fd = -1;
  135.     if (fwdCheckRetry(fwdState)) {
  136. debug(17, 3) ("fwdServerClosed: re-forwarding (%d tries, %d secs)n",
  137.     fwdState->n_tries,
  138.     (int) (squid_curtime - fwdState->start));
  139. /* use eventAdd to break potential call sequence loops */
  140. eventAdd("fwdConnectStart", fwdConnectStart, fwdState, 0.0, 1);
  141.     } else {
  142. fwdStateFree(fwdState);
  143.     }
  144. }
  146. static void
  147. fwdConnectDone(int server_fd, int status, void *data)
  148. {
  149.     FwdState *fwdState = data;
  150.     static FwdState *current = NULL;
  151.     FwdServer *fs = fwdState->servers;
  152.     ErrorState *err;
  153.     request_t *request = fwdState->request;
  154.     assert(current != fwdState);
  155.     current = fwdState;
  156.     assert(fwdState->server_fd == server_fd);
  157.     if (status == COMM_ERR_DNS) {
  158. fwdState->flags.dont_retry = 1;
  159. debug(17, 4) ("fwdConnectDone: Unknown host: %sn",
  160.     request->host);
  161. err = errorCon(ERR_DNS_FAIL, HTTP_SERVICE_UNAVAILABLE);
  162. err->dnsserver_msg = xstrdup(dns_error_message);
  163. err->request = requestLink(request);
  164. fwdFail(fwdState, err);
  165. comm_close(server_fd);
  166.     } else if (status != COMM_OK) {
  167. assert(fs);
  168. err = errorCon(ERR_CONNECT_FAIL, HTTP_SERVICE_UNAVAILABLE);
  169. err->xerrno = errno;
  170. if (fs->peer) {
  171.     err->host = xstrdup(fs->peer->host);
  172.     err->port = fs->peer->http_port;
  173. } else {
  174.     err->host = xstrdup(request->host);
  175.     err->port = request->port;
  176. }
  177. err->request = requestLink(request);
  178. fwdFail(fwdState, err);
  179. if (fs->peer)
  180.     peerCheckConnectStart(fs->peer);
  181. comm_close(server_fd);
  182.     } else {
  183. debug(17, 3) ("fwdConnectDone: FD %d: '%s'n", server_fd, storeUrl(fwdState->entry));
  184. fd_note(server_fd, storeUrl(fwdState->entry));
  185. fd_table[server_fd].uses++;
  186. fwdDispatch(fwdState);
  187.     }
  188.     current = NULL;
  189. }
  191. static void
  192. fwdConnectTimeout(int fd, void *data)
  193. {
  194.     FwdState *fwdState = data;
  195.     StoreEntry *entry = fwdState->entry;
  196.     ErrorState *err;
  197.     debug(17, 2) ("fwdConnectTimeout: FD %d: '%s'n", fd, storeUrl(entry));
  198.     assert(fd == fwdState->server_fd);
  199.     if (entry->mem_obj->inmem_hi == 0) {
  200. err = errorCon(ERR_CONNECT_FAIL, HTTP_GATEWAY_TIMEOUT);
  201. err->request = requestLink(fwdState->request);
  202. err->xerrno = ETIMEDOUT;
  203. fwdFail(fwdState, err);
  204.     }
  205.     comm_close(fd);
  206. }
  208. static void
  209. fwdConnectStart(void *data)
  210. {
  211.     FwdState *fwdState = data;
  212.     const char *url = storeUrl(fwdState->entry);
  213.     int fd;
  214.     ErrorState *err;
  215.     FwdServer *fs = fwdState->servers;
  216.     const char *host;
  217.     unsigned short port;
  218.     assert(fs);
  219.     assert(fwdState->server_fd == -1);
  220.     debug(17, 3) ("fwdConnectStart: %sn", url);
  221.     if (fs->peer) {
  222. host = fs->peer->host;
  223. port = fs->peer->http_port;
  224.     } else {
  225. host = fwdState->request->host;
  226. port = fwdState->request->port;
  227.     }
  228.     hierarchyNote(&fwdState->request->hier, fs->code, host);
  229.     if ((fd = pconnPop(host, port)) >= 0) {
  230. debug(17, 3) ("fwdConnectStart: reusing pconn FD %dn", fd);
  231. fwdState->server_fd = fd;
  232. fwdState->n_tries++;
  233. comm_add_close_handler(fd, fwdServerClosed, fwdState);
  234. fwdConnectDone(fd, COMM_OK, fwdState);
  235. return;
  236.     }
  237.     fd = comm_open(SOCK_STREAM,
  238. 0,
  239. Config.Addrs.tcp_outgoing,
  240. 0,
  241. COMM_NONBLOCKING,
  242. url);
  243.     if (fd < 0) {
  244. debug(50, 4) ("fwdConnectStart: %sn", xstrerror());
  245. err = errorCon(ERR_SOCKET_FAILURE, HTTP_INTERNAL_SERVER_ERROR);
  246. err->xerrno = errno;
  247. err->request = requestLink(fwdState->request);
  248. fwdFail(fwdState, err);
  249. fwdStateFree(fwdState);
  250. return;
  251.     }
  252.     fwdState->server_fd = fd;
  253.     fwdState->n_tries++;
  254.     comm_add_close_handler(fd, fwdServerClosed, fwdState);
  255.     commSetTimeout(fd,
  256. Config.Timeout.connect,
  257. fwdConnectTimeout,
  258. fwdState);
  259.     commConnectStart(fd, host, port, fwdConnectDone, fwdState);
  260. }
  262. static void
  263. fwdStartComplete(FwdServer * servers, void *data)
  264. {
  265.     FwdState *fwdState = data;
  266.     debug(17, 3) ("fwdStartComplete: %sn", storeUrl(fwdState->entry));
  267.     if (servers != NULL) {
  268. fwdState->servers = servers;
  269. fwdConnectStart(fwdState);
  270.     } else {
  271. fwdStartFail(fwdState);
  272.     }
  273. }
  275. static void
  276. fwdStartFail(FwdState * fwdState)
  277. {
  278.     ErrorState *err;
  279.     debug(17, 3) ("fwdStartFail: %sn", storeUrl(fwdState->entry));
  280.     err = errorCon(ERR_CANNOT_FORWARD, HTTP_SERVICE_UNAVAILABLE);
  281.     err->request = requestLink(fwdState->request);
  282.     err->xerrno = errno;
  283.     fwdFail(fwdState, err);
  284.     fwdStateFree(fwdState);
  285. }
  287. static void
  288. fwdDispatch(FwdState * fwdState)
  289. {
  290.     peer *p;
  291.     request_t *request = fwdState->request;
  292.     StoreEntry *entry = fwdState->entry;
  293.     debug(17, 3) ("fwdDispatch: FD %d: Fetching '%s %s'n",
  294. fwdState->client_fd,
  295. RequestMethodStr[request->method],
  296. storeUrl(entry));
  297.     /*assert(!EBIT_TEST(entry->flags, ENTRY_DISPATCHED)); */
  298.     assert(entry->ping_status != PING_WAITING);
  299.     assert(entry->lock_count);
  300.     EBIT_SET(entry->flags, ENTRY_DISPATCHED);
  301.     netdbPingSite(request->host);
  302.     /*
  303.      * Assert that server_fd is set.  This is to guarantee that fwdState
  304.      * is attached to something and will be deallocated when server_fd
  305.      * is closed.
  306.      */
  307.     assert(fwdState->server_fd > -1);
  308.     if (fwdState->servers && (p = fwdState->servers->peer)) {
  309. p->stats.fetches++;
  310. httpStart(fwdState);
  311.     } else {
  312. switch (request->protocol) {
  313. case PROTO_HTTP:
  314.     httpStart(fwdState);
  315.     break;
  316. case PROTO_GOPHER:
  317.     gopherStart(fwdState);
  318.     break;
  319. case PROTO_FTP:
  320.     ftpStart(fwdState);
  321.     break;
  322. case PROTO_WAIS:
  323.     waisStart(fwdState);
  324.     break;
  325. case PROTO_CACHEOBJ:
  326. case PROTO_INTERNAL:
  327. case PROTO_URN:
  328.     fatal_dump("Should never get here");
  329.     break;
  330. case PROTO_WHOIS:
  331.     whoisStart(fwdState);
  332.     break;
  333. default:
  334.     debug(17, 1) ("fwdDispatch: Cannot retrieve '%s'n",
  335. storeUrl(entry));
  336.     fwdFail(fwdState, errorCon(ERR_UNSUP_REQ, HTTP_BAD_REQUEST));
  337.     comm_close(fwdState->server_fd);
  338.     break;
  339. }
  340.     }
  341. }
  343. static int
  344. fwdReforward(FwdState * fwdState)
  345. {
  346.     StoreEntry *e = fwdState->entry;
  347.     FwdServer *fs = fwdState->servers;
  348.     http_status s;
  349.     assert(e->store_status == STORE_PENDING);
  350.     assert(e->mem_obj);
  351.     debug(17, 3) ("fwdReforward: %s?n", storeUrl(e));
  352.     if (!EBIT_TEST(e->flags, ENTRY_FWD_HDR_WAIT)) {
  353. debug(17, 3) ("fwdReforward: No, ENTRY_FWD_HDR_WAIT isn't setn");
  354. return 0;
  355.     }
  356.     if (fwdState->n_tries > 9)
  357. return 0;
  358.     if (pumpMethod(fwdState->request->method))
  359. if (0 == pumpRestart(fwdState->request))
  360.     return 0;
  361.     assert(fs);
  362.     fwdState->servers = fs->next;
  363.     fwdServerFree(fs);
  364.     if (fwdState->servers == NULL) {
  365. debug(17, 3) ("fwdReforward: No forward-servers leftn");
  366. return 0;
  367.     }
  368.     s = e->mem_obj->reply->sline.status;
  369.     debug(17, 3) ("fwdReforward: status %dn", (int) s);
  370.     switch (s) {
  371.     case HTTP_FORBIDDEN:
  372.     case HTTP_INTERNAL_SERVER_ERROR:
  373.     case HTTP_NOT_IMPLEMENTED:
  374.     case HTTP_BAD_GATEWAY:
  375.     case HTTP_SERVICE_UNAVAILABLE:
  376.     case HTTP_GATEWAY_TIMEOUT:
  377. return 1;
  378.     default:
  379. return 0;
  380.     }
  381.     /* NOTREACHED */
  382. }
  384. /* PUBLIC FUNCTIONS */
  386. void
  387. fwdStart(int fd, StoreEntry * e, request_t * r, struct in_addr client_addr,
  388.     struct in_addr my_addr)
  389. {
  390.     FwdState *fwdState;
  391.     aclCheck_t ch;
  392.     int answer;
  393.     ErrorState *err;
  394.     /*
  395.      * client_addr == no_addr indicates this is an "internal" request
  396.      * from peer_digest.c, asn.c, netdb.c, etc and should always
  397.      * be allowed.  yuck, I know.
  398.      */
  399.     if (client_addr.s_addr != no_addr.s_addr) {
  400. /*      
  401.  * Check if this host is allowed to fetch MISSES from us (miss_access)
  402.  */
  403. memset(&ch, '', sizeof(aclCheck_t));
  404. ch.src_addr = client_addr;
  405. ch.my_addr = my_addr;
  406. ch.request = r;
  407. answer = aclCheckFast(Config.accessList.miss, &ch);
  408. if (answer == 0) {
  409.     err = errorCon(ERR_FORWARDING_DENIED, HTTP_FORBIDDEN);
  410.     err->request = requestLink(r);
  411.     err->src_addr = client_addr;
  412.     errorAppendEntry(e, err);
  413.     return;
  414. }
  415.     }
  416.     debug(17, 3) ("fwdStart: '%s'n", storeUrl(e));
  417.     e->mem_obj->request = requestLink(r);
  418.     e->mem_obj->fd = fd;
  419.     if (shutting_down) {
  420. /* more yuck */
  421. err = errorCon(ERR_SHUTTING_DOWN, HTTP_SERVICE_UNAVAILABLE);
  422. err->request = requestLink(r);
  423. errorAppendEntry(e, err);
  424. return;
  425.     }
  426.     switch (r->protocol) {
  427. /*
  428.  * Note, don't create fwdState for these requests
  429.  */
  430.     case PROTO_INTERNAL:
  431. internalStart(r, e);
  432. return;
  433.     case PROTO_CACHEOBJ:
  434. cachemgrStart(fd, r, e);
  435. return;
  436.     case PROTO_URN:
  437. urnStart(r, e);
  438. return;
  439.     default:
  440. break;
  441.     }
  442.     fwdState = memAllocate(MEM_FWD_STATE);
  443.     cbdataAdd(fwdState, memFree, MEM_FWD_STATE);
  444.     fwdState->entry = e;
  445.     fwdState->client_fd = fd;
  446.     fwdState->server_fd = -1;
  447.     fwdState->request = requestLink(r);
  448.     fwdState->start = squid_curtime;
  449.     storeLockObject(e);
  450.     EBIT_SET(e->flags, ENTRY_FWD_HDR_WAIT);
  451.     storeRegisterAbort(e, fwdAbort, fwdState);
  452.     peerSelect(r, e, fwdStartComplete, fwdState);
  453. }
  455. int
  456. fwdCheckDeferRead(int fd, void *data)
  457. {
  458.     StoreEntry *e = data;
  459.     MemObject *mem = e->mem_obj;
  460.     if (mem == NULL)
  461. return 0;
  462. #if DELAY_POOLS
  463.     if (!delayIsNoDelay(fd) && delayMostBytesWanted(mem, 1) == 0)
  464. return 1;
  465. #endif
  466.     if (mem->inmem_hi - storeLowestMemReaderOffset(e) < READ_AHEAD_GAP)
  467. return 0;
  468.     return 1;
  469. }
  471. void
  472. fwdFail(FwdState * fwdState, ErrorState * errorState)
  473. {
  474.     assert(EBIT_TEST(fwdState->entry->flags, ENTRY_FWD_HDR_WAIT));
  475.     debug(17, 3) ("fwdFail: %s "%s"nt%sn",
  476. err_type_str[errorState->type],
  477. httpStatusString(errorState->http_status),
  478. storeUrl(fwdState->entry));
  479.     if (fwdState->err)
  480. errorStateFree(fwdState->err);
  481.     fwdState->err = errorState;
  482. }
  484. /*
  485.  * Called when someone else calls StoreAbort() on this entry
  486.  */
  487. void
  488. fwdAbort(void *data)
  489. {
  490.     FwdState *fwdState = data;
  491.     debug(17, 2) ("fwdAbort: %sn", storeUrl(fwdState->entry));
  492.     fwdStateFree(fwdState);
  493. }
  495. /*
  496.  * Frees fwdState without closing FD or generating an abort
  497.  */
  498. void
  499. fwdUnregister(int fd, FwdState * fwdState)
  500. {
  501.     debug(17, 3) ("fwdUnregister: %sn", storeUrl(fwdState->entry));
  502.     assert(fd = fwdState->server_fd);
  503.     assert(fd > -1);
  504.     comm_remove_close_handler(fd, fwdServerClosed, fwdState);
  505.     fwdState->server_fd = -1;
  506. }
  508. /*
  509.  * server-side modules call fwdComplete() when they are done
  510.  * downloading an object.  Then, we either 1) re-forward the
  511.  * request somewhere else if needed, or 2) call storeComplete()
  512.  * to finish it off
  513.  */
  514. void
  515. fwdComplete(FwdState * fwdState)
  516. {
  517.     StoreEntry *e = fwdState->entry;
  518.     assert(e->store_status == STORE_PENDING);
  519.     debug(17, 3) ("fwdComplete: %sntstatus %dn", storeUrl(e),
  520. e->mem_obj->reply->sline.status);
  521.     fwdLogReplyStatus(fwdState->n_tries, e->mem_obj->reply->sline.status);
  522.     if (fwdReforward(fwdState)) {
  523. debug(17, 3) ("fwdComplete: re-forwarding %d %sn",
  524.     e->mem_obj->reply->sline.status,
  525.     storeUrl(e));
  526. if (fwdState->server_fd > -1)
  527.     fwdUnregister(fwdState->server_fd, fwdState);
  528. storeEntryReset(e);
  529. fwdStartComplete(fwdState->servers, fwdState);
  530.     } else {
  531. debug(17, 3) ("fwdComplete: not re-forwarding status %dn",
  532.     e->mem_obj->reply->sline.status);
  533. EBIT_CLR(e->flags, ENTRY_FWD_HDR_WAIT);
  534. storeComplete(e);
  535. /*
  536.  * If fwdState isn't associated with a server FD, it
  537.  * won't get freed unless we do it here.
  538.  */
  539. if (fwdState->server_fd < 0)
  540.     fwdStateFree(fwdState);
  541.     }
  542. }
  544. void
  545. fwdInit(void)
  546. {
  547.     cachemgrRegister("forward",
  548. "Request Forwarding Statistics",
  549. fwdStats, 0, 1);
  550. }
  552. static void
  553. fwdLogReplyStatus(int tries, http_status status)
  554. {
  555.     if (status > HTTP_INVALID_HEADER)
  556. return;
  557.     assert(tries);
  558.     tries--;
  559.     if (tries > MAX_FWD_STATS_IDX)
  560. tries = MAX_FWD_STATS_IDX;
  561.     FwdReplyCodes[tries][status]++;
  562. }
  564. static void
  565. fwdStats(StoreEntry * s)
  566. {
  567.     int i;
  568.     int j;
  569.     storeAppendPrintf(s, "Status");
  570.     for (j = 0; j <= MAX_FWD_STATS_IDX; j++) {
  571. storeAppendPrintf(s, "ttry#%d", j + 1);
  572.     }
  573.     storeAppendPrintf(s, "n");
  574.     for (i = 0; i <= (int) HTTP_INVALID_HEADER; i++) {
  575. if (FwdReplyCodes[0][i] == 0)
  576.     continue;
  577. storeAppendPrintf(s, "%3d", i);
  578. for (j = 0; j <= MAX_FWD_STATS_IDX; j++) {
  579.     storeAppendPrintf(s, "t%d", FwdReplyCodes[j][i]);
  580. }
  581. storeAppendPrintf(s, "n");
  582.     }
  583. }