- Removed FD from FQDN callbacks

- Fixed fqdncacheUnregister() from aclChecklistFree()
  due to stupid use of static ipcache_addr memory.
- split aclCheckCallback into aclCheckCallback and
  aclChecklistFree.
- split aclNBCheck into aclNBCheck and aclChecklistCreate.
- free aclCheck_t from icpStateFree
- Added peerSelectFree()

diff --git a/src/acl.cc b/src/acl.cc
index 6026939364f622430a94303366955fef330e6425..8c1f1fbe94faafadc087c9b9c0159b8b42f35198 100644 (file)
--- a/src/acl.cc
+++ b/src/acl.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: acl.cc,v 1.93 1997/04/30 22:46:23 wessels Exp $
+ * $Id: acl.cc,v 1.94 1997/05/02 04:28:32 wessels Exp $
  *
  * DEBUG: section 28    Access Control
  * AUTHOR: Duane Wessels
@@ -61,8 +61,8 @@ static void aclCheck _PARAMS((aclCheck_t * checklist));
 
 static void aclCheckCallback _PARAMS((aclCheck_t * checklist, int answer));
 static IPH aclLookupDstIPDone;
-static void aclLookupSrcFQDNDone _PARAMS((int fd, const char *fqdn, void *data));
-static void aclLookupDstFQDNDone _PARAMS((int fd, const char *fqdn, void *data));
+static FQDNH aclLookupSrcFQDNDone;
+static FQDNH aclLookupDstFQDNDone;
 
 
 #if defined(USE_SPLAY_TREE)
@@ -1168,6 +1168,7 @@ aclCheck(aclCheck_t * checklist)
     int allow = 0;
     const struct _acl_access *A;
     int match;
+    ipcache_addrs *ia;
     while ((A = checklist->access_list)) {
        debug(28, 3, "aclCheck: checking '%s'\n", A->cfgline);
        allow = A->allow;
@@ -1182,19 +1183,18 @@ aclCheck(aclCheck_t * checklist)
        } else if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_NEEDED) {
            checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_PENDING;
            fqdncache_nbgethostbyaddr(checklist->src_addr,
-               -1,
                aclLookupSrcFQDNDone,
                checklist);
            return;
        } else if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_NEEDED) {
-           checklist->dst_ia = ipcacheCheckNumeric(checklist->request->host);
-           if (checklist->dst_ia == NULL) {
+           ia = ipcacheCheckNumeric(checklist->request->host);
+           if (ia == NULL) {
                checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_DONE;
                return;
            }
+           checklist->dst_addr = ia->in_addrs[0];
            checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_PENDING;
-           fqdncache_nbgethostbyaddr(checklist->dst_ia->in_addrs[0],
-               -1,
+           fqdncache_nbgethostbyaddr(checklist->dst_addr,
                aclLookupDstFQDNDone,
                checklist);
            return;
@@ -1210,22 +1210,29 @@ aclCheck(aclCheck_t * checklist)
     aclCheckCallback(checklist, !allow);
 }
 
-
-static void
-aclCheckCallback(aclCheck_t * checklist, int answer)
+void
+aclChecklistFree(aclCheck_t * checklist)
 {
-    debug(28, 3, "aclCheckCallback: answer=%d\n", answer);
-    checklist->callback(answer, checklist->callback_data);
     if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_PENDING)
        fqdncacheUnregister(checklist->src_addr, checklist);
     if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_PENDING)
-       fqdncacheUnregister(checklist->dst_ia->in_addrs[0], checklist);
+       fqdncacheUnregister(checklist->dst_addr, checklist);
     if (checklist->state[ACL_DST_IP] == ACL_LOOKUP_PENDING)
        ipcacheUnregister(checklist->request->host, checklist);
     requestUnlink(checklist->request);
     xfree(checklist);
 }
 
