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

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

代理服务器

开发平台：

Unix_Linux

neighbors.c：源码内容
  2. /*
  3.  * $Id: neighbors.c,v 1.270.2.2 1999/02/12 21:41:51 wessels Exp $
  4.  *
  5.  * DEBUG: section 15    Neighbor Routines
  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. #include "squid.h"
  38. /* count mcast group peers every 15 minutes */
  39. #define MCAST_COUNT_RATE 900
  41. static int peerAllowedToUse(const peer *, request_t *);
  42. static int peerWouldBePinged(const peer *, request_t *);
  43. static void neighborRemove(peer *);
  44. static void neighborAlive(peer *, const MemObject *, const icp_common_t *);
  45. #if USE_HTCP
  46. static void neighborAliveHtcp(peer *, const MemObject *, const htcpReplyData *);
  47. #endif
  48. static void neighborCountIgnored(peer *);
  49. static void peerRefreshDNS(void *);
  50. static IPH peerDNSConfigure;
  51. static EVH peerCheckConnect;
  52. static IPH peerCheckConnect2;
  53. static CNCB peerCheckConnectDone;
  54. static void peerCountMcastPeersDone(void *data);
  55. static void peerCountMcastPeersStart(void *data);
  56. static void peerCountMcastPeersSchedule(peer * p, time_t when);
  57. static IRCB peerCountHandleIcpReply;
  58. static void neighborIgnoreNonPeer(const struct sockaddr_in *, icp_opcode);
  59. static OBJH neighborDumpPeers;
  60. static OBJH neighborDumpNonPeers;
  61. static void dump_peers(StoreEntry * sentry, peer * peers);
  63. static icp_common_t echo_hdr;
  64. static u_short echo_port;
  66. static int NLateReplies = 0;
  67. static peer *first_ping = NULL;
  69. char *
  70. neighborTypeStr(const peer * p)
  71. {
  72.     if (p->type == PEER_NONE)
  73. return "Non-Peer";
  74.     if (p->type == PEER_SIBLING)
  75. return "Sibling";
  76.     if (p->type == PEER_MULTICAST)
  77. return "Multicast Group";
  78.     return "Parent";
  79. }
  82. peer *
  83. whichPeer(const struct sockaddr_in * from)
  84. {
  85.     int j;
  86.     u_short port = ntohs(from->sin_port);
  87.     struct in_addr ip = from->sin_addr;
  88.     peer *p = NULL;
  89.     debug(15, 3) ("whichPeer: from %s port %dn", inet_ntoa(ip), port);
  90.     for (p = Config.peers; p; p = p->next) {
  91. for (j = 0; j < p->n_addresses; j++) {
  92.     if (ip.s_addr == p->addresses[j].s_addr && port == p->icp.port) {
  93. return p;
  94.     }
  95. }
  96.     }
  97.     return NULL;
  98. }
  100. peer_t
  101. neighborType(const peer * p, const request_t * request)
  102. {
  103.     const struct _domain_type *d = NULL;
  104.     for (d = p->typelist; d; d = d->next) {
  105. if (matchDomainName(d->domain, request->host))
  106.     if (d->type != PEER_NONE)
  107. return d->type;
  108.     }
  109.     return p->type;
  110. }
  112. /*
  113.  * peerAllowedToUse
  114.  *
  115.  * this function figures out if it is appropriate to fetch REQUEST
  116.  * from PEER.
  117.  */
  118. static int
  119. peerAllowedToUse(const peer * p, request_t * request)
  120. {
  121.     const struct _domain_ping *d = NULL;
  122.     int do_ping = 1;
  123.     aclCheck_t checklist;
  124.     assert(request != NULL);
  125.     if (neighborType(p, request) == PEER_SIBLING) {
  126. if (request->flags.nocache)
  127.     return 0;
  128. if (request->flags.refresh)
  129.     return 0;
  130. if (request->flags.loopdetect)
  131.     return 0;
  132. if (request->flags.need_validation)
  133.     return 0;
  134.     }
  135.     if (p->peer_domain == NULL && p->access == NULL)
  136. return do_ping;
  137.     do_ping = 0;
  138.     for (d = p->peer_domain; d; d = d->next) {
  139. if (matchDomainName(d->domain, request->host)) {
  140.     do_ping = d->do_ping;
  141.     break;
  142. }
  143. do_ping = !d->do_ping;
  144.     }
  145.     if (p->peer_domain && 0 == do_ping)
  146. return do_ping;
  147.     if (p->access == NULL)
  148. return do_ping;
  149.     checklist.src_addr = request->client_addr;
  150.     checklist.my_addr = request->my_addr;
  151.     checklist.request = request;
  152.     return aclCheckFast(p->access, &checklist);
  153. }
  155. /* Return TRUE if it is okay to send an ICP request to this peer.   */
  156. static int
  157. peerWouldBePinged(const peer * p, request_t * request)
  158. {
  159.     if (!peerAllowedToUse(p, request))
  160. return 0;
  161.     if (p->options.no_query)
  162. return 0;
  163.     if (p->options.mcast_responder)
  164. return 0;
  165.     /* the case below seems strange, but can happen if the
  166.      * URL host is on the other side of a firewall */
  167.     if (p->type == PEER_SIBLING)
  168. if (!request->flags.hierarchical)
  169.     return 0;
  170.     if (p->icp.port == echo_port)
  171. if (!neighborUp(p))
  172.     return 0;
  173.     if (p->n_addresses == 0)
  174. return 0;
  175.     return 1;
  176. }
  178. /* Return TRUE if it is okay to send an HTTP request to this peer. */
  179. int
  180. peerHTTPOkay(const peer * p, request_t * request)
  181. {
  182.     if (!peerAllowedToUse(p, request))
  183. return 0;
  184.     if (!neighborUp(p))
  185. return 0;
  186.     return 1;
  187. }
  189. int
  190. neighborsCount(request_t * request)
  191. {
  192.     peer *p = NULL;
  193.     int count = 0;
  194.     for (p = Config.peers; p; p = p->next)
  195. if (peerWouldBePinged(p, request))
  196.     count++;
  197.     debug(15, 3) ("neighborsCount: %dn", count);
  198.     return count;
  199. }
  201. peer *
  202. getSingleParent(request_t * request)
  203. {
  204.     peer *p = NULL;
  205.     peer *q = NULL;
  206.     for (q = Config.peers; q; q = q->next) {
  207. if (!peerHTTPOkay(q, request))
  208.     continue;
  209. if (neighborType(q, request) != PEER_PARENT)
  210.     return NULL; /* oops, found SIBLING */
  211. if (p)
  212.     return NULL; /* oops, found second parent */
  213. p = q;
  214.     }
  215.     if (p != NULL && !p->options.no_query)
  216. return NULL;
  217.     debug(15, 3) ("getSingleParent: returning %sn", p ? p->host : "NULL");
  218.     return p;
  219. }
  221. peer *
  222. getFirstUpParent(request_t * request)
  223. {
  224.     peer *p = NULL;
  225.     for (p = Config.peers; p; p = p->next) {
  226. if (!neighborUp(p))
  227.     continue;
  228. if (neighborType(p, request) != PEER_PARENT)
  229.     continue;
  230. if (!peerHTTPOkay(p, request))
  231.     continue;
  232. break;
  233.     }
  234.     debug(15, 3) ("getFirstUpParent: returning %sn", p ? p->host : "NULL");
  235.     return p;
  236. }
  238. peer *
  239. getRoundRobinParent(request_t * request)
  240. {
  241.     peer *p;
  242.     peer *q = NULL;
  243.     for (p = Config.peers; p; p = p->next) {
  244. if (!p->options.roundrobin)
  245.     continue;
  246. if (neighborType(p, request) != PEER_PARENT)
  247.     continue;
  248. if (!peerHTTPOkay(p, request))
  249.     continue;
  250. if (q && q->rr_count < p->rr_count)
  251.     continue;
  252. q = p;
  253.     }
  254.     if (q)
  255. q->rr_count++;
  256.     debug(15, 3) ("getRoundRobinParent: returning %sn", q ? q->host : "NULL");
  257.     return q;
  258. }
  260. peer *
  261. getDefaultParent(request_t * request)
  262. {
  263.     peer *p = NULL;
  264.     for (p = Config.peers; p; p = p->next) {
  265. if (neighborType(p, request) != PEER_PARENT)
  266.     continue;
  267. if (!p->options.default_parent)
  268.     continue;
  269. if (!peerHTTPOkay(p, request))
  270.     continue;
  271. debug(15, 3) ("getDefaultParent: returning %sn", p->host);
  272. return p;
  273.     }
  274.     debug(15, 3) ("getDefaultParent: returning NULLn");
  275.     return NULL;
  276. }
  278. peer *
  279. getAnyParent(request_t * request)
  280. {
  281.     peer *p = NULL;
  282.     for (p = Config.peers; p; p = p->next) {
  283. if (neighborType(p, request) != PEER_PARENT)
  284.     continue;
  285. if (!peerHTTPOkay(p, request))
  286.     continue;
  287. debug(15, 3) ("getAnyParent: returning %sn", p->host);
  288. return p;
  289.     }
  290.     debug(15, 3) ("getAnyParent: returning NULLn");
  291.     return NULL;
  292. }
  294. peer *
  295. getNextPeer(peer * p)
  296. {
  297.     return p->next;
  298. }
  300. peer *
  301. getFirstPeer(void)
  302. {
  303.     return Config.peers;
  304. }
  306. static void
  307. neighborRemove(peer * target)
  308. {
  309.     peer *p = NULL;
  310.     peer **P = NULL;
  311.     p = Config.peers;
  312.     P = &Config.peers;
  313.     while (p) {
  314. if (target == p)
  315.     break;
  316. P = &p->next;
  317. p = p->next;
  318.     }
  319.     if (p) {
  320. *P = p->next;
  321. cbdataFree(p);
  322. Config.npeers--;
  323.     }
  324.     first_ping = Config.peers;
  325. }
  327. void
  328. neighbors_open(int fd)
  329. {
  330.     struct sockaddr_in name;
  331.     socklen_t len = sizeof(struct sockaddr_in);
  332.     struct servent *sep = NULL;
  333.     memset(&name, '', sizeof(struct sockaddr_in));
  334.     if (getsockname(fd, (struct sockaddr *) &name, &len) < 0)
  335. debug(15, 1) ("getsockname(%d,%p,%p) failed.n", fd, &name, &len);
  336.     peerRefreshDNS((void *) 1);
  337.     if (0 == echo_hdr.opcode) {
  338. echo_hdr.opcode = ICP_SECHO;
  339. echo_hdr.version = ICP_VERSION_CURRENT;
  340. echo_hdr.length = 0;
  341. echo_hdr.reqnum = 0;
  342. echo_hdr.flags = 0;
  343. echo_hdr.pad = 0;
  344. echo_hdr.shostid = name.sin_addr.s_addr;
  345. sep = getservbyname("echo", "udp");
  346. echo_port = sep ? ntohs((u_short) sep->s_port) : 7;
  347.     }
  348.     first_ping = Config.peers;
  349.     cachemgrRegister("server_list",
  350. "Peer Cache Statistics",
  351. neighborDumpPeers, 0, 1);
  352.     cachemgrRegister("non_peers",
  353. "List of Unknown sites sending ICP messages",
  354. neighborDumpNonPeers, 0, 1);
  355. }
  357. int
  358. neighborsUdpPing(request_t * request,
  359.     StoreEntry * entry,
  360.     IRCB * callback,
  361.     void *callback_data,
  362.     int *exprep,
  363.     int *timeout)
  364. {
  365.     const char *url = storeUrl(entry);
  366.     MemObject *mem = entry->mem_obj;
  367.     peer *p = NULL;
  368.     int i;
  369.     int reqnum = 0;
  370.     int flags;
  371.     icp_common_t *query;
  372.     int queries_sent = 0;
  373.     int peers_pinged = 0;
  375.     if (Config.peers == NULL)
  376. return 0;
  377.     if (theOutIcpConnection < 0)
  378. fatal("neighborsUdpPing: There is no ICP socket!");
  379.     assert(entry->swap_status == SWAPOUT_NONE);
  380.     mem->start_ping = current_time;
  381.     mem->ping_reply_callback = callback;
  382.     mem->ircb_data = callback_data;
  383.     *timeout = 0.0;
  384.     reqnum = icpSetCacheKey(entry->key);
  385.     for (i = 0, p = first_ping; i++ < Config.npeers; p = p->next) {
  386. if (p == NULL)
  387.     p = Config.peers;
  388. debug(15, 5) ("neighborsUdpPing: Peer %sn", p->host);
  389. if (!peerWouldBePinged(p, request))
  390.     continue; /* next peer */
  391. peers_pinged++;
  392. debug(15, 4) ("neighborsUdpPing: pinging peer %s for '%s'n",
  393.     p->host, url);
  394. if (p->type == PEER_MULTICAST)
  395.     mcastSetTtl(theOutIcpConnection, p->mcast.ttl);
  396. debug(15, 3) ("neighborsUdpPing: key = '%s'n", storeKeyText(entry->key));
  397. debug(15, 3) ("neighborsUdpPing: reqnum = %dn", reqnum);
  399. #if USE_HTCP
  400. if (p->options.htcp) {
  401.     debug(15, 3) ("neighborsUdpPing: sending HTCP queryn");
  402.     htcpQuery(entry, request, p);
  403. } else
  404. #endif
  405. if (p->icp.port == echo_port) {
  406.     debug(15, 4) ("neighborsUdpPing: Looks like a dumb cache, send DECHO pingn");
  407.     echo_hdr.reqnum = reqnum;
  408.     query = icpCreateMessage(ICP_DECHO, 0, url, reqnum, 0);
  409.     icpUdpSend(theOutIcpConnection,
  410. &p->in_addr,
  411. query,
  412. LOG_ICP_QUERY,
  413. 0);
  414. } else {
  415.     flags = 0;
  416.     if (Config.onoff.query_icmp)
  417. if (p->icp.version == ICP_VERSION_2)
  418.     flags |= ICP_FLAG_SRC_RTT;
  419.     query = icpCreateMessage(ICP_QUERY, flags, url, reqnum, 0);
  420.     icpUdpSend(theOutIcpConnection,
  421. &p->in_addr,
  422. query,
  423. LOG_ICP_QUERY,
  424. 0);
  425. }
  426. queries_sent++;
  428. p->stats.pings_sent++;
  429. if (p->type == PEER_MULTICAST) {
  430.     /*
  431.      * set a bogus last_reply time so neighborUp() never
  432.      * says a multicast peer is dead.
  433.      */
  434.     p->stats.last_reply = squid_curtime;
  435.     (*exprep) += p->mcast.n_replies_expected;
  436. } else if (squid_curtime - p->stats.last_query > Config.Timeout.deadPeer) {
  437.     /*
  438.      * fake a recent reply if its been a long time since our
  439.      * last query
  440.      */
  441.     p->stats.last_reply = squid_curtime;
  442.     /*
  443.      * We used to not expect a reply in this case; we assumed
  444.      * the peer was DEAD if we hadn't queried it in a long
  445.      * time.  However, the number of people whining to
  446.      * squid-users that ICP is broken became unbearable.  They
  447.      * tried a single request which, to their amazement, was
  448.      * forwarded directly to the origin server, even thought
  449.      * they KNEW it was in a neighbor cache.  Ok, I give up, you
  450.      * win!
  451.      */
  452.     (*exprep)++;
  453.     (*timeout) += 1000;
  454. } else if (neighborUp(p)) {
  455.     /* its alive, expect a reply from it */
  456.     (*exprep)++;
  457.     (*timeout) += p->stats.rtt;
  458. } else {
  459.     /* Neighbor is dead; ping it anyway, but don't expect a reply */
  460.     /* log it once at the threshold */
  461.     if (p->stats.logged_state == PEER_ALIVE) {
  462. debug(15, 1) ("Detected DEAD %s: %s/%d/%dn",
  463.     neighborTypeStr(p),
  464.     p->host, p->http_port, p->icp.port);
  465. p->stats.logged_state = PEER_DEAD;
  466.     }
  467. }
  468. p->stats.last_query = squid_curtime;
  469.     }
  470.     if ((first_ping = first_ping->next) == NULL)
  471. first_ping = Config.peers;
  473. #if ALLOW_SOURCE_PING
  474.     /* only do source_ping if we have neighbors */
  475.     if (Config.npeers) {
  476. const ipcache_addrs *ia = NULL;
  477. struct sockaddr_in to_addr;
  478. char *host = request->host;
  479. if (!Config.onoff.source_ping) {
  480.     debug(15, 6) ("neighborsUdpPing: Source Ping is disabled.n");
  481. } else if ((ia = ipcache_gethostbyname(host, 0))) {
  482.     debug(15, 6) ("neighborsUdpPing: Source Ping: to %s for '%s'n",
  483. host, url);
  484.     echo_hdr.reqnum = reqnum;
  485.     if (icmp_sock != -1) {
  486. icmpSourcePing(ia->in_addrs[ia->cur], &echo_hdr, url);
  487.     } else {
  488. to_addr.sin_family = AF_INET;
  489. to_addr.sin_addr = ia->in_addrs[ia->cur];
  490. to_addr.sin_port = htons(echo_port);
  491. query = icpCreateMessage(ICP_SECHO, 0, url, reqnum, 0);
  492. icpUdpSend(theOutIcpConnection,
  493.     &to_addr,
  494.     query,
  495.     LOG_ICP_QUERY,
  496.     0);
  497.     }
  498. } else {
  499.     debug(15, 6) ("neighborsUdpPing: Source Ping: unknown host: %sn",
  500. host);
  501. }
  502.     }
  503. #endif
  504.     /*
  505.      * If there is a configured timeout, use it
  506.      */
  507.     if (Config.Timeout.icp_query)
  508. *timeout = Config.Timeout.icp_query;
  509.     else if (*exprep > 0)
  510. (*timeout) = 2 * (*timeout) / (*exprep);
  511.     else
  512. *timeout = 2000; /* 2 seconds */
  513.     return peers_pinged;
  514. }
  516. /* lookup the digest of a given peer */
  517. lookup_t
  518. peerDigestLookup(peer * p, request_t * request, StoreEntry * entry)
  519. {
  520. #if USE_CACHE_DIGESTS
  521.     const cache_key *key = request ? storeKeyPublic(storeUrl(entry), request->method) : NULL;
  522.     assert(p);
  523.     assert(request);
  524.     debug(15, 5) ("peerDigestLookup: peer %sn", p->host);
  525.     /* does the peeer have a valid digest? */
  526.     if (!p->digest) {
  527. debug(15, 5) ("peerDigestLookup: gone!n");
  528. return LOOKUP_NONE;
  529.     } else if (!peerHTTPOkay(p, request)) {
  530. debug(15, 5) ("peerDigestLookup: !peerHTTPOkayn");
  531. return LOOKUP_NONE;
  532.     } else if (p->digest->flags.usable) {
  533. debug(15, 5) ("peerDigestLookup: usablen");
  534. /* fall through; put here to have common case on top */ ;
  535.     } else if (!p->digest->flags.needed) {
  536. debug(15, 5) ("peerDigestLookup: note needn");
  537. peerDigestNeeded(p->digest);
  538. return LOOKUP_NONE;
  539.     } else {
  540. debug(15, 5) ("peerDigestLookup: !ready && %srequestedn",
  541.     p->digest->flags.requested ? "" : "!");
  542. return LOOKUP_NONE;
  543.     }
  544.     debug(15, 5) ("peerDigestLookup: OK to lookup peer %sn", p->host);
  545.     assert(p->digest->cd);
  546.     /* does digest predict a hit? */
  547.     if (!cacheDigestTest(p->digest->cd, key))
  548. return LOOKUP_MISS;
  549.     debug(15, 5) ("peerDigestLookup: peer %s says HIT!n", p->host);
  550.     return LOOKUP_HIT;
  551. #endif
  552.     return LOOKUP_NONE;
  553. }
  555. /* select best peer based on cache digests */
  556. peer *
  557. neighborsDigestSelect(request_t * request, StoreEntry * entry)
  558. {
  559.     peer *best_p = NULL;
  560. #if USE_CACHE_DIGESTS
  561.     const cache_key *key;
  562.     int best_rtt = 0;
  563.     int choice_count = 0;
  564.     int ichoice_count = 0;
  565.     peer *p;
  566.     int p_rtt;
  567.     int i;
  569.     key = storeKeyPublic(storeUrl(entry), request->method);
  570.     for (i = 0, p = first_ping; i++ < Config.npeers; p = p->next) {
  571. lookup_t lookup;
  572. if (!p)
  573.     p = Config.peers;
  574. if (i == 1)
  575.     first_ping = p;
  576. lookup = peerDigestLookup(p, request, entry);
  577. if (lookup == LOOKUP_NONE)
  578.     continue;
  579. choice_count++;
  580. if (lookup == LOOKUP_MISS)
  581.     continue;
  582. p_rtt = netdbHostRtt(p->host);
  583. debug(15, 5) ("neighborsDigestSelect: peer %s rtt: %dn",
  584.     p->host, p_rtt);
  585. /* is this peer better than others in terms of rtt ? */
  586. if (!best_p || (p_rtt && p_rtt < best_rtt)) {
  587.     best_p = p;
  588.     best_rtt = p_rtt;
  589.     if (p_rtt) /* informative choice (aka educated guess) */
  590. ichoice_count++;
  591.     debug(15, 4) ("neighborsDigestSelect: peer %s leads with rtt %dn",
  592. p->host, best_rtt);
  593. }
  594.     }
  595.     debug(15, 4) ("neighborsDigestSelect: choices: %d (%d)n",
  596. choice_count, ichoice_count);
  597.     peerNoteDigestLookup(request, best_p,
  598. best_p ? LOOKUP_HIT : (choice_count ? LOOKUP_MISS : LOOKUP_NONE));
  599.     request->hier.n_choices = choice_count;
  600.     request->hier.n_ichoices = ichoice_count;
  601. #endif
  602.     return best_p;
  603. }
  605. void
  606. peerNoteDigestLookup(request_t * request, peer * p, lookup_t lookup)
  607. {
  608. #if USE_CACHE_DIGESTS
  609.     if (p)
  610. strncpy(request->hier.cd_host, p->host, sizeof(request->hier.cd_host));
  611.     else
  612. *request->hier.cd_host = '';
  613.     request->hier.cd_lookup = lookup;
  614.     debug(15, 4) ("peerNoteDigestLookup: peer %s, lookup: %sn",
  615. p ? p->host : "<none>", lookup_t_str[lookup]);
  616. #endif
  617. }
  619. static void
  620. neighborAlive(peer * p, const MemObject * mem, const icp_common_t * header)
  621. {
  622.     if (p->stats.logged_state == PEER_DEAD && p->tcp_up) {
  623. debug(15, 1) ("Detected REVIVED %s: %s/%d/%dn",
  624.     neighborTypeStr(p),
  625.     p->host, p->http_port, p->icp.port);
  626. p->stats.logged_state = PEER_ALIVE;
  627.     }
  628.     p->stats.last_reply = squid_curtime;
  629.     p->stats.pings_acked++;
  630.     if ((icp_opcode) header->opcode <= ICP_END)
  631. p->icp.counts[header->opcode]++;
  632.     p->icp.version = (int) header->version;
  633. }
  635. static void
  636. neighborUpdateRtt(peer * p, MemObject * mem)
  637. {
  638.     int rtt;
  639.     if (!mem)
  640. return;
  641.     if (!mem->start_ping.tv_sec)
  642. return;
  643.     rtt = tvSubMsec(mem->start_ping, current_time);
  644.     if (rtt < 1 || rtt > 10000)
  645. return;
  646.     p->stats.rtt = intAverage(p->stats.rtt, rtt,
  647. p->stats.pings_acked, RTT_AV_FACTOR);
  648. }
  650. #if USE_HTCP
  651. static void
  652. neighborAliveHtcp(peer * p, const MemObject * mem, const htcpReplyData * htcp)
  653. {
  654.     if (p->stats.logged_state == PEER_DEAD && p->tcp_up) {
  655. debug(15, 1) ("Detected REVIVED %s: %s/%d/%dn",
  656.     neighborTypeStr(p),
  657.     p->host, p->http_port, p->icp.port);
  658. p->stats.logged_state = PEER_ALIVE;
  659.     }
  660.     p->stats.last_reply = squid_curtime;
  661.     p->stats.pings_acked++;
  662.     p->htcp.counts[htcp->hit ? 1 : 0]++;
  663.     p->htcp.version = htcp->version;
  664. }
  665. #endif
  667. static void
  668. neighborCountIgnored(peer * p)
  669. {
  670.     if (p == NULL)
  671. return;
  672.     p->stats.ignored_replies++;
  673.     NLateReplies++;
  674. }
  676. static peer *non_peers = NULL;
  678. static void
  679. neighborIgnoreNonPeer(const struct sockaddr_in *from, icp_opcode opcode)
  680. {
  681.     peer *np;
  682.     double x;
  683.     for (np = non_peers; np; np = np->next) {
  684. if (np->in_addr.sin_addr.s_addr != from->sin_addr.s_addr)
  685.     continue;
  686. if (np->in_addr.sin_port != from->sin_port)
  687.     continue;
  688. break;
  689.     }
  690.     if (np == NULL) {
  691. np = xcalloc(1, sizeof(peer));
  692. np->in_addr.sin_addr = from->sin_addr;
  693. np->in_addr.sin_port = from->sin_port;
  694. np->icp.port = ntohl(from->sin_port);
  695. np->type = PEER_NONE;
  696. np->host = xstrdup(inet_ntoa(from->sin_addr));
  697. np->next = non_peers;
  698. non_peers = np;
  699.     }
  700.     np->stats.ignored_replies++;
  701.     np->icp.counts[opcode]++;
  702.     x = log(np->stats.ignored_replies) / log(10.0);
  703.     if (0.0 != x - (double) (int) x)
  704. return;
  705.     debug(15, 1) ("WARNING: Ignored %d replies from non-peer %sn",
  706. np->stats.ignored_replies, np->host);
  707. }
  709. /* ignoreMulticastReply
  710.  * 
  711.  * We want to ignore replies from multicast peers if the
  712.  * cache_host_domain rules would normally prevent the peer
  713.  * from being used
  714.  */
  715. static int
  716. ignoreMulticastReply(peer * p, MemObject * mem)
  717. {
  718.     if (p == NULL)
  719. return 0;
  720.     if (!p->options.mcast_responder)
  721. return 0;
  722.     if (peerHTTPOkay(p, mem->request))
  723. return 0;
  724.     return 1;
  725. }
  727. /* I should attach these records to the entry.  We take the first
  728.  * hit we get our wait until everyone misses.  The timeout handler
  729.  * call needs to nip this shopping list or call one of the misses.
  730.  * 
  731.  * If a hit process is already started, then sobeit
  732.  */
  733. void
  734. neighborsUdpAck(const cache_key * key, icp_common_t * header, const struct sockaddr_in *from)
  735. {
  736.     peer *p = NULL;
  737.     StoreEntry *entry;
  738.     MemObject *mem = NULL;
  739.     peer_t ntype = PEER_NONE;
  740.     char *opcode_d;
  741.     icp_opcode opcode = (icp_opcode) header->opcode;
  743.     debug(15, 6) ("neighborsUdpAck: opcode %d '%s'n",
  744. (int) opcode, storeKeyText(key));
  745.     if (NULL != (entry = storeGet(key)))
  746. mem = entry->mem_obj;
  747.     if ((p = whichPeer(from)))
  748. neighborAlive(p, mem, header);
  749.     if (opcode > ICP_END)
  750. return;
  751.     opcode_d = icp_opcode_str[opcode];
  752.     if (p)
  753. neighborUpdateRtt(p, mem);
  754.     /* Does the entry exist? */
  755.     if (NULL == entry) {
  756. debug(12, 3) ("neighborsUdpAck: Cache key '%s' not foundn",
  757.     storeKeyText(key));
  758. neighborCountIgnored(p);
  759. return;
  760.     }
  761.     /* check if someone is already fetching it */
  762.     if (EBIT_TEST(entry->flags, ENTRY_DISPATCHED)) {
  763. debug(15, 3) ("neighborsUdpAck: '%s' already being fetched.n",
  764.     storeKeyText(key));
  765. neighborCountIgnored(p);
  766. return;
  767.     }
  768.     if (mem == NULL) {
  769. debug(15, 2) ("Ignoring %s for missing mem_obj: %sn",
  770.     opcode_d, storeKeyText(key));
  771. neighborCountIgnored(p);
  772. return;
  773.     }
  774.     if (entry->ping_status != PING_WAITING) {
  775. debug(15, 2) ("neighborsUdpAck: Late %s for %sn",
  776.     opcode_d, storeKeyText(key));
  777. neighborCountIgnored(p);
  778. return;
  779.     }
  780.     if (entry->lock_count == 0) {
  781. debug(12, 1) ("neighborsUdpAck: '%s' has no locksn",
  782.     storeKeyText(key));
  783. neighborCountIgnored(p);
  784. return;
  785.     }
  786.     debug(15, 3) ("neighborsUdpAck: %s for '%s' from %s n",
  787. opcode_d, storeKeyText(key), p ? p->host : "source");
  788.     if (p) {
  789. ntype = neighborType(p, mem->request);
  790.     }
  791.     if (ignoreMulticastReply(p, mem)) {
  792. neighborCountIgnored(p);
  793.     } else if (opcode == ICP_MISS) {
  794. if (p == NULL) {
  795.     neighborIgnoreNonPeer(from, opcode);
  796. } else {
  797.     mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
  798. }
  799.     } else if (opcode == ICP_HIT) {
  800. if (p == NULL) {
  801.     neighborIgnoreNonPeer(from, opcode);
  802. } else {
  803.     header->opcode = ICP_HIT;
  804.     mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
  805. }
  806.     } else if (opcode == ICP_DECHO) {
  807. if (p == NULL) {
  808.     neighborIgnoreNonPeer(from, opcode);
  809. } else if (ntype == PEER_SIBLING) {
  810.     debug_trap("neighborsUdpAck: Found non-ICP cache as SIBLINGn");
  811.     debug_trap("neighborsUdpAck: non-ICP neighbors must be a PARENTn");
  812. } else {
  813.     mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
  814. }
  815.     } else if (opcode == ICP_SECHO) {
  816. if (p) {
  817.     debug(15, 1) ("Ignoring SECHO from neighbor %sn", p->host);
  818.     neighborCountIgnored(p);
  819. #if ALLOW_SOURCE_PING
  820. } else if (Config.onoff.source_ping) {
  821.     mem->ping_reply_callback(NULL, ntype, PROTO_ICP, header, mem->ircb_data);
  822. #endif
  823. } else {
  824.     debug(15, 1) ("Unsolicited SECHO from %sn", inet_ntoa(from->sin_addr));
  825. }
  826.     } else if (opcode == ICP_DENIED) {
  827. if (p == NULL) {
  828.     neighborIgnoreNonPeer(from, opcode);
  829. } else if (p->stats.pings_acked > 100) {
  830.     if (100 * p->icp.counts[ICP_DENIED] / p->stats.pings_acked > 95) {
  831. debug(15, 0) ("95%% of replies from '%s' are UDP_DENIEDn", p->host);
  832. debug(15, 0) ("Disabling '%s', please check your configuration.n", p->host);
  833. neighborRemove(p);
  834. p = NULL;
  835.     } else {
  836. neighborCountIgnored(p);
  837.     }
  838. }
  839.     } else if (opcode == ICP_MISS_NOFETCH) {
  840. mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
  841.     } else {
  842. debug(15, 0) ("neighborsUdpAck: Unexpected ICP reply: %sn", opcode_d);
  843.     }
  844. }
  846. peer *
  847. peerFindByName(const char *name)
  848. {
  849.     peer *p = NULL;
  850.     for (p = Config.peers; p; p = p->next) {
  851. if (!strcasecmp(name, p->host))
  852.     break;
  853.     }
  854.     return p;
  855. }
  857. peer *
  858. peerFindByNameAndPort(const char *name, unsigned short port)
  859. {
  860.     peer *p = NULL;
  861.     for (p = Config.peers; p; p = p->next) {
  862. if (strcasecmp(name, p->host))
  863.     continue;
  864. if (port != p->http_port)
  865.     continue;
  866. break;
  867.     }
  868.     return p;
  869. }
  871. int
  872. neighborUp(const peer * p)
  873. {
  874.     if (!p->tcp_up)
  875. return 0;
  876.     if (squid_curtime - p->stats.last_query > Config.Timeout.deadPeer)
  877. return 1;
  878.     if (p->stats.last_query - p->stats.last_reply > Config.Timeout.deadPeer)
  879. return 0;
  880.     return 1;
  881. }
  883. void
  884. peerDestroy(void *data, int unused)
  885. {
  886.     peer *p = data;
  887.     struct _domain_ping *l = NULL;
  888.     struct _domain_ping *nl = NULL;
  889.     if (p == NULL)
  890. return;
  891.     for (l = p->peer_domain; l; l = nl) {
  892. nl = l->next;
  893. safe_free(l->domain);
  894. safe_free(l);
  895.     }
  896.     safe_free(p->host);
  897. #if USE_CACHE_DIGESTS
  898.     /* it should be set NULL in free_peer() */
  899.     assert(p->digest == NULL);
  900. #endif
  901.     xfree(p);
  902. }
  904. void
  905. peerNoteDigestGone(peer * p)
  906. {
  907. #if USE_CACHE_DIGESTS
  908.     if (p->digest) {
  909. PeerDigest *pd = p->digest;
  910. p->digest = NULL;
  911. cbdataUnlock(pd);
  912.     }
  913. #endif
  914. }
  916. static void
  917. peerDNSConfigure(const ipcache_addrs * ia, void *data)
  918. {
  919.     peer *p = data;
  920.     struct sockaddr_in *ap;
  921.     int j;
  922.     if (p->n_addresses == 0) {
  923. debug(15, 1) ("Configuring %s %s/%d/%dn", neighborTypeStr(p),
  924.     p->host, p->http_port, p->icp.port);
  925. if (p->type == PEER_MULTICAST)
  926.     debug(15, 1) ("    Multicast TTL = %dn", p->mcast.ttl);
  927.     }
  928.     p->n_addresses = 0;
  929.     if (ia == NULL) {
  930. debug(0, 0) ("WARNING: DNS lookup for '%s' failed!n", p->host);
  931. return;
  932.     }
  933.     if ((int) ia->count < 1) {
  934. debug(0, 0) ("WARNING: No IP address found for '%s'!n", p->host);
  935. return;
  936.     }
  937.     for (j = 0; j < (int) ia->count && j < PEER_MAX_ADDRESSES; j++) {
  938. p->addresses[j] = ia->in_addrs[j];
  939. debug(15, 2) ("--> IP address #%d: %sn", j, inet_ntoa(p->addresses[j]));
  940. p->n_addresses++;
  941.     }
  942.     ap = &p->in_addr;
  943.     memset(ap, '', sizeof(struct sockaddr_in));
  944.     ap->sin_family = AF_INET;
  945.     ap->sin_addr = p->addresses[0];
  946.     ap->sin_port = htons(p->icp.port);
  947.     if (p->type == PEER_MULTICAST)
  948. peerCountMcastPeersSchedule(p, 10);
  949.     if (p->type != PEER_MULTICAST)
  950. if (!p->options.no_netdb_exchange)
  951.     eventAddIsh("netdbExchangeStart", netdbExchangeStart, p, 30.0, 1);
  952. }
  954. static void
  955. peerRefreshDNS(void *data)
  956. {
  957.     peer *p = NULL;
  958.     if (eventFind(peerRefreshDNS, NULL))
  959. eventDelete(peerRefreshDNS, NULL);
  960.     if (!data && 0 == stat5minClientRequests()) {
  961. /* no recent client traffic, wait a bit */
  962. eventAddIsh("peerRefreshDNS", peerRefreshDNS, NULL, 180.0, 1);
  963. return;
  964.     }
  965.     for (p = Config.peers; p; p = p->next)
  966. ipcache_nbgethostbyname(p->host, peerDNSConfigure, p);
  967.     /* Reconfigure the peers every hour */
  968.     eventAddIsh("peerRefreshDNS", peerRefreshDNS, NULL, 3600.0, 1);
  969. }
  971. /*
  972.  * peerCheckConnect will NOT be called by eventRun if the peer/data
  973.  * pointer becomes invalid.
  974.  */
  975. static void
  976. peerCheckConnect(void *data)
  977. {
  978.     peer *p = data;
  979.     int fd;
  980.     fd = comm_open(SOCK_STREAM, 0, Config.Addrs.tcp_outgoing,
  981. 0, COMM_NONBLOCKING, p->host);
  982.     if (fd < 0)
  983. return;
  984.     p->test_fd = fd;
  985.     ipcache_nbgethostbyname(p->host, peerCheckConnect2, p);
  986. }
  988. static void
  989. peerCheckConnect2(const ipcache_addrs * ianotused, void *data)
  990. {
  991.     peer *p = data;
  992.     commConnectStart(p->test_fd,
  993. p->host,
  994. p->http_port,
  995. peerCheckConnectDone,
  996. p);
  997. }
  999. static void
  1000. peerCheckConnectDone(int fd, int status, void *data)
  1001. {
  1002.     peer *p = data;
  1003.     if (status == COMM_OK) {
  1004. p->tcp_up = PEER_TCP_MAGIC_COUNT;
  1005. debug(15, 1) ("TCP connection to %s/%d succeededn",
  1006.     p->host, p->http_port);
  1007.     } else {
  1008. eventAdd("peerCheckConnect", peerCheckConnect, p, 60.0, 1);
  1009.     }
  1010.     comm_close(fd);
  1011.     return;
  1012. }
  1014. void
  1015. peerCheckConnectStart(peer * p)
  1016. {
  1017.     if (!p->tcp_up)
  1018. return;
  1019.     debug(15, 1) ("TCP connection to %s/%d failedn", p->host, p->http_port);
  1020.     p->tcp_up--;
  1021.     if (p->tcp_up != (PEER_TCP_MAGIC_COUNT - 1))
  1022. return;
  1023.     p->last_fail_time = squid_curtime;
  1024.     eventAdd("peerCheckConnect", peerCheckConnect, p, 30.0, 1);
  1025. }
  1027. static void
  1028. peerCountMcastPeersSchedule(peer * p, time_t when)
  1029. {
  1030.     if (p->mcast.flags.count_event_pending)
  1031. return;
  1032.     eventAdd("peerCountMcastPeersStart",
  1033. peerCountMcastPeersStart,
  1034. p,
  1035. (double) when, 1);
  1036.     p->mcast.flags.count_event_pending = 1;
  1037. }
  1039. static void
  1040. peerCountMcastPeersStart(void *data)
  1041. {
  1042.     peer *p = data;
  1043.     ps_state *psstate = xcalloc(1, sizeof(ps_state));
  1044.     StoreEntry *fake;
  1045.     MemObject *mem;
  1046.     icp_common_t *query;
  1047.     int reqnum;
  1048.     LOCAL_ARRAY(char, url, MAX_URL);
  1049.     assert(p->type == PEER_MULTICAST);
  1050.     p->mcast.flags.count_event_pending = 0;
  1051.     snprintf(url, MAX_URL, "http://%s/", inet_ntoa(p->in_addr.sin_addr));
  1052.     fake = storeCreateEntry(url, url, null_request_flags, METHOD_GET);
  1053.     psstate->request = requestLink(urlParse(METHOD_GET, url));
  1054.     psstate->entry = fake;
  1055.     psstate->callback = NULL;
  1056.     psstate->callback_data = p;
  1057.     psstate->ping.start = current_time;
  1058.     cbdataAdd(psstate, cbdataXfree, 0);
  1059.     mem = fake->mem_obj;
  1060.     mem->request = requestLink(psstate->request);
  1061.     mem->start_ping = current_time;
  1062.     mem->ping_reply_callback = peerCountHandleIcpReply;
  1063.     mem->ircb_data = psstate;
  1064.     mcastSetTtl(theOutIcpConnection, p->mcast.ttl);
  1065.     p->mcast.id = mem->id;
  1066.     reqnum = icpSetCacheKey(fake->key);
  1067.     query = icpCreateMessage(ICP_QUERY, 0, url, reqnum, 0);
  1068.     icpUdpSend(theOutIcpConnection,
  1069. &p->in_addr,
  1070. query,
  1071. LOG_ICP_QUERY,
  1072. 0);
  1073.     fake->ping_status = PING_WAITING;
  1074.     eventAdd("peerCountMcastPeersDone",
  1075. peerCountMcastPeersDone,
  1076. psstate,
  1077. (double) Config.Timeout.mcast_icp_query, 1);
  1078.     p->mcast.flags.counting = 1;
  1079.     peerCountMcastPeersSchedule(p, MCAST_COUNT_RATE);
  1080. }
  1082. static void
  1083. peerCountMcastPeersDone(void *data)
  1084. {
  1085.     ps_state *psstate = data;
  1086.     peer *p = psstate->callback_data;
  1087.     StoreEntry *fake = psstate->entry;
  1088.     p->mcast.flags.counting = 0;
  1089.     p->mcast.avg_n_members = doubleAverage(p->mcast.avg_n_members,
  1090. (double) psstate->ping.n_recv,
  1091. ++p->mcast.n_times_counted,
  1092. 10);
  1093.     debug(15, 1) ("Group %s: %d replies, %4.1f average, RTT %dn",
  1094. p->host,
  1095. psstate->ping.n_recv,
  1096. p->mcast.avg_n_members,
  1097. p->stats.rtt);
  1098.     p->mcast.n_replies_expected = (int) p->mcast.avg_n_members;
  1099.     EBIT_SET(fake->flags, ENTRY_ABORTED);
  1100.     requestUnlink(fake->mem_obj->request);
  1101.     fake->mem_obj->request = NULL;
  1102.     storeReleaseRequest(fake);
  1103.     storeUnlockObject(fake);
  1104.     requestUnlink(psstate->request);
  1105.     cbdataFree(psstate);
  1106. }
  1108. static void
  1109. peerCountHandleIcpReply(peer * p, peer_t type, protocol_t proto, void *hdrnotused, void *data)
  1110. {
  1111.     ps_state *psstate = data;
  1112.     StoreEntry *fake = psstate->entry;
  1113.     MemObject *mem = fake->mem_obj;
  1114.     int rtt = tvSubMsec(mem->start_ping, current_time);
  1115.     assert(proto == PROTO_ICP);
  1116.     assert(fake);
  1117.     assert(mem);
  1118.     psstate->ping.n_recv++;
  1119.     p->stats.rtt = intAverage(p->stats.rtt, rtt, psstate->ping.n_recv, RTT_AV_FACTOR);
  1120. }
  1122. static void
  1123. neighborDumpPeers(StoreEntry * sentry)
  1124. {
  1125.     dump_peers(sentry, Config.peers);
  1126. }
  1128. static void
  1129. neighborDumpNonPeers(StoreEntry * sentry)
  1130. {
  1131.     dump_peers(sentry, non_peers);
  1132. }
  1134. void
  1135. dump_peer_options(StoreEntry * sentry, peer * p)
  1136. {
  1137.     if (p->options.proxy_only)
  1138. storeAppendPrintf(sentry, " proxy-only");
  1139.     if (p->options.no_query)
  1140. storeAppendPrintf(sentry, " no-query");
  1141.     if (p->options.no_digest)
  1142. storeAppendPrintf(sentry, " no-digest");
  1143.     if (p->options.default_parent)
  1144. storeAppendPrintf(sentry, " default");
  1145.     if (p->options.roundrobin)
  1146. storeAppendPrintf(sentry, " round-robin");
  1147.     if (p->options.mcast_responder)
  1148. storeAppendPrintf(sentry, " multicast-responder");
  1149.     if (p->options.closest_only)
  1150. storeAppendPrintf(sentry, " closest-only");
  1151. #if USE_HTCP
  1152.     if (p->options.htcp)
  1153. storeAppendPrintf(sentry, " htcp");
  1154. #endif
  1155.     if (p->options.no_netdb_exchange)
  1156. storeAppendPrintf(sentry, " no-netdb-exchange");
  1157. #if DELAY_POOLS
  1158.     if (p->options.no_delay)
  1159. storeAppendPrintf(sentry, " no-delay");
  1160. #endif
  1161.     if (p->login)
  1162. storeAppendPrintf(sentry, " login=%s", p->login);
  1163.     if (p->mcast.ttl > 0)
  1164. storeAppendPrintf(sentry, " ttl=%d", p->mcast.ttl);
  1165.     storeAppendPrintf(sentry, "n");
  1166. }
  1168. static void
  1169. dump_peers(StoreEntry * sentry, peer * peers)
  1170. {
  1171.     peer *e = NULL;
  1172.     struct _domain_ping *d = NULL;
  1173.     icp_opcode op;
  1174.     int i;
  1175.     if (peers == NULL)
  1176. storeAppendPrintf(sentry, "There are no neighbors installed.n");
  1177.     for (e = peers; e; e = e->next) {
  1178. assert(e->host != NULL);
  1179. storeAppendPrintf(sentry, "n%-11.11s: %s/%d/%dn",
  1180.     neighborTypeStr(e),
  1181.     e->host,
  1182.     e->http_port,
  1183.     e->icp.port);
  1184. storeAppendPrintf(sentry, "Flags      :");
  1185. dump_peer_options(sentry, e);
  1186. for (i = 0; i < e->n_addresses; i++) {
  1187.     storeAppendPrintf(sentry, "Address[%d] : %sn", i,
  1188. inet_ntoa(e->addresses[i]));
  1189. }
  1190. storeAppendPrintf(sentry, "Status     : %sn",
  1191.     neighborUp(e) ? "Up" : "Down");
  1192. storeAppendPrintf(sentry, "AVG RTT    : %d msecn", e->stats.rtt);
  1193. storeAppendPrintf(sentry, "LAST QUERY : %8d seconds agon",
  1194.     (int) (squid_curtime - e->stats.last_query));
  1195. storeAppendPrintf(sentry, "LAST REPLY : %8d seconds agon",
  1196.     (int) (squid_curtime - e->stats.last_reply));
  1197. storeAppendPrintf(sentry, "PINGS SENT : %8dn", e->stats.pings_sent);
  1198. storeAppendPrintf(sentry, "PINGS ACKED: %8d %3d%%n",
  1199.     e->stats.pings_acked,
  1200.     percent(e->stats.pings_acked, e->stats.pings_sent));
  1201. storeAppendPrintf(sentry, "FETCHES    : %8d %3d%%n",
  1202.     e->stats.fetches,
  1203.     percent(e->stats.fetches, e->stats.pings_acked));
  1204. storeAppendPrintf(sentry, "IGNORED    : %8d %3d%%n",
  1205.     e->stats.ignored_replies,
  1206.     percent(e->stats.ignored_replies, e->stats.pings_acked));
  1207. storeAppendPrintf(sentry, "Histogram of PINGS ACKED:n");
  1208. #if USE_HTCP
  1209. if (e->options.htcp) {
  1210.     storeAppendPrintf(sentry, "tMissest%8d %3d%%n",
  1211. e->htcp.counts[0],
  1212. percent(e->htcp.counts[0], e->stats.pings_acked));
  1213.     storeAppendPrintf(sentry, "tHitst%8d %3d%%n",
  1214. e->htcp.counts[1],
  1215. percent(e->htcp.counts[1], e->stats.pings_acked));
  1216. } else {
  1217. #endif
  1218.     for (op = ICP_INVALID; op < ICP_END; op++) {
  1219. if (e->icp.counts[op] == 0)
  1220.     continue;
  1221. storeAppendPrintf(sentry, "    %12.12s : %8d %3d%%n",
  1222.     icp_opcode_str[op],
  1223.     e->icp.counts[op],
  1224.     percent(e->icp.counts[op], e->stats.pings_acked));
  1225.     }
  1226. #if USE_HTCP
  1227. }
  1228. #endif
  1229. if (e->last_fail_time) {
  1230.     storeAppendPrintf(sentry, "Last failed connect() at: %sn",
  1231. mkhttpdlogtime(&(e->last_fail_time)));
  1232. }
  1233. if (e->peer_domain != NULL) {
  1234.     storeAppendPrintf(sentry, "DOMAIN LIST: ");
  1235.     for (d = e->peer_domain; d; d = d->next) {
  1236. storeAppendPrintf(sentry, "%s%s ",
  1237.     d->do_ping ? null_string : "!", d->domain);
  1238.     }
  1239.     storeAppendPrintf(sentry, "n");
  1240. }
  1241. storeAppendPrintf(sentry, "keep-alive ratio: %d%%n",
  1242.     percent(e->stats.n_keepalives_recv, e->stats.n_keepalives_sent));
  1243.     }
  1244. }
  1246. #if USE_HTCP
  1247. void
  1248. neighborsHtcpReply(const cache_key * key, htcpReplyData * htcp, const struct sockaddr_in *from)
  1249. {
  1250.     StoreEntry *e = storeGet(key);
  1251.     MemObject *mem = NULL;
  1252.     peer *p;
  1253.     peer_t ntype = PEER_NONE;
  1254.     debug(15, 6) ("neighborsHtcpReply: %s %sn",
  1255. htcp->hit ? "HIT" : "MISS", storeKeyText(key));
  1256.     if (NULL != (e = storeGet(key)))
  1257. mem = e->mem_obj;
  1258.     if ((p = whichPeer(from)))
  1259. neighborAliveHtcp(p, mem, htcp);
  1260.     /* Does the entry exist? */
  1261.     if (NULL == e) {
  1262. debug(12, 3) ("neighyborsHtcpReply: Cache key '%s' not foundn",
  1263.     storeKeyText(key));
  1264. neighborCountIgnored(p);
  1265. return;
  1266.     }
  1267.     /* check if someone is already fetching it */
  1268.     if (EBIT_TEST(e->flags, ENTRY_DISPATCHED)) {
  1269. debug(15, 3) ("neighborsUdpAck: '%s' already being fetched.n",
  1270.     storeKeyText(key));
  1271. neighborCountIgnored(p);
  1272. return;
  1273.     }
  1274.     if (mem == NULL) {
  1275. debug(15, 2) ("Ignoring reply for missing mem_obj: %sn",
  1276.     storeKeyText(key));
  1277. neighborCountIgnored(p);
  1278. return;
  1279.     }
  1280.     if (e->ping_status != PING_WAITING) {
  1281. debug(15, 2) ("neighborsUdpAck: Entry %s is not PING_WAITINGn",
  1282.     storeKeyText(key));
  1283. neighborCountIgnored(p);
  1284. return;
  1285.     }
  1286.     if (e->lock_count == 0) {
  1287. debug(12, 1) ("neighborsUdpAck: '%s' has no locksn",
  1288.     storeKeyText(key));
  1289. neighborCountIgnored(p);
  1290. return;
  1291.     }
  1292.     if (p) {
  1293. ntype = neighborType(p, mem->request);
  1294. neighborUpdateRtt(p, mem);
  1295.     }
  1296.     if (ignoreMulticastReply(p, mem)) {
  1297. neighborCountIgnored(p);
  1298. return;
  1299.     }
  1300.     debug(15, 1) ("neighborsHtcpReply: e = %pn", e);
  1301.     mem->ping_reply_callback(p, ntype, PROTO_HTCP, htcp, mem->ircb_data);
  1302. }
  1303. #endif