DW:

 - Simplified ipcache internals in the same manner as the fqdncache code.
   The ipcache structures have been made internal to ipcache.c.  The
   status variable is gone.  IPcache entries are added to the hash table
   only after the lookup completes.  There is no more need for
   ipcacheUnregister. etc.

diff --git a/src/acl.cc b/src/acl.cc
index d8575d19cf9a4f3ea9473ee1c70212c92c0e9219..aa1184d1164cc9e2f095cc2f43a3f1caade6468e 100644 (file)
--- a/src/acl.cc
+++ b/src/acl.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: acl.cc,v 1.223 2000/10/03 22:38:13 wessels Exp $
+ * $Id: acl.cc,v 1.224 2000/10/04 00:24:16 wessels Exp $
  *
  * DEBUG: section 28    Access Control
  * AUTHOR: Duane Wessels
@@ -1686,8 +1686,6 @@ aclCheck(aclCheck_t * checklist)
 void
 aclChecklistFree(aclCheck_t * checklist)
 {
-    if (checklist->state[ACL_DST_IP] == ACL_LOOKUP_PENDING)
-       ipcacheUnregister(checklist->request->host, checklist);
     if (checklist->request)
        requestUnlink(checklist->request);
     checklist->request = NULL;

diff --git a/src/client_side.cc b/src/client_side.cc
index 488e6a2802c6e25bb912cea0357114dfa9d711f4..45edd3a186dde7a4be4d7e87f9bb74fc1b1a5677 100644 (file)
--- a/src/client_side.cc
+++ b/src/client_side.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: client_side.cc,v 1.498 2000/09/14 15:42:00 wessels Exp $
+ * $Id: client_side.cc,v 1.499 2000/10/04 00:24:16 wessels Exp $
  *
  * DEBUG: section 33    Client-side Routines
  * AUTHOR: Duane Wessels
@@ -1989,10 +1989,10 @@ clientProcessRequest2(clientHttpRequest * http)
     }
     /* Release negatively cached IP-cache entries on reload */
     if (r->flags.nocache)
-       ipcacheReleaseInvalid(r->host);
+       ipcacheInvalidate(r->host);
 #if HTTP_VIOLATIONS
     else if (r->flags.nocache_hack)
-       ipcacheReleaseInvalid(r->host);
+       ipcacheInvalidate(r->host);
 #endif
 #if USE_CACHE_DIGESTS
     http->lookup_type = e ? "HIT" : "MISS";