+static void
+aclCheckCallback(aclCheck_t * checklist, int answer)
+{
+    debug(28, 3, "aclCheckCallback: answer=%d\n", answer);
+    checklist->callback(answer, checklist->callback_data);
+    checklist->callback = NULL;
+    checklist->callback_data = NULL;
+    aclChecklistFree(checklist);
+}
+
 static void
 aclLookupDstIPDone(int fd, const ipcache_addrs * ia, void *data)
 {
@@ -1235,7 +1242,7 @@ aclLookupDstIPDone(int fd, const ipcache_addrs * ia, void *data)
 }
 
 static void
-aclLookupSrcFQDNDone(int fd, const char *fqdn, void *data)
+aclLookupSrcFQDNDone(const char *fqdn, void *data)
 {
     aclCheck_t *checklist = data;
     checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_DONE;
@@ -1243,21 +1250,19 @@ aclLookupSrcFQDNDone(int fd, const char *fqdn, void *data)
 }
 
 static void
-aclLookupDstFQDNDone(int fd, const char *fqdn, void *data)
+aclLookupDstFQDNDone(const char *fqdn, void *data)
 {
     aclCheck_t *checklist = data;
     checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_DONE;
     aclCheck(checklist);
 }
 
-void
-aclNBCheck(const struct _acl_access *A,
+aclCheck_t *
+aclChecklistCreate(const struct _acl_access *A,
     request_t * request,
     struct in_addr src_addr,
     char *user_agent,
-    char *ident,
-    PF callback,
-    void *callback_data)
+    char *ident)
 {
     aclCheck_t *checklist = xcalloc(1, sizeof(aclCheck_t));;
     checklist->access_list = A;
@@ -1267,6 +1272,12 @@ aclNBCheck(const struct _acl_access *A,
        xstrncpy(checklist->browser, user_agent, BROWSERNAMELEN);
     if (ident)
        xstrncpy(checklist->ident, ident, ICP_IDENT_SZ);
+    return checklist;
+}
+
+void
+aclNBCheck(aclCheck_t * checklist, PF callback, void *callback_data)
+{
     checklist->callback = callback;
     checklist->callback_data = callback_data;
     aclCheck(checklist);

diff --git a/src/client_side.cc b/src/client_side.cc
index 89c6507199a0e8ccf2322e6bc3219622ad6158c2..12dd8f1f5b5cc803e86c2f0d8dd2dd99d76f0404 100644 (file)
--- a/src/client_side.cc
+++ b/src/client_side.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: client_side.cc,v 1.99 1997/04/30 18:30:44 wessels Exp $
+ * $Id: client_side.cc,v 1.100 1997/05/02 04:28:34 wessels Exp $
  *
  * DEBUG: section 33    Client-side Routines
  * AUTHOR: Duane Wessels
@@ -120,14 +120,13 @@ clientAccessCheck(icpStateData * icpState, PF handler)
        clientAccessCheckDone(0, icpState);
        return;
     }
-    browser = mime_get_header(icpState->request_hdr, "User-Agent"),
-       aclNBCheck(Config.accessList.HTTP,
+    browser = mime_get_header(icpState->request_hdr, "User-Agent");
+    icpState->acl_checklist = aclChecklistCreate(Config.accessList.HTTP,
        icpState->request,
        icpState->peer.sin_addr,
        browser,
-       icpState->ident.ident,
-       handler,
-       icpState);
+       icpState->ident.ident);
+    aclNBCheck(icpState->acl_checklist, handler, icpState);
 }
 
 void
@@ -138,6 +137,7 @@ clientAccessCheckDone(int answer, void *data)
     char *buf = NULL;
     char *redirectUrl = NULL;
     debug(33, 5, "clientAccessCheckDone: '%s' answer=%d\n", icpState->url, answer);
