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

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

代理服务器

开发平台：

Unix_Linux

ipcache.c：源码内容
  2. /*
  3.  * $Id: ipcache.c,v 1.210 1998/12/05 00:54:30 wessels Exp $
  4.  *
  5.  * DEBUG: section 14    IP Cache
  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. static struct {
  39.     int requests;
  40.     int replies;
  41.     int hits;
  42.     int misses;
  43.     int pending_hits;
  44.     int negative_hits;
  45.     int errors;
  46.     int ghbn_calls; /* # calls to blocking gethostbyname() */
  47.     int release_locked;
  48. } IpcacheStats;
  50. static dlink_list lru_list;
  52. static FREE ipcacheFreeEntry;
  53. static HLPCB ipcacheHandleReply;
  54. static IPH dummy_handler;
  55. static int ipcacheExpiredEntry(ipcache_entry *);
  56. static int ipcache_testname(void);
  57. static ipcache_entry *ipcacheAddNew(const char *, const struct hostent *, ipcache_status_t);
  58. static ipcache_entry *ipcacheParse(const char *buf);
  59. static ipcache_entry *ipcache_create(const char *name);
  60. static ipcache_entry *ipcache_get(const char *);
  61. static void ipcacheAddHostent(ipcache_entry *, const struct hostent *);
  62. static void ipcacheAddPending(ipcache_entry *, IPH *, void *);
  63. static void ipcacheChangeKey(ipcache_entry * i);
  64. static void ipcacheLockEntry(ipcache_entry *);
  65. static void ipcacheStatPrint(ipcache_entry *, StoreEntry *);
  66. static void ipcacheUnlockEntry(ipcache_entry *);
  67. static void ipcache_call_pending(ipcache_entry *);
  68. static void ipcache_release(ipcache_entry *);
  70. static ipcache_addrs static_addrs;
  71. static hash_table *ip_table = NULL;
  73. static char ipcache_status_char[] =
  74. {
  75.     'C',
  76.     'N',
  77.     'P',
  78.     'D'
  79. };
  81. static long ipcache_low = 180;
  82. static long ipcache_high = 200;
  84. #if LIBRESOLV_DNS_TTL_HACK
  85. extern int _dns_ttl_;
  86. #endif
  88. static int
  89. ipcache_testname(void)
  90. {
  91.     wordlist *w = NULL;
  92.     debug(14, 1) ("Performing DNS Tests...n");
  93.     if ((w = Config.dns_testname_list) == NULL)
  94. return 1;
  95.     for (; w; w = w->next) {
  96. IpcacheStats.ghbn_calls++;
  97. if (gethostbyname(w->key) != NULL)
  98.     return 1;
  99.     }
  100.     return 0;
  101. }
  103. /* removes the given ipcache entry */
  104. static void
  105. ipcache_release(ipcache_entry * i)
  106. {
  107.     hash_link *table_entry = NULL;
  108.     if ((table_entry = hash_lookup(ip_table, i->name)) == NULL) {
  109. snprintf(tmp_error_buf, ERROR_BUF_SZ, "ipcache_release: key '%s' not foundn", i->name);
  110. fatal_dump(tmp_error_buf);
  111.     }
  112.     assert(i == (ipcache_entry *) table_entry);
  113.     if (i->locks) {
  114. i->expires = squid_curtime;
  115. ipcacheChangeKey(i);
  116. IpcacheStats.release_locked++;
  117. return;
  118.     }
  119.     hash_remove_link(ip_table, table_entry);
  120.     dlinkDelete(&i->lru, &lru_list);
  121.     if (i->status == IP_CACHED) {
  122. safe_free(i->addrs.in_addrs);
  123. safe_free(i->addrs.bad_mask);
  124. debug(14, 5) ("ipcache_release: Released IP cached record for '%s'.n",
  125.     i->name);
  126.     }
  127.     safe_free(i->name);
  128.     safe_free(i->error_message);
  129.     memFree(i, MEM_IPCACHE_ENTRY);
  130.     return;
  131. }
  133. static ipcache_entry *
  134. ipcache_get(const char *name)
  135. {
  136.     assert(ip_table != NULL);
  137.     return (ipcache_entry *) hash_lookup(ip_table, name);
  138. }
  140. static int
  141. ipcacheExpiredEntry(ipcache_entry * i)
  142. {
  143.     if (i->status == IP_PENDING)
  144. return 0;
  145.     if (i->status == IP_DISPATCHED)
  146. return 0;
  147.     if (i->locks != 0)
  148. return 0;
  149.     if (i->addrs.count == 0)
  150. return 1;
  151.     if (i->expires > squid_curtime)
  152. return 0;
  153.     return 1;
  154. }
  156. void
  157. ipcache_purgelru(void *voidnotused)
  158. {
  159.     dlink_node *m;
  160.     dlink_node *prev = NULL;
  161.     ipcache_entry *i;
  162.     int removed = 0;
  163.     eventAdd("ipcache_purgelru", ipcache_purgelru, NULL, 10.0, 1);
  164.     for (m = lru_list.tail; m; m = prev) {
  165. if (memInUse(MEM_IPCACHE_ENTRY) < ipcache_low)
  166.     break;
  167. prev = m->prev;
  168. i = m->data;
  169. if (i->status == IP_PENDING)
  170.     continue;
  171. if (i->status == IP_DISPATCHED)
  172.     continue;
  173. if (i->locks != 0)
  174.     continue;
  175. ipcache_release(i);
  176. removed++;
  177.     }
  178.     debug(14, 9) ("ipcache_purgelru: removed %d entriesn", removed);
  179. }
  181. /* create blank ipcache_entry */
  182. static ipcache_entry *
  183. ipcache_create(const char *name)
  184. {
  185.     static ipcache_entry *i;
  186.     i = memAllocate(MEM_IPCACHE_ENTRY);
  187.     i->name = xstrdup(name);
  188.     i->expires = squid_curtime + Config.negativeDnsTtl;
  189.     hash_join(ip_table, (hash_link *) i);
  190.     dlinkAdd(i, &i->lru, &lru_list);
  191.     return i;
  192. }
  194. static void
  195. ipcacheAddHostent(ipcache_entry * i, const struct hostent *hp)
  196. {
  197.     int addr_count = 0;
  198.     int k;
  199.     safe_free(i->addrs.in_addrs);
  200.     safe_free(i->addrs.bad_mask);
  201.     while ((addr_count < 255) && *(hp->h_addr_list + addr_count))
  202. ++addr_count;
  203.     i->addrs.count = (unsigned char) addr_count;
  204.     i->addrs.in_addrs = xcalloc(addr_count, sizeof(struct in_addr));
  205.     i->addrs.bad_mask = xcalloc(addr_count, sizeof(unsigned char));
  206.     i->addrs.badcount = 0;
  207.     for (k = 0; k < addr_count; k++)
  208. xmemcpy(&i->addrs.in_addrs[k].s_addr,
  209.     *(hp->h_addr_list + k),
  210.     hp->h_length);
  211. }
  213. static ipcache_entry *
  214. ipcacheAddNew(const char *name, const struct hostent *hp, ipcache_status_t status)
  215. {
  216.     ipcache_entry *i;
  217.     if (ipcache_get(name))
  218. fatal_dump("ipcacheAddNew: somebody adding a duplicate!");
  219.     debug(14, 10) ("ipcacheAddNew: Adding '%s', status=%cn",
  220. name,
  221. ipcache_status_char[status]);
  222.     i = ipcache_create(name);
  223.     if (hp)
  224. ipcacheAddHostent(i, hp);
  225.     i->status = status;
  226.     i->lastref = squid_curtime;
  227.     return i;
  228. }
  230. /* walks down the pending list, calling handlers */
  231. static void
  232. ipcache_call_pending(ipcache_entry * i)
  233. {
  234.     ip_pending *p = NULL;
  235.     int nhandler = 0;
  236.     i->lastref = squid_curtime;
  237.     ipcacheLockEntry(i);
  238.     while (i->pending_head != NULL) {
  239. p = i->pending_head;
  240. i->pending_head = p->next;
  241. if (p->handler) {
  242.     nhandler++;
  243.     dns_error_message = i->error_message;
  244.     if (cbdataValid(p->handlerData)) {
  245. p->handler(i->status == IP_CACHED ? &i->addrs : NULL,
  246.     p->handlerData);
  247.     }
  248.     cbdataUnlock(p->handlerData);
  249. }
  250. memFree(p, MEM_IPCACHE_PENDING);
  251.     }
  252.     i->pending_head = NULL; /* nuke list */
  253.     debug(14, 10) ("ipcache_call_pending: Called %d handlers.n", nhandler);
  254.     ipcacheUnlockEntry(i);
  255. }
  257. static ipcache_entry *
  258. ipcacheParse(const char *inbuf)
  259. {
  260.     LOCAL_ARRAY(char, buf, DNS_INBUF_SZ);
  261.     char *token;
  262.     static ipcache_entry i;
  263.     int j;
  264.     int k;
  265.     int ipcount = 0;
  266.     int ttl;
  267.     char A[32][16];
  268.     memset(&i, '', sizeof(i));
  269.     i.expires = squid_curtime;
  270.     i.status = IP_NEGATIVE_CACHED;
  271.     if (inbuf == NULL) {
  272. debug(14, 1) ("ipcacheParse: Got <NULL> replyn");
  273. i.error_message = xstrdup("Internal Squid Error");
  274. return &i;
  275.     }
  276.     xstrncpy(buf, inbuf, DNS_INBUF_SZ);
  277.     debug(14, 5) ("ipcacheParse: parsing: {%s}n", buf);
  278.     token = strtok(buf, w_space);
  279.     if (NULL == token) {
  280. debug(14, 1) ("ipcacheParse: Got <NULL>, expecting '$addr'n");
  281. return &i;
  282.     }
  283.     if (0 == strcmp(token, "$fail")) {
  284. i.expires = squid_curtime + Config.negativeDnsTtl;
  285. token = strtok(NULL, "n");
  286. assert(NULL != token);
  287. i.error_message = xstrdup(token);
  288. return &i;
  289.     }
  290.     if (0 != strcmp(token, "$addr")) {
  291. debug(14, 1) ("ipcacheParse: Got '%s', expecting '$addr'n", token);
  292. return &i;
  293.     }
  294.     token = strtok(NULL, w_space);
  295.     if (NULL == token) {
  296. debug(14, 1) ("ipcacheParse: Got <NULL>, expecting TTLn");
  297. return &i;
  298.     }
  299.     i.status = IP_CACHED;
  300.     ttl = atoi(token);
  301.     if (ttl > 0)
  302. i.expires = squid_curtime + ttl;
  303.     else
  304. i.expires = squid_curtime + Config.positiveDnsTtl;
  305.     while (NULL != (token = strtok(NULL, w_space))) {
  306. xstrncpy(A[ipcount], token, 16);
  307. if (++ipcount == 32)
  308.     break;
  309.     }
  310.     if (0 == ipcount) {
  311. i.addrs.in_addrs = NULL;
  312. i.addrs.bad_mask = NULL;
  313.     } else {
  314. i.addrs.in_addrs = xcalloc(ipcount, sizeof(struct in_addr));
  315. i.addrs.bad_mask = xcalloc(ipcount, sizeof(unsigned char));
  316.     }
  317.     for (j = 0, k = 0; k < ipcount; k++) {
  318. if (safe_inet_addr(A[k], &i.addrs.in_addrs[j]))
  319.     j++;
  320. else
  321.     debug(14, 1) ("ipcacheParse: Invalid IP address '%s'n", A[k]);
  322.     }
  323.     i.addrs.count = (unsigned char) j;
  324.     return &i;
  325. }
  327. static void
  328. ipcacheHandleReply(void *data, char *reply)
  329. {
  330.     int n;
  331.     generic_cbdata *c = data;
  332.     ipcache_entry *i = c->data;
  333.     ipcache_entry *x = NULL;
  334.     assert(i->status == IP_DISPATCHED);
  335.     assert(i->locks);
  336.     cbdataFree(c);
  337.     c = NULL;
  338.     n = ++IpcacheStats.replies;
  339.     statHistCount(&Counter.dns.svc_time, tvSubMsec(i->request_time, current_time));
  340.     x = ipcacheParse(reply);
  341.     assert(x);
  342.     i->status = x->status;
  343.     i->addrs = x->addrs;
  344.     i->error_message = x->error_message;
  345.     i->expires = x->expires;
  346.     ipcache_call_pending(i);
  347.     ipcacheUnlockEntry(i); /* unlock from IP_DISPATCHED */
  348. }
  350. static void
  351. ipcacheAddPending(ipcache_entry * i, IPH * handler, void *handlerData)
  352. {
  353.     ip_pending *pending = memAllocate(MEM_IPCACHE_PENDING);
  354.     ip_pending **I = NULL;
  355.     i->lastref = squid_curtime;
  356.     pending->handler = handler;
  357.     pending->handlerData = handlerData;
  358.     cbdataLock(handlerData);
  359.     for (I = &(i->pending_head); *I; I = &((*I)->next));
  360.     *I = pending;
  361. }
  363. void
  364. ipcache_nbgethostbyname(const char *name, IPH * handler, void *handlerData)
  365. {
  366.     ipcache_entry *i = NULL;
  367.     const ipcache_addrs *addrs = NULL;
  368.     generic_cbdata *c;
  369.     assert(handler != NULL);
  370.     debug(14, 4) ("ipcache_nbgethostbyname: Name '%s'.n", name);
  371.     IpcacheStats.requests++;
  372.     if (name == NULL || name[0] == '') {
  373. debug(14, 4) ("ipcache_nbgethostbyname: Invalid name!n");
  374. handler(NULL, handlerData);
  375. return;
  376.     }
  377.     if ((addrs = ipcacheCheckNumeric(name))) {
  378. handler(addrs, handlerData);
  379. return;
  380.     }
  381.     if ((i = ipcache_get(name))) {
  382. if (ipcacheExpiredEntry(i)) {
  383.     ipcache_release(i);
  384.     i = NULL;
  385. }
  386.     }
  387.     if (i == NULL) {
  388. /* MISS: No entry, create the new one */
  389. debug(14, 5) ("ipcache_nbgethostbyname: MISS for '%s'n", name);
  390. IpcacheStats.misses++;
  391. i = ipcacheAddNew(name, NULL, IP_PENDING);
  392. ipcacheAddPending(i, handler, handlerData);
  393. i->request_time = current_time;
  394.     } else if (i->status == IP_CACHED || i->status == IP_NEGATIVE_CACHED) {
  395. /* HIT */
  396. debug(14, 4) ("ipcache_nbgethostbyname: HIT for '%s'n", name);
  397. if (i->status == IP_NEGATIVE_CACHED)
  398.     IpcacheStats.negative_hits++;
  399. else
  400.     IpcacheStats.hits++;
  401. ipcacheAddPending(i, handler, handlerData);
  402. ipcache_call_pending(i);
  403. return;
  404.     } else if (i->status == IP_PENDING || i->status == IP_DISPATCHED) {
  405. debug(14, 4) ("ipcache_nbgethostbyname: PENDING for '%s'n", name);
  406. IpcacheStats.pending_hits++;
  407. ipcacheAddPending(i, handler, handlerData);
  408. if (squid_curtime - i->expires > 600) {
  409.     debug(14, 0) ("ipcache_nbgethostbyname: '%s' PENDING for %d seconds, abortingn", name, (int) (squid_curtime + Config.negativeDnsTtl - i->expires));
  410.     ipcacheChangeKey(i);
  411.     ipcache_call_pending(i);
  412. }
  413. return;
  414.     } else {
  415. fatal_dump("ipcache_nbgethostbyname: BAD ipcache_entry status");
  416.     }
  417.     /* for HIT, PENDING, DISPATCHED we've returned.  For MISS we submit */
  418.     c = xcalloc(1, sizeof(*c));
  419.     c->data = i;
  420.     cbdataAdd(c, cbdataXfree, 0);
  421.     i->status = IP_DISPATCHED;
  422.     ipcacheLockEntry(i);
  423.     dnsSubmit(i->name, ipcacheHandleReply, c);
  424. }
  426. /* initialize the ipcache */
  427. void
  428. ipcache_init(void)
  429. {
  430.     int n;
  431.     debug(14, 3) ("Initializing IP Cache...n");
  432.     memset(&IpcacheStats, '', sizeof(IpcacheStats));
  433.     memset(&lru_list, '', sizeof(lru_list));
  434.     /* test naming lookup */
  435.     if (!opt_dns_tests) {
  436. debug(14, 4) ("ipcache_init: Skipping DNS name lookup tests.n");
  437.     } else if (!ipcache_testname()) {
  438. fatal("ipcache_init: DNS name lookup tests failed.");
  439.     } else {
  440. debug(14, 1) ("Successful DNS name lookup tests...n");
  441.     }
  442.     memset(&static_addrs, '', sizeof(ipcache_addrs));
  443.     static_addrs.in_addrs = xcalloc(1, sizeof(struct in_addr));
  444.     static_addrs.bad_mask = xcalloc(1, sizeof(unsigned char));
  445.     ipcache_high = (long) (((float) Config.ipcache.size *
  446.     (float) Config.ipcache.high) / (float) 100);
  447.     ipcache_low = (long) (((float) Config.ipcache.size *
  448.     (float) Config.ipcache.low) / (float) 100);
  449.     n = hashPrime(ipcache_high / 4);
  450.     ip_table = hash_create((HASHCMP *) strcmp, n, hash4);
  451.     cachemgrRegister("ipcache",
  452. "IP Cache Stats and Contents",
  453. stat_ipcache_get, 0, 1);
  454. }
  456. int
  457. ipcacheUnregister(const char *name, void *data)
  458. {
  459.     ipcache_entry *i = NULL;
  460.     ip_pending *p = NULL;
  461.     int n = 0;
  462.     debug(14, 3) ("ipcacheUnregister: name '%s'n", name);
  463.     if ((i = ipcache_get(name)) == NULL)
  464. return 0;
  465.     if (i->status == IP_PENDING || i->status == IP_DISPATCHED) {
  466. for (p = i->pending_head; p; p = p->next) {
  467.     if (p->handlerData != data)
  468. continue;
  469.     p->handler = NULL;
  470.     n++;
  471. }
  472.     }
  473.     assert(n > 0);
  474.     debug(14, 3) ("ipcacheUnregister: unregistered %d handlersn", n);
  475.     return n;
  476. }
  478. const ipcache_addrs *
  479. ipcache_gethostbyname(const char *name, int flags)
  480. {
  481.     ipcache_entry *i = NULL;
  482.     ipcache_addrs *addrs;
  483.     if (!name)
  484. fatal_dump("ipcache_gethostbyname: NULL name");
  485.     debug(14, 3) ("ipcache_gethostbyname: '%s', flags=%xn", name, flags);
  486.     IpcacheStats.requests++;
  487.     if ((i = ipcache_get(name))) {
  488. if (ipcacheExpiredEntry(i)) {
  489.     ipcache_release(i);
  490.     i = NULL;
  491. }
  492.     }
  493.     if (i) {
  494. if (i->status == IP_NEGATIVE_CACHED) {
  495.     IpcacheStats.negative_hits++;
  496.     dns_error_message = i->error_message;
  497.     return NULL;
  498. } else if (i->addrs.count == 0) {
  499.     (void) 0;
  500. } else {
  501.     IpcacheStats.hits++;
  502.     i->lastref = squid_curtime;
  503.     return &i->addrs;
  504. }
  505.     }
  506.     if ((addrs = ipcacheCheckNumeric(name)))
  507. return addrs;
  508.     IpcacheStats.misses++;
  509.     if (flags & IP_LOOKUP_IF_MISS)
  510. ipcache_nbgethostbyname(name, dummy_handler, NULL);
  511.     return NULL;
  512. }
  514. static void
  515. ipcacheStatPrint(ipcache_entry * i, StoreEntry * sentry)
  516. {
  517.     int k;
  518.     storeAppendPrintf(sentry, " %-32.32s  %c%c %6d %6d %2d(%2d)",
  519. i->name,
  520. ipcache_status_char[i->status],
  521. i->locks ? 'L' : ' ',
  522. (int) (squid_curtime - i->lastref),
  523. (int) (i->expires - squid_curtime),
  524. (int) i->addrs.count,
  525. (int) i->addrs.badcount);
  526.     for (k = 0; k < (int) i->addrs.count; k++) {
  527. storeAppendPrintf(sentry, " %15s-%3s", inet_ntoa(i->addrs.in_addrs[k]),
  528.     i->addrs.bad_mask[k] ? "BAD" : "OK ");
  529.     }
  530.     storeAppendPrintf(sentry, "n");
  531. }
  533. /* process objects list */
  534. void
  535. stat_ipcache_get(StoreEntry * sentry)
  536. {
  537.     dlink_node *m;
  538.     assert(ip_table != NULL);
  539.     storeAppendPrintf(sentry, "IP Cache Statistics:n");
  540.     storeAppendPrintf(sentry, "IPcache Entries: %dn",
  541. memInUse(MEM_IPCACHE_ENTRY));
  542.     storeAppendPrintf(sentry, "IPcache Requests: %dn",
  543. IpcacheStats.requests);
  544.     storeAppendPrintf(sentry, "IPcache Hits: %dn",
  545. IpcacheStats.hits);
  546.     storeAppendPrintf(sentry, "IPcache Pending Hits: %dn",
  547. IpcacheStats.pending_hits);
  548.     storeAppendPrintf(sentry, "IPcache Negative Hits: %dn",
  549. IpcacheStats.negative_hits);
  550.     storeAppendPrintf(sentry, "IPcache Misses: %dn",
  551. IpcacheStats.misses);
  552.     storeAppendPrintf(sentry, "Blocking calls to gethostbyname(): %dn",
  553. IpcacheStats.ghbn_calls);
  554.     storeAppendPrintf(sentry, "Attempts to release locked entries: %dn",
  555. IpcacheStats.release_locked);
  556.     storeAppendPrintf(sentry, "nn");
  557.     storeAppendPrintf(sentry, "IP Cache Contents:nn");
  558.     storeAppendPrintf(sentry, " %-29.29s %5s %6s %6s %1sn",
  559. "Hostname",
  560. "Flags",
  561. "lstref",
  562. "TTL",
  563. "N");
  564.     for (m = lru_list.head; m; m = m->next)
  565. ipcacheStatPrint(m->data, sentry);
  566. }
  568. static void
  569. dummy_handler(const ipcache_addrs * addrsnotused, void *datanotused)
  570. {
  571.     return;
  572. }
  574. void
  575. ipcacheReleaseInvalid(const char *name)
  576. {
  577.     ipcache_entry *i;
  578.     if (NULL == name) {
  579. debug(14, 1) ("ipcacheReleaseInvalid: NULL namen");
  580. return;
  581.     }
  582.     if (0 == strlen(name)) {
  583. debug(14, 1) ("ipcacheReleaseInvalid: Empty namen");
  584. return;
  585.     }
  586.     if ((i = ipcache_get(name)) == NULL)
  587. return;
  588.     if (i->status != IP_NEGATIVE_CACHED)
  589. return;
  590.     ipcache_release(i);
  591. }
  593. void
  594. ipcacheInvalidate(const char *name)
  595. {
  596.     ipcache_entry *i;
  597.     if ((i = ipcache_get(name)) == NULL)
  598. return;
  599.     i->expires = squid_curtime;
  600.     /* NOTE, don't call ipcache_release here becuase we might be here due
  601.      * to a thread started from ipcache_call_pending() which will cause a
  602.      * FMR */
  603. }
  605. ipcache_addrs *
  606. ipcacheCheckNumeric(const char *name)
  607. {
  608.     struct in_addr ip;
  609.     /* check if it's already a IP address in text form. */
  610.     if (!safe_inet_addr(name, &ip))
  611. return NULL;
  612.     static_addrs.count = 1;
  613.     static_addrs.cur = 0;
  614.     static_addrs.in_addrs[0].s_addr = ip.s_addr;
  615.     static_addrs.bad_mask[0] = FALSE;
  616.     static_addrs.badcount = 0;
  617.     return &static_addrs;
  618. }
  620. static void
  621. ipcacheLockEntry(ipcache_entry * i)
  622. {
  623.     if (i->locks++ == 0) {
  624. dlinkDelete(&i->lru, &lru_list);
  625. dlinkAdd(i, &i->lru, &lru_list);
  626.     }
  627. }
  629. static void
  630. ipcacheUnlockEntry(ipcache_entry * i)
  631. {
  632.     assert(i->locks > 0);
  633.     i->locks--;
  634.     if (ipcacheExpiredEntry(i))
  635. ipcache_release(i);
  636. }
  638. void
  639. ipcacheCycleAddr(const char *name, ipcache_addrs * ia)
  640. {
  641.     ipcache_entry *i;
  642.     unsigned char k;
  643.     assert(name || ia);
  644.     if (NULL == ia) {
  645. if ((i = ipcache_get(name)) == NULL)
  646.     return;
  647. if (i->status != IP_CACHED)
  648.     return;
  649. ia = &i->addrs;
  650.     }
  651.     for (k = 0; k < ia->count; k++) {
  652. if (++ia->cur == ia->count)
  653.     ia->cur = 0;
  654. if (!ia->bad_mask[ia->cur])
  655.     break;;
  656.     }
  657.     if (k == ia->count) {
  658. /* All bad, reset to All good */
  659. debug(14, 3) ("ipcacheCycleAddr: Changing ALL %s addrs from BAD to OKn",
  660.     name);
  661. for (k = 0; k < ia->count; k++)
  662.     ia->bad_mask[k] = 0;
  663. ia->badcount = 0;
  664. ia->cur = 0;
  665.     }
  666.     debug(14, 3) ("ipcacheCycleAddr: %s now at %sn", name,
  667. inet_ntoa(ia->in_addrs[ia->cur]));
  668. }
  670. /*
  671.  * Marks the given address as BAD and calls ipcacheCycleAddr to
  672.  * advance the current pointer to the next OK address.
  673.  */
  674. void
  675. ipcacheMarkBadAddr(const char *name, struct in_addr addr)
  676. {
  677.     ipcache_entry *i;
  678.     ipcache_addrs *ia;
  679.     int k;
  680.     if ((i = ipcache_get(name)) == NULL)
  681. return;
  682.     ia = &i->addrs;
  683.     for (k = 0; k < (int) ia->count; k++) {
  684. if (ia->in_addrs[k].s_addr == addr.s_addr)
  685.     break;
  686.     }
  687.     if (k == (int) ia->count) /* not found */
  688. return;
  689.     if (!ia->bad_mask[k]) {
  690. ia->bad_mask[k] = TRUE;
  691. ia->badcount++;
  692. debug(14, 2) ("ipcacheMarkBadAddr: %s [%s]n", name, inet_ntoa(addr));
  693.     }
  694.     ipcacheCycleAddr(name, ia);
  695. }
  697. void
  698. ipcacheMarkGoodAddr(const char *name, struct in_addr addr)
  699. {
  700.     ipcache_entry *i;
  701.     ipcache_addrs *ia;
  702.     int k;
  703.     if ((i = ipcache_get(name)) == NULL)
  704. return;
  705.     ia = &i->addrs;
  706.     for (k = 0; k < (int) ia->count; k++) {
  707. if (ia->in_addrs[k].s_addr == addr.s_addr)
  708.     break;
  709.     }
  710.     if (k == (int) ia->count) /* not found */
  711. return;
  712.     if (!ia->bad_mask[k]) /* already OK */
  713. return;
  714.     ia->bad_mask[k] = FALSE;
  715.     ia->badcount--;
  716.     debug(14, 2) ("ipcacheMarkGoodAddr: %s [%s]n", name, inet_ntoa(addr));
  717. }
  719. static void
  720. ipcacheFreeEntry(void *data)
  721. {
  722.     ipcache_entry *i = data;
  723.     ip_pending *p;
  724.     while ((p = i->pending_head)) {
  725. i->pending_head = p->next;
  726. memFree(p, MEM_IPCACHE_PENDING);
  727.     }
  728.     safe_free(i->addrs.in_addrs);
  729.     safe_free(i->addrs.bad_mask);
  730.     safe_free(i->name);
  731.     safe_free(i->error_message);
  732.     memFree(i, MEM_IPCACHE_ENTRY);
  733. }
  735. void
  736. ipcacheFreeMemory(void)
  737. {
  738.     hashFreeItems(ip_table, ipcacheFreeEntry);
  739.     hashFreeMemory(ip_table);
  740.     ip_table = NULL;
  741. }
  743. static void
  744. ipcacheChangeKey(ipcache_entry * i)
  745. {
  746.     static int index = 0;
  747.     LOCAL_ARRAY(char, new_key, 256);
  748.     hash_link *table_entry = hash_lookup(ip_table, i->name);
  749.     if (table_entry == NULL) {
  750. debug(14, 0) ("ipcacheChangeKey: Could not find key '%s'n", i->name);
  751. return;
  752.     }
  753.     assert(i == (ipcache_entry *) table_entry);
  754.     hash_remove_link(ip_table, table_entry);
  755.     snprintf(new_key, 256, "%d/%s", ++index, i->name);
  756.     debug(14, 1) ("ipcacheChangeKey: from '%s' to '%s'n", i->name, new_key);
  757.     safe_free(i->name);
  758.     i->name = xstrdup(new_key);
  759.     hash_join(ip_table, (hash_link *) i);
  760. }
  762. /* call during reconfigure phase to clear out all the 
  763.  * pending and dispatched reqeusts that got lost */
  764. void
  765. ipcache_restart(void)
  766. {
  767.     ipcache_entry *this;
  768.     assert(ip_table != NULL);
  769.     hash_first(ip_table);
  770.     while ((this = (ipcache_entry *) hash_next(ip_table))) {
  771. if (this->status == IP_CACHED)
  772.     continue;
  773. if (this->status == IP_NEGATIVE_CACHED)
  774.     continue;
  775.     }
  776.     /* recalculate these while we're at it */
  777.     ipcache_high = (long) (((float) Config.ipcache.size *
  778.     (float) Config.ipcache.high) / (float) 100);
  779.     ipcache_low = (long) (((float) Config.ipcache.size *
  780.     (float) Config.ipcache.low) / (float) 100);
  781. }
  783. #ifdef SQUID_SNMP
  784. /*
  785.  * The function to return the ip cache statistics to via SNMP
  786.  */
  788. variable_list *
  789. snmp_netIpFn(variable_list * Var, snint * ErrP)
  790. {
  791.     variable_list *Answer;
  793.     debug(49, 5) ("snmp_netIpFn: Processing request:n", Var->name[LEN_SQ_NET + 1]);
  794.     snmpDebugOid(5, Var->name, Var->name_length);
  796.     Answer = snmp_var_new(Var->name, Var->name_length);
  797.     *ErrP = SNMP_ERR_NOERROR;
  798.     Answer->val_len = sizeof(snint);
  799.     Answer->val.integer = xmalloc(Answer->val_len);
  800.     Answer->type = SMI_COUNTER32;
  802.     switch (Var->name[LEN_SQ_NET + 1]) {
  803.     case IP_ENT:
  804. *(Answer->val.integer) = memInUse(MEM_IPCACHE_ENTRY);
  805. Answer->type = SMI_GAUGE32;
  806. break;
  807.     case IP_REQ:
  808. *(Answer->val.integer) = IpcacheStats.requests;
  809. break;
  810.     case IP_HITS:
  811. *(Answer->val.integer) = IpcacheStats.hits;
  812. break;
  813.     case IP_PENDHIT:
  814. *(Answer->val.integer) = IpcacheStats.pending_hits;
  815. Answer->type = SMI_GAUGE32;
  816. break;
  817.     case IP_NEGHIT:
  818. *(Answer->val.integer) = IpcacheStats.negative_hits;
  819. break;
  820.     case IP_MISS:
  821. *(Answer->val.integer) = IpcacheStats.misses;
  822. break;
  823.     case IP_GHBN:
  824. *(Answer->val.integer) = IpcacheStats.ghbn_calls;
  825. break;
  826.     case IP_LOC:
  827. *(Answer->val.integer) = IpcacheStats.release_locked;
  828. break;
  829.     default:
  830. *ErrP = SNMP_ERR_NOSUCHNAME;
  831. snmp_var_free(Answer);
  832. return (NULL);
  833.     }
  834.     return Answer;
  835. }
  837. #endif /*SQUID_SNMP */