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

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

代理服务器

开发平台：

Unix_Linux

net_db.c：源码内容
  2. /*
  3.  * $Id: net_db.c,v 1.136 1999/01/29 21:28:16 wessels Exp $
  4.  *
  5.  * DEBUG: section 38    Network Measurement Database
  6.  * AUTHOR: Duane Wessels
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #include "squid.h"
  38. #if USE_ICMP
  40. typedef struct {
  41.     peer *p;
  42.     StoreEntry *e;
  43.     request_t *r;
  44.     off_t seen;
  45.     off_t used;
  46.     size_t buf_sz;
  47.     char *buf;
  48. } netdbExchangeState;
  50. static hash_table *addr_table = NULL;
  51. static hash_table *host_table = NULL;
  53. static struct in_addr networkFromInaddr(struct in_addr a);
  54. static void netdbRelease(netdbEntry * n);
  55. static void netdbHashInsert(netdbEntry * n, struct in_addr addr);
  56. static void netdbHashDelete(const char *key);
  57. static void netdbHostInsert(netdbEntry * n, const char *hostname);
  58. static void netdbHostDelete(const net_db_name * x);
  59. static void netdbPurgeLRU(void);
  60. static netdbEntry *netdbLookupHost(const char *key);
  61. static net_db_peer *netdbPeerByName(const netdbEntry * n, const char *);
  62. static net_db_peer *netdbPeerAdd(netdbEntry * n, peer * e);
  63. static char *netdbPeerName(const char *name);
  64. static IPH netdbSendPing;
  65. static QS sortPeerByRtt;
  66. static QS sortByRtt;
  67. static QS netdbLRU;
  68. static FREE netdbFreeNameEntry;
  69. static FREE netdbFreeNetdbEntry;
  70. static STCB netdbExchangeHandleReply;
  71. static void netdbExchangeDone(void *);
  73. /* We have to keep a local list of peer names.  The Peers structure
  74.  * gets freed during a reconfigure.  We want this database to
  75.  * remain persisitent, so _net_db_peer->peername points into this
  76.  * linked list */
  77. static wordlist *peer_names = NULL;
  79. static void
  80. netdbHashInsert(netdbEntry * n, struct in_addr addr)
  81. {
  82.     xstrncpy(n->network, inet_ntoa(networkFromInaddr(addr)), 16);
  83.     n->key = n->network;
  84.     assert(hash_lookup(addr_table, n->network) == NULL);
  85.     hash_join(addr_table, (hash_link *) n);
  86. }
  88. static void
  89. netdbHashDelete(const char *key)
  90. {
  91.     hash_link *hptr = hash_lookup(addr_table, key);
  92.     if (hptr == NULL) {
  93. debug_trap("netdbHashDelete: key not found");
  94. return;
  95.     }
  96.     hash_remove_link(addr_table, hptr);
  97. }
  99. static void
  100. netdbHostInsert(netdbEntry * n, const char *hostname)
  101. {
  102.     net_db_name *x = memAllocate(MEM_NET_DB_NAME);
  103.     x->name = xstrdup(hostname);
  104.     x->next = n->hosts;
  105.     n->hosts = x;
  106.     x->net_db_entry = n;
  107.     assert(hash_lookup(host_table, hostname) == NULL);
  108.     hash_join(host_table, (hash_link *) x);
  109.     n->link_count++;
  110. }
  112. static void
  113. netdbHostDelete(const net_db_name * x)
  114. {
  115.     netdbEntry *n;
  116.     net_db_name **X;
  117.     assert(x != NULL);
  118.     assert(x->net_db_entry != NULL);
  119.     n = x->net_db_entry;
  120.     n->link_count--;
  121.     for (X = &n->hosts; *X; X = &(*X)->next) {
  122. if (*X == x) {
  123.     *X = x->next;
  124.     break;
  125. }
  126.     }
  127.     hash_remove_link(host_table, (hash_link *) x);
  128.     xfree(x->name);
  129.     memFree((void *) x, MEM_NET_DB_NAME);
  130. }
  132. static netdbEntry *
  133. netdbLookupHost(const char *key)
  134. {
  135.     net_db_name *x = (net_db_name *) hash_lookup(host_table, key);
  136.     return x ? x->net_db_entry : NULL;
  137. }
  139. static void
  140. netdbRelease(netdbEntry * n)
  141. {
  142.     net_db_name *x;
  143.     net_db_name *next;
  144.     for (x = n->hosts; x; x = next) {
  145. next = x->next;
  146. netdbHostDelete(x);
  147.     }
  148.     n->hosts = NULL;
  149.     safe_free(n->peers);
  150.     n->peers = NULL;
  151.     n->n_peers = 0;
  152.     n->n_peers_alloc = 0;
  153.     if (n->link_count == 0) {
  154. netdbHashDelete(n->network);
  155. memFree(n, MEM_NETDBENTRY);
  156.     }
  157. }
  159. static int
  160. netdbLRU(const void *A, const void *B)
  161. {
  162.     const netdbEntry *const *n1 = A;
  163.     const netdbEntry *const *n2 = B;
  164.     if ((*n1)->last_use_time > (*n2)->last_use_time)
  165. return (1);
  166.     if ((*n1)->last_use_time < (*n2)->last_use_time)
  167. return (-1);
  168.     return (0);
  169. }
  171. static void
  172. netdbPurgeLRU(void)
  173. {
  174.     netdbEntry *n;
  175.     netdbEntry **list;
  176.     int k = 0;
  177.     int list_count = 0;
  178.     int removed = 0;
  179.     list = xcalloc(memInUse(MEM_NETDBENTRY), sizeof(netdbEntry *));
  180.     hash_first(addr_table);
  181.     while ((n = (netdbEntry *) hash_next(addr_table))) {
  182. assert(list_count < memInUse(MEM_NETDBENTRY));
  183. *(list + list_count) = n;
  184. list_count++;
  185.     }
  186.     qsort((char *) list,
  187. list_count,
  188. sizeof(netdbEntry *),
  189. netdbLRU);
  190.     for (k = 0; k < list_count; k++) {
  191. if (memInUse(MEM_NETDBENTRY) < Config.Netdb.low)
  192.     break;
  193. netdbRelease(*(list + k));
  194. removed++;
  195.     }
  196.     xfree(list);
  197. }
  199. static netdbEntry *
  200. netdbLookupAddr(struct in_addr addr)
  201. {
  202.     netdbEntry *n;
  203.     char *key = inet_ntoa(networkFromInaddr(addr));
  204.     n = (netdbEntry *) hash_lookup(addr_table, key);
  205.     return n;
  206. }
  208. static netdbEntry *
  209. netdbAdd(struct in_addr addr)
  210. {
  211.     netdbEntry *n;
  212.     if (memInUse(MEM_NETDBENTRY) > Config.Netdb.high)
  213. netdbPurgeLRU();
  214.     if ((n = netdbLookupAddr(addr)) == NULL) {
  215. n = memAllocate(MEM_NETDBENTRY);
  216. netdbHashInsert(n, addr);
  217.     }
  218.     return n;
  219. }
  221. static void
  222. netdbSendPing(const ipcache_addrs * ia, void *data)
  223. {
  224.     struct in_addr addr;
  225.     char *hostname = data;
  226.     netdbEntry *n;
  227.     netdbEntry *na;
  228.     net_db_name *x;
  229.     net_db_name **X;
  230.     cbdataUnlock(hostname);
  231.     if (ia == NULL) {
  232. cbdataFree(hostname);
  233. return;
  234.     }
  235.     addr = ia->in_addrs[ia->cur];
  236.     if ((n = netdbLookupHost(hostname)) == NULL) {
  237. n = netdbAdd(addr);
  238. netdbHostInsert(n, hostname);
  239.     } else if ((na = netdbLookupAddr(addr)) != n) {
  240. /*
  241.  *hostname moved from 'network n' to 'network na'!
  242.  */
  243. if (na == NULL)
  244.     na = netdbAdd(addr);
  245. debug(38, 3) ("netdbSendPing: %s moved from %s to %sn",
  246.     hostname, n->network, na->network);
  247. x = (net_db_name *) hash_lookup(host_table, hostname);
  248. if (x == NULL) {
  249.     debug(38, 1) ("netdbSendPing: net_db_name list bug: %s not found", hostname);
  250.     cbdataFree(hostname);
  251.     return;
  252. }
  253. /* remove net_db_name from 'network n' linked list */
  254. for (X = &n->hosts; *X; X = &(*X)->next) {
  255.     if (*X == x) {
  256. *X = x->next;
  257. break;
  258.     }
  259. }
  260. n->link_count--;
  261. /* point to 'network na' from host entry */
  262. x->net_db_entry = na;
  263. /* link net_db_name to 'network na' */
  264. x->next = na->hosts;
  265. na->hosts = x;
  266. na->link_count++;
  267. n = na;
  268.     }
  269.     if (n->next_ping_time <= squid_curtime) {
  270. debug(38, 3) ("netdbSendPing: pinging %sn", hostname);
  271. icmpDomainPing(addr, hostname);
  272. n->pings_sent++;
  273. n->next_ping_time = squid_curtime + Config.Netdb.period;
  274. n->last_use_time = squid_curtime;
  275.     }
  276.     cbdataFree(hostname);
  277. }
  279. static struct in_addr
  280. networkFromInaddr(struct in_addr a)
  281. {
  282.     struct in_addr b;
  283.     b.s_addr = ntohl(a.s_addr);
  284. #if USE_CLASSFUL
  285.     if (IN_CLASSC(b.s_addr))
  286. b.s_addr &= IN_CLASSC_NET;
  287.     else if (IN_CLASSB(b.s_addr))
  288. b.s_addr &= IN_CLASSB_NET;
  289.     else if (IN_CLASSA(b.s_addr))
  290. b.s_addr &= IN_CLASSA_NET;
  291. #else
  292.     /* use /24 for everything */
  293.     b.s_addr &= IN_CLASSC_NET;
  294. #endif
  295.     b.s_addr = htonl(b.s_addr);
  296.     return b;
  297. }
  299. static int
  300. sortByRtt(const void *A, const void *B)
  301. {
  302.     const netdbEntry *const *n1 = A;
  303.     const netdbEntry *const *n2 = B;
  304.     if ((*n1)->rtt > (*n2)->rtt)
  305. return 1;
  306.     else if ((*n1)->rtt < (*n2)->rtt)
  307. return -1;
  308.     else
  309. return 0;
  310. }
  312. static net_db_peer *
  313. netdbPeerByName(const netdbEntry * n, const char *peername)
  314. {
  315.     int i;
  316.     net_db_peer *p = n->peers;
  317.     for (i = 0; i < n->n_peers; i++, p++) {
  318. if (!strcmp(p->peername, peername))
  319.     return p;
  320.     }
  321.     return NULL;
  322. }
  324. static net_db_peer *
  325. netdbPeerAdd(netdbEntry * n, peer * e)
  326. {
  327.     net_db_peer *p;
  328.     net_db_peer *o;
  329.     int osize;
  330.     int i;
  331.     if (n->n_peers == n->n_peers_alloc) {
  332. o = n->peers;
  333. osize = n->n_peers_alloc;
  334. if (n->n_peers_alloc == 0)
  335.     n->n_peers_alloc = 2;
  336. else
  337.     n->n_peers_alloc <<= 1;
  338. debug(38, 3) ("netdbPeerAdd: Growing peer list for '%s' to %dn",
  339.     n->network, n->n_peers_alloc);
  340. n->peers = xcalloc(n->n_peers_alloc, sizeof(net_db_peer));
  341. for (i = 0; i < osize; i++)
  342.     *(n->peers + i) = *(o + i);
  343. if (osize) {
  344.     safe_free(o);
  345. }
  346.     }
  347.     p = n->peers + n->n_peers;
  348.     p->peername = netdbPeerName(e->host);
  349.     n->n_peers++;
  350.     return p;
  351. }
  353. static int
  354. sortPeerByRtt(const void *A, const void *B)
  355. {
  356.     const net_db_peer *p1 = A;
  357.     const net_db_peer *p2 = B;
  358.     if (p1->rtt > p2->rtt)
  359. return 1;
  360.     else if (p1->rtt < p2->rtt)
  361. return -1;
  362.     else
  363. return 0;
  364. }
  366. static void
  367. netdbSaveState(void *foo)
  368. {
  369.     LOCAL_ARRAY(char, path, SQUID_MAXPATHLEN);
  370.     FILE *fp;
  371.     netdbEntry *n;
  372.     net_db_name *x;
  373.     struct timeval start = current_time;
  374.     int count = 0;
  375.     snprintf(path, SQUID_MAXPATHLEN, "%s/netdb_state", storeSwapDir(0));
  376.     fp = fopen(path, "w");
  377.     if (fp == NULL) {
  378. debug(50, 1) ("netdbSaveState: %s: %sn", path, xstrerror());
  379. return;
  380.     }
  381.     hash_first(addr_table);
  382.     while ((n = (netdbEntry *) hash_next(addr_table))) {
  383. if (n->pings_recv == 0)
  384.     continue;
  385. fprintf(fp, "%s %d %d %10.5f %10.5f %d %d",
  386.     n->network,
  387.     n->pings_sent,
  388.     n->pings_recv,
  389.     n->hops,
  390.     n->rtt,
  391.     (int) n->next_ping_time,
  392.     (int) n->last_use_time);
  393. for (x = n->hosts; x; x = x->next)
  394.     fprintf(fp, " %s", x->name);
  395. fprintf(fp, "n");
  396. count++;
  397.     }
  398.     fclose(fp);
  399.     getCurrentTime();
  400.     debug(38, 1) ("NETDB state saved; %d entries, %d msecn",
  401. count, tvSubMsec(start, current_time));
  402.     eventAddIsh("netdbSaveState", netdbSaveState, NULL, 3600.0, 1);
  403. }
  405. static void
  406. netdbReloadState(void)
  407. {
  408.     LOCAL_ARRAY(char, path, SQUID_MAXPATHLEN);
  409.     char *buf;
  410.     char *t;
  411.     FILE *fp;
  412.     netdbEntry *n;
  413.     netdbEntry N;
  414.     struct in_addr addr;
  415.     int count = 0;
  416.     struct timeval start = current_time;
  417.     snprintf(path, SQUID_MAXPATHLEN, "%s/netdb_state", storeSwapDir(0));
  418.     fp = fopen(path, "r");
  419.     if (fp == NULL)
  420. return;
  421.     buf = memAllocate(MEM_4K_BUF);
  422.     while (fgets(buf, 4095, fp)) {
  423. memset(&N, '', sizeof(netdbEntry));
  424. if ((t = strtok(buf, w_space)) == NULL)
  425.     continue;
  426. if (!safe_inet_addr(t, &addr))
  427.     continue;
  428. if (netdbLookupAddr(addr) != NULL) /* no dups! */
  429.     continue;
  430. if ((t = strtok(NULL, w_space)) == NULL)
  431.     continue;
  432. N.pings_sent = atoi(t);
  433. if ((t = strtok(NULL, w_space)) == NULL)
  434.     continue;
  435. N.pings_recv = atoi(t);
  436. if (N.pings_recv == 0)
  437.     continue;
  438. /* give this measurement low weight */
  439. N.pings_sent = 1;
  440. N.pings_recv = 1;
  441. if ((t = strtok(NULL, w_space)) == NULL)
  442.     continue;
  443. N.hops = atof(t);
  444. if ((t = strtok(NULL, w_space)) == NULL)
  445.     continue;
  446. N.rtt = atof(t);
  447. if ((t = strtok(NULL, w_space)) == NULL)
  448.     continue;
  449. N.next_ping_time = (time_t) atoi(t);
  450. if ((t = strtok(NULL, w_space)) == NULL)
  451.     continue;
  452. N.last_use_time = (time_t) atoi(t);
  453. n = memAllocate(MEM_NETDBENTRY);
  454. xmemcpy(n, &N, sizeof(netdbEntry));
  455. netdbHashInsert(n, addr);
  456. while ((t = strtok(NULL, w_space)) != NULL) {
  457.     if (netdbLookupHost(t) != NULL) /* no dups! */
  458. continue;
  459.     netdbHostInsert(n, t);
  460. }
  461. count++;
  462.     }
  463.     memFree(buf, MEM_4K_BUF);
  464.     fclose(fp);
  465.     getCurrentTime();
  466.     debug(38, 1) ("NETDB state reloaded; %d entries, %d msecn",
  467. count, tvSubMsec(start, current_time));
  468. }
  470. static char *
  471. netdbPeerName(const char *name)
  472. {
  473.     wordlist *w;
  474.     for (w = peer_names; w; w = w->next) {
  475. if (!strcmp(w->key, name))
  476.     return w->key;
  477.     }
  478.     w = wordlistAdd(&peer_names, name);
  479.     return w->key;
  480. }
  482. static void
  483. netdbFreeNetdbEntry(void *data)
  484. {
  485.     netdbEntry *n = data;
  486.     safe_free(n->peers);
  487.     memFree(n, MEM_NETDBENTRY);
  488. }
  490. static void
  491. netdbFreeNameEntry(void *data)
  492. {
  493.     net_db_name *x = data;
  494.     xfree(x->name);
  495.     memFree(x, MEM_NET_DB_NAME);
  496. }
  498. static void
  499. netdbExchangeHandleReply(void *data, char *buf, ssize_t size)
  500. {
  501.     netdbExchangeState *ex = data;
  502.     int rec_sz = 0;
  503.     off_t o;
  504.     struct in_addr addr;
  505.     double rtt;
  506.     double hops;
  507.     char *p;
  508.     int j;
  509.     HttpReply *rep;
  510.     size_t hdr_sz;
  511.     int nused = 0;
  512.     rec_sz = 0;
  513.     rec_sz += 1 + sizeof(addr.s_addr);
  514.     rec_sz += 1 + sizeof(int);
  515.     rec_sz += 1 + sizeof(int);
  516.     ex->seen = ex->used + size;
  517.     debug(38, 3) ("netdbExchangeHandleReply: %d bytesn", (int) size);
  518.     if (!cbdataValid(ex->p)) {
  519. debug(38, 3) ("netdbExchangeHandleReply: Peer became invalidn");
  520. netdbExchangeDone(ex);
  521. return;
  522.     }
  523.     debug(38, 3) ("netdbExchangeHandleReply: for '%s:%d'n", ex->p->host, ex->p->http_port);
  524.     p = buf;
  525.     if (0 == ex->used) {
  526. /* skip reply headers */
  527. if ((hdr_sz = headersEnd(p, size))) {
  528.     debug(38, 5) ("netdbExchangeHandleReply: hdr_sz = %dn", hdr_sz);
  529.     rep = ex->e->mem_obj->reply;
  530.     if (0 == rep->sline.status)
  531. httpReplyParse(rep, buf);
  532.     debug(38, 3) ("netdbExchangeHandleReply: reply status %dn",
  533. rep->sline.status);
  534.     if (HTTP_OK != rep->sline.status) {
  535. netdbExchangeDone(ex);
  536. return;
  537.     }
  538.     assert(size >= hdr_sz);
  539.     ex->used += hdr_sz;
  540.     size -= hdr_sz;
  541.     p += hdr_sz;
  542. } else {
  543.     size = 0;
  544. }
  545.     }
  546.     debug(38, 5) ("netdbExchangeHandleReply: start parsing loop, size = %dn",
  547. size);
  548.     while (size >= rec_sz) {
  549. debug(38, 5) ("netdbExchangeHandleReply: in parsing loop, size = %dn",
  550.     size);
  551. addr.s_addr = any_addr.s_addr;
  552. hops = rtt = 0.0;
  553. for (o = 0; o < rec_sz;) {
  554.     switch ((int) *(p + o)) {
  555.     case NETDB_EX_NETWORK:
  556. o++;
  557. xmemcpy(&addr.s_addr, p + o, sizeof(addr.s_addr));
  558. o += sizeof(addr.s_addr);
  559. break;
  560.     case NETDB_EX_RTT:
  561. o++;
  562. xmemcpy(&j, p + o, sizeof(int));
  563. o += sizeof(int);
  564. rtt = (double) ntohl(j) / 1000.0;
  565. break;
  566.     case NETDB_EX_HOPS:
  567. o++;
  568. xmemcpy(&j, p + o, sizeof(int));
  569. o += sizeof(int);
  570. hops = (double) ntohl(j) / 1000.0;
  571. break;
  572.     }
  573. }
  574. if (addr.s_addr != any_addr.s_addr && rtt > 0)
  575.     netdbExchangeUpdatePeer(addr, ex->p, rtt, hops);
  576. assert(o == rec_sz);
  577. ex->used += rec_sz;
  578. size -= rec_sz;
  579. p += rec_sz;
  580. /*
  581.  * This is a fairly cpu-intensive loop, break after adding
  582.  * just a few
  583.  */
  584. if (++nused == 20)
  585.     break;
  586.     }
  587.     debug(38, 3) ("netdbExchangeHandleReply: used %d entries, (x %d bytes) == %d bytes totaln",
  588. nused, rec_sz, nused * rec_sz);
  589.     debug(38, 3) ("netdbExchangeHandleReply: seen %d, used %dn", ex->seen, ex->used);
  590.     if (EBIT_TEST(ex->e->flags, ENTRY_ABORTED)) {
  591. debug(38, 3) ("netdbExchangeHandleReply: ENTRY_ABORTEDn");
  592. netdbExchangeDone(ex);
  593.     } else if (ex->e->store_status == STORE_PENDING) {
  594. debug(38, 3) ("netdbExchangeHandleReply: STORE_PENDINGn");
  595. storeClientCopy(ex->e, ex->seen, ex->used, ex->buf_sz,
  596.     ex->buf, netdbExchangeHandleReply, ex);
  597.     } else if (ex->seen < ex->e->mem_obj->inmem_hi) {
  598. debug(38, 3) ("netdbExchangeHandleReply: ex->e->mem_obj->inmem_hin");
  599. storeClientCopy(ex->e, ex->seen, ex->used, ex->buf_sz,
  600.     ex->buf, netdbExchangeHandleReply, ex);
  601.     } else {
  602. debug(38, 3) ("netdbExchangeHandleReply: Donen");
  603. netdbExchangeDone(ex);
  604.     }
  605. }
  607. static void
  608. netdbExchangeDone(void *data)
  609. {
  610.     netdbExchangeState *ex = data;
  611.     debug(38, 3) ("netdbExchangeDone: %sn", storeUrl(ex->e));
  612.     memFree(ex->buf, MEM_4K_BUF);
  613.     requestUnlink(ex->r);
  614.     storeUnregister(ex->e, ex);
  615.     storeUnlockObject(ex->e);
  616.     cbdataUnlock(ex->p);
  617.     cbdataFree(ex);
  618. }
  620. #endif /* USE_ICMP */
  622. /* PUBLIC FUNCTIONS */
  624. void
  625. netdbInit(void)
  626. {
  627. #if USE_ICMP
  628.     int n;
  629.     if (addr_table)
  630. return;
  631.     n = hashPrime(Config.Netdb.high / 4);
  632.     addr_table = hash_create((HASHCMP *) strcmp, n, hash_string);
  633.     n = hashPrime(3 * Config.Netdb.high / 4);
  634.     host_table = hash_create((HASHCMP *) strcmp, n, hash_string);
  635.     eventAddIsh("netdbSaveState", netdbSaveState, NULL, 3600.0, 1);
  636.     netdbReloadState();
  637.     cachemgrRegister("netdb",
  638. "Network Measurement Database",
  639. netdbDump, 0, 1);
  640. #endif
  641. }
  643. void
  644. netdbPingSite(const char *hostname)
  645. {
  646. #if USE_ICMP
  647.     netdbEntry *n;
  648.     char *h;
  649.     if ((n = netdbLookupHost(hostname)) != NULL)
  650. if (n->next_ping_time > squid_curtime)
  651.     return;
  652.     h = xstrdup(hostname);
  653.     cbdataAdd(h, cbdataXfree, 0);
  654.     cbdataLock(h);
  655.     ipcache_nbgethostbyname(hostname, netdbSendPing, h);
  656. #endif
  657. }
  659. void
  660. netdbHandlePingReply(const struct sockaddr_in *from, int hops, int rtt)
  661. {
  662. #if USE_ICMP
  663.     netdbEntry *n;
  664.     int N;
  665.     debug(38, 3) ("netdbHandlePingReply: from %sn", inet_ntoa(from->sin_addr));
  666.     if ((n = netdbLookupAddr(from->sin_addr)) == NULL)
  667. return;
  668.     N = ++n->pings_recv;
  669.     if (N > 5)
  670. N = 5;
  671.     n->hops = ((n->hops * (N - 1)) + hops) / N;
  672.     n->rtt = ((n->rtt * (N - 1)) + rtt) / N;
  673.     debug(38, 3) ("netdbHandlePingReply: %s; rtt=%5.1f  hops=%4.1fn",
  674. n->network,
  675. n->rtt,
  676. n->hops);
  677. #endif
  678. }
  680. void
  681. netdbFreeMemory(void)
  682. {
  683. #if USE_ICMP
  684.     hashFreeItems(addr_table, netdbFreeNetdbEntry);
  685.     hashFreeMemory(addr_table);
  686.     addr_table = NULL;
  687.     hashFreeItems(host_table, netdbFreeNameEntry);
  688.     hashFreeMemory(host_table);
  689.     host_table = NULL;
  690.     wordlistDestroy(&peer_names);
  691.     peer_names = NULL;
  692. #endif
  693. }
  695. int
  696. netdbHops(struct in_addr addr)
  697. {
  698. #if USE_ICMP
  699.     netdbEntry *n = netdbLookupAddr(addr);
  700.     if (n && n->pings_recv) {
  701. n->last_use_time = squid_curtime;
  702. return (int) (n->hops + 0.5);
  703.     }
  704. #endif
  705.     return 256;
  706. }
  708. void
  709. netdbDump(StoreEntry * sentry)
  710. {
  711. #if USE_ICMP
  712.     netdbEntry *n;
  713.     netdbEntry **list;
  714.     net_db_name *x;
  715.     int k;
  716.     int i;
  717.     int j;
  718.     net_db_peer *p;
  719.     storeAppendPrintf(sentry, "Network DB Statistics:n");
  720.     storeAppendPrintf(sentry, "%-16.16s %9s %7s %5s %sn",
  721. "Network",
  722. "recv/sent",
  723. "RTT",
  724. "Hops",
  725. "Hostnames");
  726.     list = xcalloc(memInUse(MEM_NETDBENTRY), sizeof(netdbEntry *));
  727.     i = 0;
  728.     hash_first(addr_table);
  729.     while ((n = (netdbEntry *) hash_next(addr_table)))
  730. *(list + i++) = n;
  731.     if (i != memInUse(MEM_NETDBENTRY))
  732. debug(38, 0) ("WARNING: netdb_addrs count off, found %d, expected %dn",
  733.     i, memInUse(MEM_NETDBENTRY));
  734.     qsort((char *) list,
  735. i,
  736. sizeof(netdbEntry *),
  737. sortByRtt);
  738.     for (k = 0; k < i; k++) {
  739. n = *(list + k);
  740. storeAppendPrintf(sentry, "%-16.16s %4d/%4d %7.1f %5.1f",
  741.     n->network,
  742.     n->pings_recv,
  743.     n->pings_sent,
  744.     n->rtt,
  745.     n->hops);
  746. for (x = n->hosts; x; x = x->next)
  747.     storeAppendPrintf(sentry, " %s", x->name);
  748. storeAppendPrintf(sentry, "n");
  749. p = n->peers;
  750. for (j = 0; j < n->n_peers; j++, p++) {
  751.     storeAppendPrintf(sentry, "    %-22.22s %7.1f %5.1fn",
  752. p->peername,
  753. p->rtt,
  754. p->hops);
  755. }
  756.     }
  757.     xfree(list);
  758. #else
  759.     storeAppendPrintf(sentry,
  760. "NETDB support not compiled into this Squid cache.n");
  761. #endif
  762. }
  764. int
  765. netdbHostHops(const char *host)
  766. {
  767. #if USE_ICMP
  768.     netdbEntry *n = netdbLookupHost(host);
  769.     if (n) {
  770. n->last_use_time = squid_curtime;
  771. return (int) (n->hops + 0.5);
  772.     }
  773. #endif
  774.     return 0;
  775. }
  777. int
  778. netdbHostRtt(const char *host)
  779. {
  780. #if USE_ICMP
  781.     netdbEntry *n = netdbLookupHost(host);
  782.     if (n) {
  783. n->last_use_time = squid_curtime;
  784. return (int) (n->rtt + 0.5);
  785.     }
  786. #endif
  787.     return 0;
  788. }
  790. void
  791. netdbHostData(const char *host, int *samp, int *rtt, int *hops)
  792. {
  793. #if USE_ICMP
  794.     netdbEntry *n = netdbLookupHost(host);
  795.     if (n == NULL)
  796. return;
  797.     *samp = n->pings_recv;
  798.     *rtt = (int) (n->rtt + 0.5);
  799.     *hops = (int) (n->hops + 0.5);
  800. #endif
  801. }
  803. int
  804. netdbHostPeerRtt(const char *host, peer * p)
  805. {
  806. #if USE_ICMP
  807.     const netdbEntry *n = netdbLookupHost(host);
  808.     if (n) {
  809. const net_db_peer *np = netdbPeerByName(n, p->host);
  810. if (np && np->expires >= squid_curtime)
  811.     return (int) (np->rtt + 0.5);
  812.     }
  813. #endif
  814.     return 0;
  815. }
  817. void
  818. netdbUpdatePeer(request_t * r, peer * e, int irtt, int ihops)
  819. {
  820. #if USE_ICMP
  821.     netdbEntry *n;
  822.     double rtt = (double) irtt;
  823.     double hops = (double) ihops;
  824.     net_db_peer *p;
  825.     debug(38, 3) ("netdbUpdatePeer: '%s', %d hops, %d rttn", r->host, ihops, irtt);
  826.     n = netdbLookupHost(r->host);
  827.     if (n == NULL) {
  828. debug(38, 3) ("netdbUpdatePeer: host '%s' not foundn", r->host);
  829. return;
  830.     }
  831.     if ((p = netdbPeerByName(n, e->host)) == NULL)
  832. p = netdbPeerAdd(n, e);
  833.     p->rtt = rtt;
  834.     p->hops = hops;
  835.     p->expires = squid_curtime + 3600;
  836.     if (n->n_peers < 2)
  837. return;
  838.     qsort((char *) n->peers,
  839. n->n_peers,
  840. sizeof(net_db_peer),
  841. sortPeerByRtt);
  842. #endif
  843. }
  845. void
  846. netdbExchangeUpdatePeer(struct in_addr addr, peer * e, double rtt, double hops)
  847. {
  848. #if USE_ICMP
  849.     netdbEntry *n;
  850.     net_db_peer *p;
  851.     debug(38, 5) ("netdbExchangeUpdatePeer: '%s', %0.1f hops, %0.1f rttn",
  852. inet_ntoa(addr), hops, rtt);
  853.     n = netdbLookupAddr(addr);
  854.     if (n == NULL)
  855. n = netdbAdd(addr);
  856.     assert(NULL != n);
  857.     if ((p = netdbPeerByName(n, e->host)) == NULL)
  858. p = netdbPeerAdd(n, e);
  859.     p->rtt = rtt;
  860.     p->hops = hops;
  861.     p->expires = squid_curtime + 3600; /* XXX ? */
  862.     if (n->n_peers < 2)
  863. return;
  864.     qsort((char *) n->peers,
  865. n->n_peers,
  866. sizeof(net_db_peer),
  867. sortPeerByRtt);
  868. #endif
  869. }
  871. void
  872. netdbDeleteAddrNetwork(struct in_addr addr)
  873. {
  874. #if USE_ICMP
  875.     netdbEntry *n = netdbLookupAddr(addr);
  876.     if (n == NULL)
  877. return;
  878.     debug(38, 3) ("netdbDeleteAddrNetwork: %sn", n->network);
  879.     netdbRelease(n);
  880. #endif
  881. }
  883. void
  884. netdbBinaryExchange(StoreEntry * s)
  885. {
  886.     http_reply *reply = s->mem_obj->reply;
  887. #if USE_ICMP
  888.     netdbEntry *n;
  889.     int i;
  890.     int j;
  891.     int rec_sz;
  892.     char *buf;
  893.     struct in_addr addr;
  894.     storeBuffer(s);
  895.     httpReplyReset(reply);
  896.     httpReplySetHeaders(reply, 1.0, HTTP_OK, "OK",
  897. NULL, -1, squid_curtime, -2);
  898.     httpReplySwapOut(reply, s);
  899.     rec_sz = 0;
  900.     rec_sz += 1 + sizeof(addr.s_addr);
  901.     rec_sz += 1 + sizeof(int);
  902.     rec_sz += 1 + sizeof(int);
  903.     buf = memAllocate(MEM_4K_BUF);
  904.     i = 0;
  905.     hash_first(addr_table);
  906.     while ((n = (netdbEntry *) hash_next(addr_table))) {
  907. if (0.0 == n->rtt)
  908.     continue;
  909. if (n->rtt > 60000) /* RTT > 1 MIN probably bogus */
  910.     continue;
  911. if (!safe_inet_addr(n->network, &addr))
  912.     continue;
  913. buf[i++] = (char) NETDB_EX_NETWORK;
  914. xmemcpy(&buf[i], &addr.s_addr, sizeof(addr.s_addr));
  915. i += sizeof(addr.s_addr);
  916. buf[i++] = (char) NETDB_EX_RTT;
  917. j = htonl((int) (n->rtt * 1000));
  918. xmemcpy(&buf[i], &j, sizeof(int));
  919. i += sizeof(int);
  920. buf[i++] = (char) NETDB_EX_HOPS;
  921. j = htonl((int) (n->hops * 1000));
  922. xmemcpy(&buf[i], &j, sizeof(int));
  923. i += sizeof(int);
  924. if (i + rec_sz > 4096) {
  925.     storeAppend(s, buf, i);
  926.     i = 0;
  927. }
  928.     }
  929.     if (i > 0) {
  930. storeAppend(s, buf, i);
  931. i = 0;
  932.     }
  933.     assert(0 == i);
  934.     storeBufferFlush(s);
  935.     memFree(buf, MEM_4K_BUF);
  936. #else
  937.     httpReplyReset(reply);
  938.     httpReplySetHeaders(reply, 1.0, HTTP_BAD_REQUEST, "Bad Request",
  939. NULL, -1, squid_curtime, -2);
  940.     storeAppendPrintf(s, "NETDB support not compiled into this Squid cache.n");
  941. #endif
  942.     storeComplete(s);
  943. }
  945. void
  946. netdbExchangeStart(void *data)
  947. {
  948. #if USE_ICMP
  949.     peer *p = data;
  950.     char *uri;
  951.     netdbExchangeState *ex = xcalloc(1, sizeof(*ex));
  952.     cbdataAdd(ex, cbdataXfree, 0);
  953.     cbdataLock(p);
  954.     ex->p = p;
  955.     uri = internalRemoteUri(p->host, p->http_port, "/squid-internal-dynamic/", "netdb");
  956.     debug(38, 3) ("netdbExchangeStart: Requesting '%s'n", uri);
  957.     assert(NULL != uri);
  958.     ex->r = urlParse(METHOD_GET, uri);
  959.     if (NULL == ex->r) {
  960. debug(38, 1) ("netdbExchangeStart: Bad URI %sn", uri);
  961. return;
  962.     }
  963.     requestLink(ex->r);
  964.     assert(NULL != ex->r);
  965.     ex->r->http_ver = 1.0;
  966.     ex->e = storeCreateEntry(uri, uri, null_request_flags, METHOD_GET);
  967.     ex->buf_sz = 4096;;
  968.     ex->buf = memAllocate(MEM_4K_BUF);
  969.     assert(NULL != ex->e);
  970.     storeClientListAdd(ex->e, ex);
  971.     storeClientCopy(ex->e, ex->seen, ex->used, ex->buf_sz,
  972. ex->buf, netdbExchangeHandleReply, ex);
  973.     ex->r->flags.loopdetect = 1; /* cheat! -- force direct */
  974.     fwdStart(-1, ex->e, ex->r, no_addr, no_addr);
  975. #endif
  976. }
  978. peer *
  979. netdbClosestParent(request_t * request)
  980. {
  981. #if USE_ICMP
  982.     peer *p = NULL;
  983.     netdbEntry *n;
  984.     const ipcache_addrs *ia;
  985.     net_db_peer *h;
  986.     int i;
  987.     n = netdbLookupHost(request->host);
  988.     if (NULL == n) {
  989. /* try IP addr */
  990. ia = ipcache_gethostbyname(request->host, 0);
  991. if (NULL != ia)
  992.     n = netdbLookupAddr(ia->in_addrs[ia->cur]);
  993.     }
  994.     if (NULL == n)
  995. return NULL;
  996.     if (0 == n->n_peers)
  997. return NULL;
  998.     /* 
  999.      * Find the parent with the least RTT to the origin server.
  1000.      * Make sure we don't return a parent who is farther away than
  1001.      * we are.  Note, the n->peers list is pre-sorted by RTT.
  1002.      */
  1003.     for (i = 0; i < n->n_peers; i++) {
  1004. h = &n->peers[i];
  1005. if (n->rtt > 0)
  1006.     if (n->rtt < h->rtt)
  1007. break;
  1008. p = peerFindByName(h->peername);
  1009. if (NULL == p) /* not found */
  1010.     continue;
  1011. if (neighborType(p, request) != PEER_PARENT)
  1012.     continue;
  1013. if (!peerHTTPOkay(p, request)) /* not allowed */
  1014.     continue;
  1015. return p;
  1016.     }
  1017. #endif
  1018.     return NULL;
  1019. }