+    icpState->acl_checklist = NULL;
     if (answer) {
        urlCanonical(icpState->request, icpState->url);
        if (icpState->redirect_state != REDIRECT_NONE)

diff --git a/src/fqdncache.cc b/src/fqdncache.cc
index 341c3b95fc9dc2bc5b85062898fc1858ebb815d8..66d9a7c192c83763cd4bd1bafb17d742531382a9 100644 (file)
--- a/src/fqdncache.cc
+++ b/src/fqdncache.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: fqdncache.cc,v 1.51 1997/04/30 20:06:26 wessels Exp $
+ * $Id: fqdncache.cc,v 1.52 1997/05/02 04:28:34 wessels Exp $
  *
  * DEBUG: section 35    FQDN Cache
  * AUTHOR: Harvest Derived
@@ -113,7 +113,6 @@
 #define FQDN_HIGH_WATER      95
 
 struct _fqdn_pending {
-    int fd;
     FQDNH *handler;
     void *handlerData;
     struct _fqdn_pending *next;
@@ -149,9 +148,9 @@ static void fqdncache_call_pending _PARAMS((fqdncache_entry *));
 static void fqdncacheAddHostent _PARAMS((fqdncache_entry *, const struct hostent *));
 static int fqdncacheHasPending _PARAMS((const fqdncache_entry *));
 static fqdncache_entry *fqdncache_get _PARAMS((const char *));
-static void dummy_handler _PARAMS((int, const char *, void *));
+static FQDNH dummy_handler;
 static int fqdncacheExpiredEntry _PARAMS((const fqdncache_entry *));
-static void fqdncacheAddPending _PARAMS((fqdncache_entry *, int fd, FQDNH *, void *));
+static void fqdncacheAddPending _PARAMS((fqdncache_entry *, FQDNH *, void *));
 static void fqdncacheEnqueue _PARAMS((fqdncache_entry *));
 static void *fqdncacheDequeue _PARAMS((void));
 static void fqdncache_dnsDispatch _PARAMS((dnsserver_t *, fqdncache_entry *));
@@ -223,6 +222,8 @@ fqdncache_release(fqdncache_entry * f)
        debug(35, 1, "fqdncache_release: Someone called on a DISPATCHED entry\n");
        return;
     }
+    if (f->pending_head)
+       fatal_dump("fqdncache_release: still have pending clients");
     if (hash_remove_link(fqdn_table, table_entry)) {
        debug(35, 0, "fqdncache_release: hash_remove_link() failed for '%s'\n",
            f->name);
@@ -434,8 +435,7 @@ fqdncache_call_pending(fqdncache_entry * f)
        if (p->handler) {
            nhandler++;
            dns_error_message = f->error_message;
-           p->handler(p->fd,
-               (f->status == FQDN_CACHED) ? f->names[0] : NULL,
+           p->handler((f->status == FQDN_CACHED) ? f->names[0] : NULL,
                p->handlerData);
        }
        safe_free(p);
@@ -599,12 +599,11 @@ fqdncache_dnsHandleRead(int fd, void *data)
 }
 
 static void
-fqdncacheAddPending(fqdncache_entry * f, int fd, FQDNH * handler, void *handlerData)
+fqdncacheAddPending(fqdncache_entry * f, FQDNH * handler, void *handlerData)
 {
     struct _fqdn_pending *pending = xcalloc(1, sizeof(struct _fqdn_pending));
     struct _fqdn_pending **I = NULL;
     f->lastref = squid_curtime;
-    pending->fd = fd;
     pending->handler = handler;
     pending->handlerData = handlerData;
     for (I = &(f->pending_head); *I; I = &((*I)->next));
@@ -614,7 +613,7 @@ fqdncacheAddPending(fqdncache_entry * f, int fd, FQDNH * handler, void *handlerD
 }
 
 void
-fqdncache_nbgethostbyaddr(struct in_addr addr, int fd, FQDNH * handler, void *handlerData)
+fqdncache_nbgethostbyaddr(struct in_addr addr, FQDNH * handler, void *handlerData)
 {
     fqdncache_entry *f = NULL;
     dnsserver_t *dnsData = NULL;
@@ -623,12 +622,12 @@ fqdncache_nbgethostbyaddr(struct in_addr addr, int fd, FQDNH * handler, void *ha
     if (!handler)
        fatal_dump("fqdncache_nbgethostbyaddr: NULL handler");
 
-    debug(35, 4, "fqdncache_nbgethostbyaddr: FD %d: Name '%s'.\n", fd, name);
+    debug(35, 4, "fqdncache_nbgethostbyaddr: Name '%s'.\n", name);
     FqdncacheStats.requests++;
 
     if (name == NULL || name[0] == '\0') {
        debug(35, 4, "fqdncache_nbgethostbyaddr: Invalid name!\n");
-       handler(fd, NULL, handlerData);
+       handler(NULL, handlerData);
        return;
     }
     if ((f = fqdncache_get(name))) {
@@ -642,7 +641,7 @@ fqdncache_nbgethostbyaddr(struct in_addr addr, int fd, FQDNH * handler, void *ha
        debug(35, 5, "fqdncache_nbgethostbyaddr: MISS for '%s'\n", name);
        FqdncacheStats.misses++;
        f = fqdncacheAddNew(name, NULL, FQDN_PENDING);
-       fqdncacheAddPending(f, fd, handler, handlerData);
+       fqdncacheAddPending(f, handler, handlerData);
     } else if (f->status == FQDN_CACHED || f->status == FQDN_NEGATIVE_CACHED) {
        /* HIT */
        debug(35, 4, "fqdncache_nbgethostbyaddr: HIT for '%s'\n", name);
@@ -650,13 +649,13 @@ fqdncache_nbgethostbyaddr(struct in_addr addr, int fd, FQDNH * handler, void *ha
            FqdncacheStats.negative_hits++;
        else
            FqdncacheStats.hits++;
-       fqdncacheAddPending(f, fd, handler, handlerData);
+       fqdncacheAddPending(f, handler, handlerData);
        fqdncache_call_pending(f);
        return;
     } else if (f->status == FQDN_PENDING || f->status == FQDN_DISPATCHED) {
        debug(35, 4, "fqdncache_nbgethostbyaddr: PENDING for '%s'\n", name);
        FqdncacheStats.pending_hits++;
-       fqdncacheAddPending(f, fd, handler, handlerData);
+       fqdncacheAddPending(f, handler, handlerData);
        if (squid_curtime - f->expires > 600) {
            debug(14, 0, "fqdncache_nbgethostbyname: '%s' PENDING for %d seconds, aborting\n", name, squid_curtime + Config.negativeDnsTtl - f->expires);
            fqdncacheChangeKey(f);
@@ -754,7 +753,6 @@ fqdncacheUnregister(struct in_addr addr, void *data)
            if (p->handlerData != data)
                continue;
            p->handler = NULL;
-           p->fd = -1;
            n++;
        }
     }
@@ -830,7 +828,7 @@ fqdncache_gethostbyaddr(struct in_addr addr, int flags)
        }
     }
     if (flags & FQDN_LOOKUP_IF_MISS)
-       fqdncache_nbgethostbyaddr(addr, -1, dummy_handler, NULL);
+       fqdncache_nbgethostbyaddr(addr, dummy_handler, NULL);
     return NULL;
 }
 
@@ -884,7 +882,7 @@ fqdnStats(StoreEntry * sentry)
 }
 
 static void
-dummy_handler(int u1, const char *u2, void *u3)
+dummy_handler(const char *u2, void *u3)
 {
     return;
 }

diff --git a/src/peer_select.cc b/src/peer_select.cc
index 0eb6f4311989a50e9847b9a9aeea84574895b396..91363250b2610aee4294c09e345bfb260a714fbb 100644 (file)
--- a/src/peer_select.cc
+++ b/src/peer_select.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: peer_select.cc,v 1.11 1997/04/30 18:30:58 wessels Exp $
+ * $Id: peer_select.cc,v 1.12 1997/05/02 04:28:37 wessels Exp $
  *
  * DEBUG: section 44    Peer Selection Algorithm
  * AUTHOR: Duane Wessels
@@ -63,6 +63,18 @@ static void peerSelectFoo _PARAMS((ps_state *));
 static void peerPingTimeout _PARAMS((void *data));
 static void peerSelectCallbackFail _PARAMS((ps_state * psstate));
 static void peerHandleIcpReply _PARAMS((peer * p, peer_t type, icp_opcode op, void *data));
+static void peerSelectStateFree _PARAMS((ps_state * psstate));
+
+static void
+peerSelectStateFree(ps_state * psstate)
+{
+    if (psstate->acl_checklist) {
+       debug(0, 0, "calling aclChecklistFree() from peerSelectStateFree\n");
+       aclChecklistFree(psstate->acl_checklist);
+    }
+    requestUnlink(psstate->request);
+    xfree(psstate);
+}
 
 int
 peerSelectIcpPing(request_t * request, int direct, StoreEntry * entry)
@@ -139,6 +151,7 @@ static void
 peerCheckNeverDirectDone(int answer, void *data)
 {
     ps_state *psstate = data;
+    psstate->acl_checklist = NULL;
     debug(44, 3, "peerCheckNeverDirectDone: %d\n", answer);
     psstate->never_direct = answer ? 1 : -1;
     peerSelectFoo(psstate);
@@ -148,6 +161,7 @@ static void
 peerCheckAlwaysDirectDone(int answer, void *data)
 {
     ps_state *psstate = data;
+    psstate->acl_checklist = NULL;
     debug(44, 3, "peerCheckAlwaysDirectDone: %d\n", answer);
     psstate->always_direct = answer ? 1 : -1;
     peerSelectFoo(psstate);
@@ -163,8 +177,7 @@ peerSelectCallback(ps_state * psstate, peer * p)
        entry->ping_status = PING_DONE;
     }
     psstate->callback(p, psstate->callback_data);
-    requestUnlink(psstate->request);
-    xfree(psstate);
+    peerSelectStateFree(psstate);
 }
 
 static void
@@ -177,8 +190,7 @@ peerSelectCallbackFail(ps_state * psstate)
     debug(44, 1, "   never_direct = %d\n", psstate->never_direct);
     debug(44, 1, "        timeout = %d\n", psstate->icp.timeout);
     psstate->fail_callback(NULL, psstate->callback_data);
-    requestUnlink(psstate->request);
-    xfree(psstate);
+    peerSelectStateFree(psstate);
 }
 
 static void
@@ -193,22 +205,26 @@ peerSelectFoo(ps_state * psstate)
        RequestMethodStr[request->method],
        request->host);
     if (psstate->never_direct == 0 && Config.accessList.NeverDirect) {
-       aclNBCheck(Config.accessList.NeverDirect,
+       psstate->acl_checklist = aclChecklistCreate(
+           Config.accessList.NeverDirect,
            request,
            request->client_addr,
            NULL,               /* user agent */
-           NULL,               /* ident */
+           NULL);              /* ident */
+       aclNBCheck(psstate->acl_checklist,
            peerCheckNeverDirectDone,
            psstate);
        return;
     } else if (psstate->never_direct > 0) {
        direct = DIRECT_NO;
     } else if (psstate->always_direct == 0 && Config.accessList.AlwaysDirect) {
-       aclNBCheck(Config.accessList.AlwaysDirect,
+       psstate->acl_checklist = aclChecklistCreate(
+           Config.accessList.AlwaysDirect,
            request,
            request->client_addr,
            NULL,               /* user agent */
-           NULL,               /* ident */
+           NULL);              /* ident */
+       aclNBCheck(psstate->acl_checklist,
            peerCheckAlwaysDirectDone,
            psstate);
        return;