@@ -2031,7 +2031,7 @@ clientProcessRequest2(clientHttpRequest * http)
     if (r->flags.nocache) {
        debug(33, 3) ("clientProcessRequest2: no-cache REFRESH MISS\n");
        http->entry = NULL;
-       ipcacheReleaseInvalid(r->host);
+       ipcacheInvalidate(r->host);
        return LOG_TCP_CLIENT_REFRESH_MISS;
     }
     if (NULL == r->range) {

diff --git a/src/comm.cc b/src/comm.cc
index 6facc49de9582fe1fe5160dd5826177674b3dd9d..9ee9f96a761567f6e3a6d26c149272be9bf18238 100644 (file)
--- a/src/comm.cc
+++ b/src/comm.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: comm.cc,v 1.306 2000/06/27 22:06:00 hno Exp $
+ * $Id: comm.cc,v 1.307 2000/10/04 00:24:17 wessels Exp $
  *
  * DEBUG: section 5     Socket Functions
  * AUTHOR: Harvest Derived
@@ -282,8 +282,6 @@ commConnectFree(int fd, void *data)
 {
     ConnectStateData *cs = data;
     debug(5, 3) ("commConnectFree: FD %d\n", fd);
-    if (cs->locks)
-       ipcacheUnregister(cs->host, cs);
     if (cs->data)
        cbdataUnlock(cs->data);
     safe_free(cs->host);

diff --git a/src/enums.h b/src/enums.h
index 7a13d68024e30e9ed9c1d08c6d2dbd3595f8a60b..59f7f00930bd73dfd580b565acc0afdbc71d1d21 100644 (file)
--- a/src/enums.h
+++ b/src/enums.h
@@ -1,6 +1,6 @@
 
 /*
- * $Id: enums.h,v 1.172 2000/10/03 22:38:13 wessels Exp $
+ * $Id: enums.h,v 1.173 2000/10/04 00:24:17 wessels Exp $
  *
  *
  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
@@ -147,14 +147,6 @@ enum {
     FD_WRITE
 };
 
-enum {
-    IP_CACHED,
-    IP_NEGATIVE_CACHED,
-    IP_PENDING,                        /* waiting to be dispatched */
-    IP_DISPATCHED              /* waiting for reply from dnsserver */
-};
-typedef unsigned int ipcache_status_t;
-
 typedef enum {
     PEER_NONE,
     PEER_SIBLING,
@@ -574,7 +566,6 @@ typedef enum {
     MEM_INTLIST,
     MEM_IOSTATS,
     MEM_IPCACHE_ENTRY,
-    MEM_IPCACHE_PENDING,
     MEM_MD5_DIGEST,
     MEM_MEMOBJECT,
     MEM_MEM_NODE,

diff --git a/src/ipcache.cc b/src/ipcache.cc
index 8a572d05576c655400f18be0541de3048f1c2c04..0272075128e020c9fac5bb3057fd741604a8ed73 100644 (file)
--- a/src/ipcache.cc
+++ b/src/ipcache.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: ipcache.cc,v 1.221 2000/06/27 22:06:02 hno Exp $
+ * $Id: ipcache.cc,v 1.222 2000/10/04 00:24:17 wessels Exp $
  *
  * DEBUG: section 14    IP Cache
  * AUTHOR: Harvest Derived
@@ -35,12 +35,31 @@
 
 #include "squid.h"
 
+typedef struct _ipcache_entry ipcache_entry;
+
+struct _ipcache_entry {
+    /* first two items must be equivalent to hash_link */
+    char *name;
+    ipcache_entry *next;
+    time_t lastref;
+    time_t expires;
+    ipcache_addrs addrs;
+    IPH *handler;
+    void *handlerData;
+    char *error_message;
+    struct timeval request_time;
+    dlink_node lru;
+    unsigned char locks;
+    struct {
+       unsigned int negcached:1;
+    } flags;
+};
+
 static struct {
     int requests;
     int replies;
     int hits;
     int misses;
-    int pending_hits;
     int negative_hits;
     int errors;
     int ghbn_calls;            /* # calls to blocking gethostbyname() */
@@ -58,34 +77,20 @@ static IDNSCB ipcacheHandleReply;
 static IPH dummy_handler;
 static int ipcacheExpiredEntry(ipcache_entry *);
 static int ipcache_testname(void);
-static ipcache_entry *ipcacheAddNew(const char *, const struct hostent *, ipcache_status_t);
 #if USE_DNSSERVERS
 static ipcache_entry *ipcacheParse(const char *buf);
 #else
 static ipcache_entry *ipcacheParse(rfc1035_rr *, int);
 #endif
-static ipcache_entry *ipcache_create(const char *name);
 static ipcache_entry *ipcache_get(const char *);
-static void ipcacheAddHostent(ipcache_entry *, const struct hostent *);
-static void ipcacheAddPending(ipcache_entry *, IPH *, void *);
-static void ipcacheChangeKey(ipcache_entry * i);
 static void ipcacheLockEntry(ipcache_entry *);
 static void ipcacheStatPrint(ipcache_entry *, StoreEntry *);
 static void ipcacheUnlockEntry(ipcache_entry *);
-static void ipcache_call_pending(ipcache_entry *);
-static void ipcache_release(ipcache_entry *);
+static void ipcacheRelease(ipcache_entry *);
 
 static ipcache_addrs static_addrs;
 static hash_table *ip_table = NULL;
 
-static char ipcache_status_char[] =
-{
-    'C',
-    'N',
-    'P',
-    'D'
-};
-
 static long ipcache_low = 180;
 static long ipcache_high = 200;
 
@@ -110,52 +115,29 @@ ipcache_testname(void)
 
 /* removes the given ipcache entry */
 static void
-ipcache_release(ipcache_entry * i)
+ipcacheRelease(ipcache_entry * i)
 {
-    hash_link *table_entry = NULL;
-    if ((table_entry = hash_lookup(ip_table, i->name)) == NULL) {
-       snprintf(tmp_error_buf, ERROR_BUF_SZ, "ipcache_release: key '%s' not found\n", i->name);
-       fatal_dump(tmp_error_buf);
-    }
-    assert(i == (ipcache_entry *) table_entry);
-    if (i->locks) {
-       i->expires = squid_curtime;
-       ipcacheChangeKey(i);
-       IpcacheStats.release_locked++;
-       return;
-    }
-    hash_remove_link(ip_table, table_entry);
+    hash_remove_link(ip_table, (hash_link *) i);
     dlinkDelete(&i->lru, &lru_list);
-    if (i->status == IP_CACHED) {
-       safe_free(i->addrs.in_addrs);
-       safe_free(i->addrs.bad_mask);
-       debug(14, 5) ("ipcache_release: Released IP cached record for '%s'.\n",
-           i->name);
-    }
-    safe_free(i->name);
-    safe_free(i->error_message);
-    memFree(i, MEM_IPCACHE_ENTRY);
-    return;
+    ipcacheFreeEntry(i);
 }
 
 static ipcache_entry *
 ipcache_get(const char *name)
 {
-    assert(ip_table != NULL);
-    return (ipcache_entry *) hash_lookup(ip_table, name);
+    if (ip_table != NULL)
+       return (ipcache_entry *) hash_lookup(ip_table, name);
+    else
+       return NULL;
 }
 
 static int
 ipcacheExpiredEntry(ipcache_entry * i)
 {
-    if (i->status == IP_PENDING)
-       return 0;
-    if (i->status == IP_DISPATCHED)
-       return 0;
     if (i->locks != 0)
        return 0;
     if (i->addrs.count == 0)
-       if (i->status != IP_NEGATIVE_CACHED)
+       if (0 == i->flags.negcached)
            return 1;
     if (i->expires > squid_curtime)
        return 0;
@@ -175,13 +157,9 @@ ipcache_purgelru(void *voidnotused)
            break;
        prev = m->prev;
        i = m->data;
-       if (i->status == IP_PENDING)
-           continue;
-       if (i->status == IP_DISPATCHED)
-           continue;
        if (i->locks != 0)
            continue;
-       ipcache_release(i);
+       ipcacheRelease(i);
        removed++;
     }
     debug(14, 9) ("ipcache_purgelru: removed %d entries\n", removed);
@@ -189,77 +167,46 @@ ipcache_purgelru(void *voidnotused)
 
 /* create blank ipcache_entry */
 static ipcache_entry *
-ipcache_create(const char *name)
+ipcacheCreateEntry(const char *name)
 {
     static ipcache_entry *i;
     i = memAllocate(MEM_IPCACHE_ENTRY);
     i->name = xstrdup(name);
     i->expires = squid_curtime + Config.negativeDnsTtl;
-    hash_join(ip_table, (hash_link *) i);
-    dlinkAdd(i, &i->lru, &lru_list);
     return i;
 }
 
 static void
-ipcacheAddHostent(ipcache_entry * i, const struct hostent *hp)
-{
-    int addr_count = 0;
-    int k;
-    safe_free(i->addrs.in_addrs);
-    safe_free(i->addrs.bad_mask);
-    while ((addr_count < 255) && *(hp->h_addr_list + addr_count))
-       ++addr_count;
-    i->addrs.count = (unsigned char) addr_count;
-    i->addrs.in_addrs = xcalloc(addr_count, sizeof(struct in_addr));
-    i->addrs.bad_mask = xcalloc(addr_count, sizeof(unsigned char));
-    i->addrs.badcount = 0;
-    for (k = 0; k < addr_count; k++)
-       xmemcpy(&i->addrs.in_addrs[k].s_addr,
-           *(hp->h_addr_list + k),
-           hp->h_length);
-}
-
-static ipcache_entry *
-ipcacheAddNew(const char *name, const struct hostent *hp, ipcache_status_t status)
+ipcacheAddEntry(ipcache_entry * i)
 {
-    ipcache_entry *i;
-    if (ipcache_get(name))
-       fatal_dump("ipcacheAddNew: somebody adding a duplicate!");
-    debug(14, 10) ("ipcacheAddNew: Adding '%s', status=%c\n",
-       name,
-       ipcache_status_char[status]);
-    i = ipcache_create(name);
-    if (hp)
-       ipcacheAddHostent(i, hp);
-    i->status = status;
+    hash_link *e = hash_lookup(ip_table, i->name);
+    if (NULL != e) {
+       /* avoid colission */
+       ipcache_entry *q = (ipcache_entry *) e;
+       ipcacheRelease(q);
+    }
+    hash_join(ip_table, (hash_link *) i);
+    dlinkAdd(i, &i->lru, &lru_list);
     i->lastref = squid_curtime;
-    return i;
 }
 
 /* walks down the pending list, calling handlers */
 static void
-ipcache_call_pending(ipcache_entry * i)
+ipcacheCallback(ipcache_entry * i)
 {
-    ip_pending *p = NULL;
-    int nhandler = 0;
+    IPH *handler = i->handler;
+    void *handlerData = i->handlerData;
     i->lastref = squid_curtime;
     ipcacheLockEntry(i);
-    while (i->pending_head != NULL) {
-       p = i->pending_head;
-       i->pending_head = p->next;
-       if (p->handler) {
-           nhandler++;
-           dns_error_message = i->error_message;
-           if (cbdataValid(p->handlerData)) {
-               p->handler(i->status == IP_CACHED ? &i->addrs : NULL,
-                   p->handlerData);
-           }
-           cbdataUnlock(p->handlerData);
-       }
-       memFree(p, MEM_IPCACHE_PENDING);
+    if (NULL == handler)
+       return;
+    i->handler = NULL;
+    i->handlerData = NULL;
+    if (cbdataValid(handlerData)) {
+       dns_error_message = i->error_message;
+       handler(i->flags.negcached ? &i->addrs : NULL, handlerData);
     }
-    i->pending_head = NULL;    /* nuke list */
-    debug(14, 10) ("ipcache_call_pending: Called %d handlers.\n", nhandler);
+    cbdataUnlock(i->handlerData);
     ipcacheUnlockEntry(i);
 }
 
@@ -277,7 +224,7 @@ ipcacheParse(const char *inbuf)
     char A[32][16];
     memset(&i, '\0', sizeof(i));
     i.expires = squid_curtime;
-    i.status = IP_NEGATIVE_CACHED;
+    i.flags.negcached = 1;
     if (inbuf == NULL) {
        debug(14, 1) ("ipcacheParse: Got <NULL> reply\n");
        i.error_message = xstrdup("Internal Squid Error");
@@ -306,7 +253,7 @@ ipcacheParse(const char *inbuf)
        debug(14, 1) ("ipcacheParse: Got <NULL>, expecting TTL\n");
        return &i;
     }
-    i.status = IP_CACHED;
+    i.flags.negcached = 0;
     ttl = atoi(token);
     if (ttl > 0)
        i.expires = squid_curtime + ttl;
@@ -342,7 +289,7 @@ ipcacheParse(rfc1035_rr * answers, int nr)
     int na = 0;
     memset(&i, '\0', sizeof(i));
     i.expires = squid_curtime + Config.negativeDnsTtl;
-    i.status = IP_NEGATIVE_CACHED;
+    i.flags.negcached = 1;
     if (nr < 0) {
        debug(14, 3) ("ipcacheParse: Lookup failed (error %d)\n",
            rfc1035_errno);
@@ -368,7 +315,7 @@ ipcacheParse(rfc1035_rr * answers, int nr)
        i.error_message = xstrdup("No Address records");
        return &i;
     }
-    i.status = IP_CACHED;
+    i.flags.negcached = 0;
     i.addrs.in_addrs = xcalloc(na, sizeof(struct in_addr));
     i.addrs.bad_mask = xcalloc(na, sizeof(unsigned char));
     i.addrs.count = (unsigned char) na;
@@ -401,37 +348,23 @@ ipcacheHandleReply(void *data, rfc1035_rr * answers, int na)
     generic_cbdata *c = data;
     ipcache_entry *i = c->data;
     ipcache_entry *x = NULL;
-    assert(i->status == IP_DISPATCHED);
-    assert(i->locks);
     cbdataFree(c);
     c = NULL;
     n = ++IpcacheStats.replies;
-    statHistCount(&statCounter.dns.svc_time, tvSubMsec(i->request_time, current_time));
+    statHistCount(&statCounter.dns.svc_time,
+       tvSubMsec(i->request_time, current_time));
 #if USE_DNSSERVERS
     x = ipcacheParse(reply);
 #else
     x = ipcacheParse(answers, na);
 #endif
     assert(x);
-    i->status = x->status;
     i->addrs = x->addrs;
     i->error_message = x->error_message;
     i->expires = x->expires;
-    ipcache_call_pending(i);
-    ipcacheUnlockEntry(i);     /* unlock from IP_DISPATCHED */
-}
-
-static void
-ipcacheAddPending(ipcache_entry * i, IPH * handler, void *handlerData)
-{
-    ip_pending *pending = memAllocate(MEM_IPCACHE_PENDING);
-    ip_pending **I = NULL;
-    i->lastref = squid_curtime;
-    pending->handler = handler;
-    pending->handlerData = handlerData;
-    cbdataLock(handlerData);
-    for (I = &(i->pending_head); *I; I = &((*I)->next));
-    *I = pending;
+    i->flags = x->flags;
+    ipcacheAddEntry(i);
+    ipcacheCallback(i);
 }
 
 void
@@ -452,48 +385,37 @@ ipcache_nbgethostbyname(const char *name, IPH * handler, void *handlerData)
        handler(addrs, handlerData);
        return;
     }
-    if ((i = ipcache_get(name))) {
-       if (ipcacheExpiredEntry(i)) {
-           ipcache_release(i);
-           i = NULL;
-       }
-    }
-    if (i == NULL) {
-       /* MISS: No entry, create the new one */
-       debug(14, 5) ("ipcache_nbgethostbyname: MISS for '%s'\n", name);
-       IpcacheStats.misses++;
-       i = ipcacheAddNew(name, NULL, IP_PENDING);
-       ipcacheAddPending(i, handler, handlerData);
-       i->request_time = current_time;
-    } else if (i->status == IP_CACHED || i->status == IP_NEGATIVE_CACHED) {
-       /* HIT */
+    i = ipcache_get(name);
+    if (NULL == i) {
+       /* miss */
+       (void) 0;
+    } else if (ipcacheExpiredEntry(i)) {
+       /* hit, but expired -- bummer */
+       ipcacheRelease(i);
+       i = NULL;
+    } else {
+       /* hit */
        debug(14, 4) ("ipcache_nbgethostbyname: HIT for '%s'\n", name);
-       if (i->status == IP_NEGATIVE_CACHED)
+       if (i->flags.negcached)
            IpcacheStats.negative_hits++;
        else
            IpcacheStats.hits++;
-       ipcacheAddPending(i, handler, handlerData);
-       ipcache_call_pending(i);
-       return;
-    } else if (i->status == IP_PENDING || i->status == IP_DISPATCHED) {
-       debug(14, 4) ("ipcache_nbgethostbyname: PENDING for '%s'\n", name);
-       IpcacheStats.pending_hits++;
-       ipcacheAddPending(i, handler, handlerData);
-       if (squid_curtime - i->expires > 600) {
-           debug(14, 0) ("ipcache_nbgethostbyname: '%s' PENDING for %d seconds, aborting\n", name, (int) (squid_curtime + Config.negativeDnsTtl - i->expires));
-           ipcacheChangeKey(i);
-           ipcache_call_pending(i);
-       }
+       i->handler = handler;
+       i->handlerData = handlerData;
+       cbdataLock(handlerData);
+       ipcacheCallback(i);
        return;
-    } else {
-       fatal_dump("ipcache_nbgethostbyname: BAD ipcache_entry status");
     }
-    /* for HIT, PENDING, DISPATCHED we've returned.  For MISS we submit */
+    debug(14, 5) ("ipcache_nbgethostbyname: MISS for '%s'\n", name);
+    IpcacheStats.misses++;
+    i = ipcacheCreateEntry(name);
+    i->handler = handler;
+    i->handlerData = handlerData;
+    cbdataLock(handlerData);
+    i->request_time = current_time;
     c = xcalloc(1, sizeof(*c));
     c->data = i;
     cbdataAdd(c, cbdataXfree, 0);
-    i->status = IP_DISPATCHED;
-    ipcacheLockEntry(i);
 #if USE_DNSSERVERS
     dnsSubmit(i->name, ipcacheHandleReply, c);
 #else
@@ -529,28 +451,7 @@ ipcache_init(void)
     cachemgrRegister("ipcache",
        "IP Cache Stats and Contents",
        stat_ipcache_get, 0, 1);
-}
-
-int
-ipcacheUnregister(const char *name, void *data)
-{
-    ipcache_entry *i = NULL;
-    ip_pending *p = NULL;
-    int n = 0;
-    debug(14, 3) ("ipcacheUnregister: name '%s'\n", name);
-    if ((i = ipcache_get(name)) == NULL)
-       return 0;
-    if (i->status == IP_PENDING || i->status == IP_DISPATCHED) {
-       for (p = i->pending_head; p; p = p->next) {
-           if (p->handlerData != data)
-               continue;
-           p->handler = NULL;
-           n++;
-       }
-    }
-    assert(n > 0);
-    debug(14, 3) ("ipcacheUnregister: unregistered %d handlers\n", n);
-    return n;
+    memDataInit(MEM_IPCACHE_ENTRY, "ipcache_entry", sizeof(ipcache_entry), 0);
 }
 
 const ipcache_addrs *
@@ -558,28 +459,23 @@ ipcache_gethostbyname(const char *name, int flags)
 {
     ipcache_entry *i = NULL;
     ipcache_addrs *addrs;
-    if (!name)
-       fatal_dump("ipcache_gethostbyname: NULL name");
+    assert(name);
     debug(14, 3) ("ipcache_gethostbyname: '%s', flags=%x\n", name, flags);
     IpcacheStats.requests++;
-    if ((i = ipcache_get(name))) {
-       if (ipcacheExpiredEntry(i)) {
-           ipcache_release(i);
-           i = NULL;
-       }
-    }
-    if (i) {
-       if (i->status == IP_NEGATIVE_CACHED) {
-           IpcacheStats.negative_hits++;
-           dns_error_message = i->error_message;
-           return NULL;
-       } else if (i->addrs.count == 0) {
-           (void) 0;
-       } else {
-           IpcacheStats.hits++;
-           i->lastref = squid_curtime;
-           return &i->addrs;
-       }
+    i = ipcache_get(name);
+    if (NULL == i) {
+       (void) 0;
+    } else if (ipcacheExpiredEntry(i)) {
+       ipcacheRelease(i);
+       i = NULL;
+    } else if (i->flags.negcached) {
+       IpcacheStats.negative_hits++;
+       dns_error_message = i->error_message;
+       return NULL;
+    } else {
+       IpcacheStats.hits++;
+       i->lastref = squid_curtime;
+       return &i->addrs;
     }
     if ((addrs = ipcacheCheckNumeric(name)))
        return addrs;
@@ -593,10 +489,9 @@ static void
 ipcacheStatPrint(ipcache_entry * i, StoreEntry * sentry)
 {
     int k;
-    storeAppendPrintf(sentry, " %-32.32s  %c%c %6d %6d %2d(%2d)",
+    storeAppendPrintf(sentry, " %-32.32s  %c %6d %6d %2d(%2d)",
        i->name,
-       ipcache_status_char[i->status],
-       i->locks ? 'L' : ' ',
+       i->flags.negcached ? 'N' : ' ',
        (int) (squid_curtime - i->lastref),
        (int) (i->expires - squid_curtime),
        (int) i->addrs.count,
@@ -621,8 +516,6 @@ stat_ipcache_get(StoreEntry * sentry)
        IpcacheStats.requests);
     storeAppendPrintf(sentry, "IPcache Hits: %d\n",
        IpcacheStats.hits);
-    storeAppendPrintf(sentry, "IPcache Pending Hits: %d\n",
-       IpcacheStats.pending_hits);
     storeAppendPrintf(sentry, "IPcache Negative Hits: %d\n",
        IpcacheStats.negative_hits);
     storeAppendPrintf(sentry, "IPcache Misses: %d\n",
@@ -633,9 +526,9 @@ stat_ipcache_get(StoreEntry * sentry)
        IpcacheStats.release_locked);
     storeAppendPrintf(sentry, "\n\n");
     storeAppendPrintf(sentry, "IP Cache Contents:\n\n");
-    storeAppendPrintf(sentry, " %-29.29s %5s %6s %6s %1s\n",
+    storeAppendPrintf(sentry, " %-29.29s %3s %6s %6s %1s\n",
        "Hostname",
-       "Flags",
+       "Flg",
        "lstref",
        "TTL",
        "N");
@@ -649,25 +542,6 @@ dummy_handler(const ipcache_addrs * addrsnotused, void *datanotused)
     return;
 }
 
-void
-ipcacheReleaseInvalid(const char *name)
-{
-    ipcache_entry *i;
-    if (NULL == name) {
-       debug(14, 1) ("ipcacheReleaseInvalid: NULL name\n");
-       return;
-    }
-    if (0 == strlen(name)) {
-       debug(14, 1) ("ipcacheReleaseInvalid: Empty name\n");
-       return;
-    }
-    if ((i = ipcache_get(name)) == NULL)
-       return;
-    if (i->status != IP_NEGATIVE_CACHED)
-       return;
-    ipcache_release(i);
-}
-
 void
 ipcacheInvalidate(const char *name)
 {
@@ -675,9 +549,10 @@ ipcacheInvalidate(const char *name)
     if ((i = ipcache_get(name)) == NULL)
        return;
     i->expires = squid_curtime;
-    /* NOTE, don't call ipcache_release here becuase we might be here due
-     * to a thread started from ipcache_call_pending() which will cause a
-     * FMR */
+    /*
+     * NOTE, don't call ipcacheRelease here becuase we might be here due
+     * to a thread started from a callback.
+     */
 }
 
 ipcache_addrs *
@@ -710,7 +585,7 @@ ipcacheUnlockEntry(ipcache_entry * i)
     assert(i->locks > 0);
     i->locks--;
     if (ipcacheExpiredEntry(i))
-       ipcache_release(i);
+       ipcacheRelease(i);
 }
 
 void
@@ -722,7 +597,7 @@ ipcacheCycleAddr(const char *name, ipcache_addrs * ia)
     if (NULL == ia) {
        if ((i = ipcache_get(name)) == NULL)
            return;
-       if (i->status != IP_CACHED)
+       if (i->flags.negcached)
            return;
        ia = &i->addrs;
     }
@@ -798,11 +673,6 @@ static void
 ipcacheFreeEntry(void *data)
 {
     ipcache_entry *i = data;
-    ip_pending *p;
-    while ((p = i->pending_head)) {
-       i->pending_head = p->next;
-       memFree(p, MEM_IPCACHE_PENDING);
-    }
     safe_free(i->addrs.in_addrs);
     safe_free(i->addrs.bad_mask);
     safe_free(i->name);
@@ -818,25 +688,6 @@ ipcacheFreeMemory(void)
     ip_table = NULL;
 }
 
-static void
-ipcacheChangeKey(ipcache_entry * i)
-{
-    static int index = 0;
-    LOCAL_ARRAY(char, new_key, 256);
-    hash_link *table_entry = hash_lookup(ip_table, i->name);
-    if (table_entry == NULL) {
-       debug(14, 0) ("ipcacheChangeKey: Could not find key '%s'\n", i->name);
-       return;
-    }
-    assert(i == (ipcache_entry *) table_entry);
-    hash_remove_link(ip_table, table_entry);
-    snprintf(new_key, 256, "%d/%s", ++index, i->name);
-    debug(14, 1) ("ipcacheChangeKey: from '%s' to '%s'\n", i->name, new_key);
-    safe_free(i->name);
-    i->name = xstrdup(new_key);
-    hash_join(ip_table, (hash_link *) i);
-}
-
 /* Recalculate IP cache size upon reconfigure */
 void
 ipcache_restart(void)
@@ -877,7 +728,7 @@ snmp_netIpFn(variable_list * Var, snint * ErrP)
        break;
     case IP_PENDHIT:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
-           IpcacheStats.pending_hits,
+           0,
            SMI_GAUGE32);
        break;
     case IP_NEGHIT:

diff --git a/src/mem.cc b/src/mem.cc
index e0f29bfcdda6956629965d27532182ae3a4e4a91..def17eb9f3e6cf32c1c05050408817ced5686d82 100644 (file)
--- a/src/mem.cc
+++ b/src/mem.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: mem.cc,v 1.47 2000/10/03 22:38:14 wessels Exp $
+ * $Id: mem.cc,v 1.48 2000/10/04 00:24:17 wessels Exp $
  *
  * DEBUG: section 13    High Level Memory Pool Management
  * AUTHOR: Harvest Derived
@@ -245,8 +245,6 @@ memInit(void)
     memDataInit(MEM_ICP_PING_DATA, "ping_data", sizeof(ping_data), 0);
     memDataInit(MEM_INTLIST, "intlist", sizeof(intlist), 0);
     memDataInit(MEM_IOSTATS, "iostats", sizeof(iostats), 0);
-    memDataInit(MEM_IPCACHE_PENDING, "ip_pending", sizeof(ip_pending), 0);
-    memDataInit(MEM_IPCACHE_ENTRY, "ipcache_entry", sizeof(ipcache_entry), 0);
     memDataInit(MEM_MEMOBJECT, "MemObject", sizeof(MemObject),
        Squid_MaxFD >> 3);
     memDataInit(MEM_MEM_NODE, "mem_node", sizeof(mem_node), 0);

diff --git a/src/protos.h b/src/protos.h
index 5f90aec00fccb868d48428dd8bf1a0ad538136d1..4639ffcb01505e48f64487a5596634ba996010ac 100644 (file)
--- a/src/protos.h
+++ b/src/protos.h
@@ -1,6 +1,6 @@
 
 /*
- * $Id: protos.h,v 1.377 2000/10/03 22:38:14 wessels Exp $
+ * $Id: protos.h,v 1.378 2000/10/04 00:24:17 wessels Exp $
  *
  *
  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
@@ -555,7 +555,6 @@ extern void ipcacheMarkGoodAddr(const char *name, struct in_addr);
 extern void ipcacheFreeMemory(void);
 extern ipcache_addrs *ipcacheCheckNumeric(const char *name);
 extern void ipcache_restart(void);
-extern int ipcacheUnregister(const char *name, void *data);
 
 /* MemBuf */
 /* init with specific sizes */

diff --git a/src/structs.h b/src/structs.h
index 89dc2ad8000897285e3c2428409dd088cbe548f6..5e870642b935fc056a3511b1f50b00b2fb5e18f7 100644 (file)
--- a/src/structs.h
+++ b/src/structs.h
@@ -1,6 +1,6 @@
 
 /*
- * $Id: structs.h,v 1.351 2000/10/03 22:38:15 wessels Exp $
+ * $Id: structs.h,v 1.352 2000/10/04 00:24:17 wessels Exp $
  *
  *
  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
@@ -924,27 +924,6 @@ struct _ipcache_addrs {
     unsigned char badcount;
 };
 
-struct _ip_pending {
-    IPH *handler;
-    void *handlerData;
-    ip_pending *next;
-};
-
-struct _ipcache_entry {
-    /* first two items must be equivalent to hash_link */
-    char *name;
-    ipcache_entry *next;
-    time_t lastref;
-    time_t expires;
-    ipcache_addrs addrs;
-    ip_pending *pending_head;
-    char *error_message;
-    struct timeval request_time;
-    dlink_node lru;
-    u_char locks;
-    ipcache_status_t status:3;
-};
-
 struct _domain_ping {
     char *domain;
     int do_ping;               /* boolean */

diff --git a/src/typedefs.h b/src/typedefs.h
index 6a2b59c71844ff8c3186a96c29f29b15874c037a..18e28c5dfacaece1d4ef50c4611b31e210212a57 100644 (file)
--- a/src/typedefs.h
+++ b/src/typedefs.h
@@ -1,6 +1,6 @@
 
 /*
- * $Id: typedefs.h,v 1.108 2000/10/03 22:38:15 wessels Exp $
+ * $Id: typedefs.h,v 1.109 2000/10/04 00:24:18 wessels Exp $
  *
  *
  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
@@ -106,8 +106,6 @@ typedef struct _icpUdpData icpUdpData;
 typedef struct _clientHttpRequest clientHttpRequest;
 typedef struct _ConnStateData ConnStateData;
 typedef struct _ipcache_addrs ipcache_addrs;
-typedef struct _ipcache_entry ipcache_entry;
-typedef struct _ip_pending ip_pending;
 typedef struct _domain_ping domain_ping;
 typedef struct _domain_type domain_type;
 typedef struct _DynPool DynPool;