combine two comm_set_select*() funcs into commSetSelect()

remove some (PF) casting

diff --git a/src/client_side.cc b/src/client_side.cc
index 0a24be4fb06702585511084e1b0485f61bd81a9d..cd3e96292becfe032d89d9e811b372109d2d49a7 100644 (file)
--- a/src/client_side.cc
+++ b/src/client_side.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: client_side.cc,v 1.40 1996/10/09 22:49:29 wessels Exp $
+ * $Id: client_side.cc,v 1.41 1996/10/11 23:11:06 wessels Exp $
  *
  * DEBUG: section 33    Client-side Routines
  * AUTHOR: Duane Wessels
@@ -218,10 +218,11 @@ clientRedirectDone(void *data, char *result)
     }
     icpParseRequestHeaders(icpState);
     fd_note(fd, icpState->url);
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_READ,
        (PF) icpDetectClientClose,
-       (void *) icpState);
+       (void *) icpState,
+       0);
     icpProcessRequest(fd, icpState);
 }
 

diff --git a/src/comm.cc b/src/comm.cc
index 47fd0d419c254993ad0a1de2df8c821e515b4623..2256c67fb6ba3e7f71c573494b29e18731f9b493 100644 (file)
--- a/src/comm.cc
+++ b/src/comm.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: comm.cc,v 1.87 1996/10/09 22:49:29 wessels Exp $
+ * $Id: comm.cc,v 1.88 1996/10/11 23:11:07 wessels Exp $
  *
  * DEBUG: section 5     Socket Functions
  * AUTHOR: Harvest Derived
@@ -330,10 +330,11 @@ comm_nbconnect(int fd, void *data)
     }
     switch (comm_connect_addr(fd, &connectState->S)) {
     case COMM_INPROGRESS:
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_WRITE,
            comm_nbconnect,
-           (void *) connectState);
+           (void *) connectState,
+       0);
        break;
     case COMM_OK:
        connectState->handler(fd, COMM_OK, connectState->data);
@@ -825,13 +826,7 @@ comm_select(time_t sec)
 }
 
 void
-comm_set_select_handler(int fd, unsigned int type, PF handler, void *client_data)
-{
-    comm_set_select_handler_plus_timeout(fd, type, handler, client_data, 0);
-}
-
-void
-comm_set_select_handler_plus_timeout(int fd, unsigned int type, PF handler, void *client_data, time_t timeout)
+commSetSelect(int fd, unsigned int type, PF handler, void *client_data, time_t timeout)
 {
     if (type & COMM_SELECT_TIMEOUT) {
        fd_table[fd].timeout_time = (getCurrentTime() + timeout);
@@ -839,7 +834,7 @@ comm_set_select_handler_plus_timeout(int fd, unsigned int type, PF handler, void
        fd_table[fd].timeout_handler = handler;
        fd_table[fd].timeout_data = client_data;
        if ((timeout <= 0) && handler) {
-           debug(5, 2, "comm_set_select_handler_plus_timeout: Zero timeout doesn't make sense\n");
+           debug(5, 2, "commSetSelect: Zero timeout doesn't make sense\n");
        }
     }
     if (type & COMM_SELECT_READ) {
@@ -1243,10 +1238,11 @@ commHandleRead(int fd, RWStateData * state)
     if (len <= 0) {
        if (errno == EWOULDBLOCK || errno == EAGAIN) {
            /* reschedule self */
-           comm_set_select_handler(fd,
+           commSetSelect(fd,
                COMM_SELECT_READ,
                (PF) commHandleRead,
-               state);
+               state,
+       0);
            return COMM_OK;
        } else {
            /* Len == 0 means connection closed; otherwise would not have been
@@ -1266,10 +1262,11 @@ commHandleRead(int fd, RWStateData * state)
        RWStateCallbackAndFree(fd, COMM_OK);
     } else {
        /* Reschedule until we are done */
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) commHandleRead,
-           state);
+           state,
+       0);
     }
     return COMM_OK;
 }
@@ -1305,10 +1302,11 @@ comm_read(int fd,
     state->handler_data = handler_data;
     state->free = NULL;
     fd_table[fd].rwstate = state;
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_READ,
        (PF) commHandleRead,
-       state);
+       state,
+       0);
 }
 
 /* Write to FD. */
@@ -1335,10 +1333,11 @@ commHandleWrite(int fd, RWStateData * state)
        if (errno == EWOULDBLOCK || errno == EAGAIN) {
            debug(5, 10, "commHandleWrite: FD %d: write failure: %s.\n",
                fd, xstrerror());
-           comm_set_select_handler(fd,
+           commSetSelect(fd,
                COMM_SELECT_WRITE,
                (PF) commHandleWrite,
-               state);
+               state,
+       0);
        } else {
            debug(5, 2, "commHandleWrite: FD %d: write failure: %s.\n",
                fd, xstrerror());
@@ -1349,10 +1348,11 @@ commHandleWrite(int fd, RWStateData * state)
        state->offset += len;
        if (state->offset < state->size) {
            /* Not done, reinstall the write handler and write some more */
-           comm_set_select_handler(fd,
+           commSetSelect(fd,
                COMM_SELECT_WRITE,
                (PF) commHandleWrite,
-               state);
+               state,
+       0);
        } else {
            RWStateCallbackAndFree(fd, COMM_OK);
        }
@@ -1385,10 +1385,11 @@ comm_write(int fd, char *buf, int size, int timeout, rw_complete_handler * handl
     state->handler_data = handler_data;
     state->free = free_func;
     fd_table[fd].rwstate = state;
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_WRITE,
        (PF) commHandleWrite,
-       fd_table[fd].rwstate);
+       fd_table[fd].rwstate,
+       0);
 }
 
 void

diff --git a/src/disk.cc b/src/disk.cc
index 099122e977e10b9eea4fab74e59c3f9ad5fcb279..d48334ab9c49a0372630c26d7f0dc583aab12553 100644 (file)
--- a/src/disk.cc
+++ b/src/disk.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: disk.cc,v 1.33 1996/10/10 22:20:27 wessels Exp $
+ * $Id: disk.cc,v 1.34 1996/10/11 23:11:09 wessels Exp $
  *
  * DEBUG: section 6     Disk I/O Routines
  * AUTHOR: Harvest Derived
@@ -282,10 +282,11 @@ diskHandleWrite(int fd, FileEntry * entry)
        if (len < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                /* just reschedule us, try again */
-               comm_set_select_handler(fd,
+               commSetSelect(fd,
                    COMM_SELECT_WRITE,
                    (PF) diskHandleWrite,
-                   (void *) entry);
+                   (void *) entry,
+       0);
                entry->write_daemon = PRESENT;
                return DISK_OK;
            } else {
@@ -383,10 +384,11 @@ file_write(int fd,
        aioFileWriteComplete,
        &file_table[fd]);
 #else
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_WRITE,
        (PF) diskHandleWrite,
-       (void *) &file_table[fd]);
+       (void *) &file_table[fd],
+       0);
     return DISK_OK;
 #endif
 }
@@ -435,10 +437,11 @@ diskHandleRead(int fd, dread_ctrl * ctrl_dat)
 
     /* reschedule if need more data. */
     if (ctrl_dat->cur_len < ctrl_dat->req_len) {
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) diskHandleRead,
-           (void *) ctrl_dat);
+           (void *) ctrl_dat,
+       0);
        return DISK_OK;
     } else {
        /* all data we need is here. */
@@ -477,10 +480,11 @@ file_read(int fd, char *buf, int req_len, int offset, FILE_READ_HD handler, void
 #if USE_ASYNC_IO
     return aioFileQueueRead(fd, aioFileReadComplete, ctrl_dat);
 #else
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_READ,
        (PF) diskHandleRead,
-       (void *) ctrl_dat);
+       (void *) ctrl_dat,
+       0);
     return DISK_OK;
 #endif
 }
@@ -545,8 +549,9 @@ diskHandleWalk(int fd, dwalk_ctrl * walk_dat)
     walk_dat->offset += used_bytes;
 
     /* reschedule it for next line. */
-    comm_set_select_handler(fd, COMM_SELECT_READ, (PF) diskHandleWalk,
-       (void *) walk_dat);
+    commSetSelect(fd, COMM_SELECT_READ, (PF) diskHandleWalk,
+       (void *) walk_dat,
+       0);
     return DISK_OK;
 }
 
@@ -574,8 +579,9 @@ file_walk(int fd,
     walk_dat->line_handler = line_handler;
     walk_dat->line_data = line_data;
 
-    comm_set_select_handler(fd, COMM_SELECT_READ, (PF) diskHandleWalk,
-       (void *) walk_dat);
+    commSetSelect(fd, COMM_SELECT_READ, (PF) diskHandleWalk,
+       (void *) walk_dat,
+       0);
     return DISK_OK;
 }
 

diff --git a/src/fqdncache.cc b/src/fqdncache.cc
index a98d6d7dd5933bee2022e2c528f6d1cae8074328..9e023116b0b24a92e14666152161420a05f2508a 100644 (file)
--- a/src/fqdncache.cc
+++ b/src/fqdncache.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: fqdncache.cc,v 1.25 1996/10/10 22:20:55 wessels Exp $
+ * $Id: fqdncache.cc,v 1.26 1996/10/11 23:11:10 wessels Exp $
  *
  * DEBUG: section 35    FQDN Cache
  * AUTHOR: Harvest Derived
@@ -528,10 +528,11 @@ fqdncache_dnsHandleRead(int fd, dnsserver_t * dnsData)
            "FD %d: Connection from DNSSERVER #%d is closed, disabling\n",
            fd, dnsData->id);
        dnsData->flags = 0;
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_WRITE,
            NULL,
-           NULL);
+           NULL,
+       0);
        comm_close(fd);
        return 0;
     }
@@ -669,10 +670,11 @@ fqdncache_dnsDispatch(dnsserver_t * dns, fqdncache_entry * f)
        NULL,                   /* Handler */
        NULL,                   /* Handler-data */
        xfree);
-    comm_set_select_handler(dns->outpipe,
+    commSetSelect(dns->outpipe,
        COMM_SELECT_READ,
        (PF) fqdncache_dnsHandleRead,
-       dns);
+       dns,
+       0);
     debug(35, 5, "fqdncache_dnsDispatch: Request sent to DNS server #%d.\n",
        dns->id);
     dns->dispatch_time = current_time;

diff --git a/src/ftp.cc b/src/ftp.cc
index ee2748f4bafadbe83d65e0955046c4257a5b0b65..0382aa565ecac882abd4b3457b11018bd2b5585e 100644 (file)
--- a/src/ftp.cc
+++ b/src/ftp.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: ftp.cc,v 1.63 1996/10/09 22:49:31 wessels Exp $
+ * $Id: ftp.cc,v 1.64 1996/10/11 23:11:10 wessels Exp $
  *
  * DEBUG: section 9     File Transfer Protocol (FTP)
  * AUTHOR: Harvest Derived
@@ -312,10 +312,10 @@ ftpReadReply(int fd, FtpStateData * data)
        debug(11, 3, "                Current Gap: %d bytes\n", clen - off);
        /* reschedule, so it will be automatically reactivated
         * when Gap is big enough. */
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) ftpReadReply,
-           (void *) data);
+           (void *) data, 0);
        if (!BIT_TEST(entry->flag, READ_DEFERRED)) {
            /* NOTE there is no read timeout handler to disable */
            BIT_SET(entry->flag, READ_DEFERRED);
@@ -340,8 +340,8 @@ ftpReadReply(int fd, FtpStateData * data)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(fd, COMM_SELECT_READ,
-               (PF) ftpReadReply, (void *) data);
+           commSetSelect(fd, COMM_SELECT_READ,
+               (PF) ftpReadReply, (void *) data, 0);
            /* note there is no ftpReadReplyTimeout.  Timeouts are handled
             * by `ftpget'. */
        } else {
@@ -376,10 +376,10 @@ ftpReadReply(int fd, FtpStateData * data)
        /*  accept data, but start to delete behind it */
        storeStartDeleteBehind(entry);
        storeAppend(entry, buf, len);
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) ftpReadReply,
-           (void *) data);
+           (void *) data, 0);
     } else if (entry->flag & CLIENT_ABORT_REQUEST) {
        /* append the last bit of info we get */
        storeAppend(entry, buf, len);
@@ -397,11 +397,11 @@ ftpReadReply(int fd, FtpStateData * data)
        storeAppend(entry, buf, len);
        if (data->reply_hdr_state < 2 && len > 0)
            ftpProcessReplyHeader(data, buf, len);
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) ftpReadReply,
-           (void *) data);
-       comm_set_select_handler_plus_timeout(fd,
+           (void *) data, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
            (PF) ftpLifetimeExpire,
            (void *) data,
@@ -429,11 +429,11 @@ ftpSendComplete(int fd, char *buf, int size, int errflag, void *data)
        comm_close(fd);
        return;
     } else {
-       comm_set_select_handler(ftpState->ftp_fd,
+       commSetSelect(ftpState->ftp_fd,
            COMM_SELECT_READ,
            (PF) ftpReadReply,
-           (void *) ftpState);
-       comm_set_select_handler_plus_timeout(ftpState->ftp_fd,
+           (void *) ftpState, 0);
+       commSetSelect(ftpState->ftp_fd,
            COMM_SELECT_TIMEOUT,
            (PF) ftpLifetimeExpire,
            (void *) ftpState, Config.readTimeout);
@@ -644,16 +644,16 @@ ftpConnectDone(int fd, int status, void *data)
     (void) fd_note(fd, ftpData->entry->url);
     /* Install connection complete handler. */
     fd_note(fd, ftpData->entry->url);
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_WRITE,
        (PF) ftpSendRequest,
-       (void *) data);
+       (void *) data, 0);
     comm_set_fd_lifetime(fd,
        Config.lifetimeDefault);
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_LIFETIME,
        (PF) ftpLifetimeExpire,
-       (void *) ftpData);
+       (void *) ftpData, 0);
     if (opt_no_ipcache)
        ipcacheInvalidate(ftpData->request->host);
 }
@@ -680,10 +680,10 @@ ftpServerClose(void)
      * pending */
     if (ftpget_server_read < 0)
        return;
-    comm_set_select_handler(ftpget_server_read,
+    commSetSelect(ftpget_server_read,
        COMM_SELECT_READ,
        (PF) NULL,
-       (void *) NULL);
+       (void *) NULL, 0);
     fdstat_close(ftpget_server_read);
     close(ftpget_server_read);
     fdstat_close(ftpget_server_write);
@@ -751,10 +751,10 @@ ftpInitialize(void)
        commSetCloseOnExec(squid_to_ftpget[1]);
        commSetCloseOnExec(ftpget_to_squid[0]);
        /* if ftpget -S goes away, this handler should get called */
-       comm_set_select_handler(ftpget_to_squid[0],
+       commSetSelect(ftpget_to_squid[0],
            COMM_SELECT_READ,
            (PF) ftpServerClosed,
-           (void *) NULL);
+           (void *) NULL, 0);
        ftpget_server_write = squid_to_ftpget[1];
        ftpget_server_read = ftpget_to_squid[0];
        slp.tv_sec = 0;

diff --git a/src/gopher.cc b/src/gopher.cc
index b6634e05e6df21435256fa2cc948bc7475e8d361..1f0b2fb7c8e5d1e6a649724afbba25e5b0020d51 100644 (file)
--- a/src/gopher.cc
+++ b/src/gopher.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: gopher.cc,v 1.52 1996/10/09 22:49:32 wessels Exp $
+ * $Id: gopher.cc,v 1.53 1996/10/11 23:11:11 wessels Exp $
  *
  * DEBUG: section 10    Gopher
  * AUTHOR: Harvest Derived
@@ -696,16 +696,14 @@ gopherLifetimeExpire(int fd, GopherStateData * data)
     entry = data->entry;
     debug(10, 4, "gopherLifeTimeExpire: FD %d: <URL:%s>\n", fd, entry->url);
     squid_error_entry(entry, ERR_LIFETIME_EXP, NULL);
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_READ | COMM_SELECT_WRITE,
-       0,
-       0);
+       NULL,
+       NULL, 0);
     comm_close(fd);
 }
 
 
-
-
 /* This will be called when data is ready to be read from fd.  Read until
  * error or connection closed. */
 static void
@@ -740,16 +738,16 @@ gopherReadReply(int fd, GopherStateData * data)
        debug(10, 3, "                Current Gap: %d bytes\n", clen - off);
        /* reschedule, so it will automatically reactivated when
         * Gap is big enough.  */
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) gopherReadReply,
-           (void *) data);
+           (void *) data, 0);
        /* don't install read timeout until we are below the GAP */
-       comm_set_select_handler_plus_timeout(fd,
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
-           (PF) NULL,
-           (void *) NULL,
-           (time_t) 0);
+           NULL,
+            NULL,
+           0);
        if (!BIT_TEST(entry->flag, READ_DEFERRED)) {
            comm_set_fd_lifetime(fd, 3600);     /* limit during deferring */
            BIT_SET(entry->flag, READ_DEFERRED);
@@ -776,11 +774,11 @@ gopherReadReply(int fd, GopherStateData * data)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(fd,
+           commSetSelect(fd,
                COMM_SELECT_READ,
                (PF) gopherReadReply,
-               (void *) data);
-           comm_set_select_handler_plus_timeout(fd,
+               (void *) data, 0);
+           commSetSelect(fd,
                COMM_SELECT_TIMEOUT,
                (PF) gopherReadReplyTimeout,
                (void *) data,
@@ -815,11 +813,11 @@ gopherReadReply(int fd, GopherStateData * data)
        } else {
            storeAppend(entry, buf, len);
        }
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) gopherReadReply,
-           (void *) data);
-       comm_set_select_handler_plus_timeout(fd,
+           (void *) data, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
            (PF) gopherReadReplyTimeout,
            (void *) data,
@@ -842,11 +840,11 @@ gopherReadReply(int fd, GopherStateData * data)
        } else {
            storeAppend(entry, buf, len);
        }
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) gopherReadReply,
-           (void *) data);
-       comm_set_select_handler_plus_timeout(fd,
+           (void *) data, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
            (PF) gopherReadReplyTimeout,
            (void *) data,
@@ -911,11 +909,11 @@ gopherSendComplete(int fd, char *buf, int size, int errflag, void *data)
 
        }
     /* Schedule read reply. */
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_READ,
        (PF) gopherReadReply,
-       (void *) gopherState);
-    comm_set_select_handler_plus_timeout(fd,
+       (void *) gopherState, 0);
+    commSetSelect(fd,
        COMM_SELECT_TIMEOUT,
        (PF) gopherReadReplyTimeout,
        (void *) gopherState,
@@ -1041,14 +1039,14 @@ gopherConnectDone(int fd, int status, void *data)
     /* Install connection complete handler. */
     if (opt_no_ipcache)
        ipcacheInvalidate(gopherState->host);
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_LIFETIME,
        (PF) gopherLifetimeExpire,
-       (void *) gopherState);
-    comm_set_select_handler(fd,
+       (void *) gopherState, 0);
+    commSetSelect(fd,
        COMM_SELECT_WRITE,
        (PF) gopherSendRequest,
-       (void *) gopherState);
+       (void *) gopherState, 0);
 }
 
 

diff --git a/src/http.cc b/src/http.cc
index 6d799c6cc7161ed2dc49f148e41e15c0b5672e1a..7ab43486b44a45298c6af6afcefa80e7eeb0a37f 100644 (file)
--- a/src/http.cc
+++ b/src/http.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: http.cc,v 1.82 1996/10/09 22:49:33 wessels Exp $
+ * $Id: http.cc,v 1.83 1996/10/11 23:11:12 wessels Exp $
  *
  * DEBUG: section 11    Hypertext Transfer Protocol (HTTP)
  * AUTHOR: Harvest Derived
@@ -116,23 +116,24 @@ static struct {
     int ctype;
 } ReplyHeaderStats;
 
-static int httpStateFree _PARAMS((int fd, HttpStateData *));
-static void httpReadReplyTimeout _PARAMS((int fd, HttpStateData *));
-static void httpLifetimeExpire _PARAMS((int fd, HttpStateData *));
+static void httpStateFree _PARAMS((int fd, void *));
+static void httpReadReplyTimeout _PARAMS((int fd, void *));
+static void httpLifetimeExpire _PARAMS((int fd, void *));
 static void httpMakePublic _PARAMS((StoreEntry *));
 static void httpMakePrivate _PARAMS((StoreEntry *));
 static void httpCacheNegatively _PARAMS((StoreEntry *));
-static void httpReadReply _PARAMS((int fd, HttpStateData *));
+static void httpReadReply _PARAMS((int fd, void *));
 static void httpSendComplete _PARAMS((int fd, char *, int, int, void *));
-static void httpSendRequest _PARAMS((int fd, HttpStateData *));
+static void httpSendRequest _PARAMS((int fd, void *));
 static void httpConnect _PARAMS((int fd, ipcache_addrs *, void *));
 static void httpConnectDone _PARAMS((int fd, int status, void *data));
 
-static int
-httpStateFree(int fd, HttpStateData * httpState)
+static void
+httpStateFree(int fd, void *data)
 {
+    HttpStateData *httpState = data;
     if (httpState == NULL)
-       return 1;
+       return;
     storeUnlockObject(httpState->entry);
     if (httpState->reply_hdr) {
        put_free_8k_page(httpState->reply_hdr);
@@ -140,7 +141,6 @@ httpStateFree(int fd, HttpStateData * httpState)
     }
     requestUnlink(httpState->request);
     xfree(httpState);
-    return 0;
 }
 
 int
@@ -155,28 +155,30 @@ httpCachable(char *url, int method)
 
 /* This will be called when timeout on read. */
 static void
-httpReadReplyTimeout(int fd, HttpStateData * httpState)
+httpReadReplyTimeout(int fd, void *data)
 {
+    HttpStateData *httpState = data;
     StoreEntry *entry = NULL;
 
     entry = httpState->entry;
     debug(11, 4, "httpReadReplyTimeout: FD %d: <URL:%s>\n", fd, entry->url);
     squid_error_entry(entry, ERR_READ_TIMEOUT, NULL);
-    comm_set_select_handler(fd, COMM_SELECT_READ, 0, 0);
+    commSetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0);
     comm_close(fd);
 }
 
 /* This will be called when socket lifetime is expired. */
 static void
-httpLifetimeExpire(int fd, HttpStateData * httpState)
+httpLifetimeExpire(int fd, void *data)
 {
+    HttpStateData *httpState = data;
     StoreEntry *entry = NULL;
 
     entry = httpState->entry;
     debug(11, 4, "httpLifeTimeExpire: FD %d: <URL:%s>\n", fd, entry->url);
 
     squid_error_entry(entry, ERR_LIFETIME_EXP, NULL);
-    comm_set_select_handler(fd, COMM_SELECT_READ | COMM_SELECT_WRITE, 0, 0);
+    commSetSelect(fd, COMM_SELECT_READ | COMM_SELECT_WRITE, NULL, NULL, 0);
     comm_close(fd);
 }
 
@@ -397,8 +399,9 @@ httpProcessReplyHeader(HttpStateData * httpState, char *buf, int size)
  * error or connection closed. */
 /* XXX this function is too long! */
 static void
-httpReadReply(int fd, HttpStateData * httpState)
+httpReadReply(int fd, void *data)
 {
+    HttpStateData *httpState = data;
     LOCAL_ARRAY(char, buf, SQUID_TCP_SO_RCVBUF);
     int len;
     int bin;
@@ -428,14 +431,14 @@ httpReadReply(int fd, HttpStateData * httpState)
        debug(11, 3, "                Current Gap: %d bytes\n", clen - off);
        /* reschedule, so it will be automatically reactivated
         * when Gap is big enough. */
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
-           (PF) httpReadReply,
-           (void *) httpState);
+           httpReadReply,
+           (void *) httpState, 0);
        /* disable read timeout until we are below the GAP */
-       comm_set_select_handler_plus_timeout(fd,
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
-           (PF) NULL,
+           NULL,
            (void *) NULL,
            (time_t) 0);
        if (!BIT_TEST(entry->flag, READ_DEFERRED)) {
@@ -464,10 +467,10 @@ httpReadReply(int fd, HttpStateData * httpState)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(fd, COMM_SELECT_READ,
-               (PF) httpReadReply, (void *) httpState);
-           comm_set_select_handler_plus_timeout(fd, COMM_SELECT_TIMEOUT,
-               (PF) httpReadReplyTimeout, (void *) httpState, Config.readTimeout);
+           commSetSelect(fd, COMM_SELECT_READ,
+               httpReadReply, (void *) httpState, 0);
+           commSetSelect(fd, COMM_SELECT_TIMEOUT,
+               httpReadReplyTimeout, (void *) httpState, Config.readTimeout);
        } else {
            BIT_RESET(entry->flag, ENTRY_CACHABLE);
            storeReleaseRequest(entry);
@@ -488,13 +491,13 @@ httpReadReply(int fd, HttpStateData * httpState)
        /*  accept data, but start to delete behind it */
        storeStartDeleteBehind(entry);
        storeAppend(entry, buf, len);
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
-           (PF) httpReadReply,
-           (void *) httpState);
-       comm_set_select_handler_plus_timeout(fd,
+           httpReadReply,
+           (void *) httpState, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
-           (PF) httpReadReplyTimeout,
+           httpReadReplyTimeout,
            (void *) httpState, Config.readTimeout);
     } else if (entry->flag & CLIENT_ABORT_REQUEST) {
        /* append the last bit of info we get */
@@ -505,13 +508,13 @@ httpReadReply(int fd, HttpStateData * httpState)
        if (httpState->reply_hdr_state < 2 && len > 0)
            httpProcessReplyHeader(httpState, buf, len);
        storeAppend(entry, buf, len);
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
-           (PF) httpReadReply,
-           (void *) httpState);
-       comm_set_select_handler_plus_timeout(fd,
+           httpReadReply,
+           (void *) httpState, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
-           (PF) httpReadReplyTimeout,
+           httpReadReplyTimeout,
            (void *) httpState,
            Config.readTimeout);
     }
@@ -535,13 +538,13 @@ httpSendComplete(int fd, char *buf, int size, int errflag, void *data)
        return;
     } else {
        /* Schedule read reply. */
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
-           (PF) httpReadReply,
-           (void *) httpState);
-       comm_set_select_handler_plus_timeout(fd,
+           httpReadReply,
+           (void *) httpState, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
-           (PF) httpReadReplyTimeout,
+           httpReadReplyTimeout,
            (void *) httpState,
            Config.readTimeout);
        comm_set_fd_lifetime(fd, 86400);        /* extend lifetime */
@@ -550,8 +553,9 @@ httpSendComplete(int fd, char *buf, int size, int errflag, void *data)
 
 /* This will be called when connect completes. Write request. */
 static void
-httpSendRequest(int fd, HttpStateData * httpState)
+httpSendRequest(int fd, void *data)
 {
+    HttpStateData *httpState = data;
     char *xbuf = NULL;
     char *ybuf = NULL;
     char *buf = NULL;
@@ -685,7 +689,7 @@ proxyhttpStart(edge * e, char *url, StoreEntry * entry)
     httpState->neighbor = e;
     /* register the handler to free HTTP state data when the FD closes */
     comm_add_close_handler(sock,
-       (PF) httpStateFree,
+       httpStateFree,
        (void *) httpState);
     request->method = entry->method;
     strncpy(request->host, e->host, SQUIDHOSTNAMELEN);
@@ -738,10 +742,10 @@ httpConnectDone(int fd, int status, void *data)
        if (opt_no_ipcache)
            ipcacheInvalidate(request->host);
        fd_note(fd, entry->url);
-       comm_set_select_handler(fd, COMM_SELECT_LIFETIME,
-           (PF) httpLifetimeExpire, (void *) httpState);
-       comm_set_select_handler(fd, COMM_SELECT_WRITE,
-           (PF) httpSendRequest, (void *) httpState);
+       commSetSelect(fd, COMM_SELECT_LIFETIME,
+           httpLifetimeExpire, (void *) httpState, 0);
+       commSetSelect(fd, COMM_SELECT_WRITE,
+           httpSendRequest, (void *) httpState, 0);
     }
 }
 
@@ -779,7 +783,7 @@ httpStart(int unusedfd,
     httpState->req_hdr_sz = req_hdr_sz;
     httpState->request = requestLink(request);
     comm_add_close_handler(sock,
-       (PF) httpStateFree,
+       httpStateFree,
        (void *) httpState);
     ipcache_nbgethostbyname(request->host,
        sock,

diff --git a/src/icmp.cc b/src/icmp.cc
index 1e79a9f55d73ab4da4c28686b35249641cf8c396..512b08860fe7db78d1d8a22d4abb6a090d52724c 100644 (file)
--- a/src/icmp.cc
+++ b/src/icmp.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: icmp.cc,v 1.18 1996/10/11 19:35:28 wessels Exp $
+ * $Id: icmp.cc,v 1.19 1996/10/11 23:11:12 wessels Exp $
  *
  * DEBUG: section 37    ICMP Routines
  * AUTHOR: Duane Wessels
@@ -111,10 +111,10 @@ icmpOpen(void)
        _exit(1);
     }
     comm_close(child_sock);
-    comm_set_select_handler(icmp_sock,
+    commSetSelect(icmp_sock,
        COMM_SELECT_READ,
        (PF) icmpRecv,
-       (void *) -1);
+       (void *) -1, 0);
     comm_set_fd_lifetime(icmp_sock, -1);
     debug(29,0,"Pinger socket opened on FD %d\n", icmp_sock);
 }
@@ -125,10 +125,10 @@ icmpClose(void)
     icmpQueueData *queue;
     debug(29, 0, "Closing ICMP socket on FD %d\n", icmp_sock);
     comm_close(icmp_sock);
-    comm_set_select_handler(icmp_sock,
+    commSetSelect(icmp_sock,
        COMM_SELECT_READ,
        NULL,
-       NULL);
+       NULL, 0);
     icmp_sock = -1;
     while ((queue = IcmpQueueHead)) {
        IcmpQueueHead = queue->next;
@@ -158,10 +158,10 @@ icmpRecv(int unused1, void *unused2)
     pingerReplyData preply;
     static struct sockaddr_in F;
 
-    comm_set_select_handler(icmp_sock,
+    commSetSelect(icmp_sock,
        COMM_SELECT_READ,
        (PF) icmpRecv,
-       (void *) -1);
+       (void *) -1, 0);
     memset((char *) &preply, '\0', sizeof(pingerReplyData));
     n = recv(icmp_sock,
        (char *) &preply,
@@ -211,10 +211,10 @@ icmpQueueSend(pingerEchoData * pkt,
     q->free_func = free_func;
     for (H = &IcmpQueueHead; *H; H = &(*H)->next);
     *H = q;
-    comm_set_select_handler(icmp_sock,
+    commSetSelect(icmp_sock,
        COMM_SELECT_WRITE,
        (PF) icmpSend,
-       (void *) IcmpQueueHead);
+       (void *) IcmpQueueHead, 0);
 }
 
 static void
@@ -241,15 +241,15 @@ icmpSend(int fd, icmpQueueData * queue)
     }
     /* Reinstate handler if needed */
     if (IcmpQueueHead) {
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_WRITE,
            (PF) icmpSend,
-           (void *) IcmpQueueHead);
+           (void *) IcmpQueueHead, 0);
     } else {
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_WRITE,
            NULL,
-           NULL);
+           NULL, 0);
     }
 }
 

diff --git a/src/ident.cc b/src/ident.cc
index e50bee197342a1a538beb3e99a5b2349fd2d5f60..2333fb225ab6b0124462bda43c6c1c3a4b36215e 100644 (file)
--- a/src/ident.cc
+++ b/src/ident.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: ident.cc,v 1.18 1996/10/10 23:21:28 wessels Exp $
+ * $Id: ident.cc,v 1.19 1996/10/11 23:11:14 wessels Exp $
  *
  * DEBUG: section 30    Ident (RFC 931)
  * AUTHOR: Duane Wessels
@@ -88,10 +88,10 @@ identConnectDone(int fd, int status, void *data)
        identRequestComplete,
        (void *) icpState,
        NULL);
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_READ,
        (PF) identReadReply,
-       (void *) icpState);
+       (void *) icpState, 0);
 }
 
 static void

diff --git a/src/ipcache.cc b/src/ipcache.cc
index fa7b3555bf4c157725f267da9169c9b1faee434b..7da4f4fc38f5d72ebfd247b3d5e2d337c5be96b2 100644 (file)
--- a/src/ipcache.cc
+++ b/src/ipcache.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: ipcache.cc,v 1.70 1996/10/10 22:20:57 wessels Exp $
+ * $Id: ipcache.cc,v 1.71 1996/10/11 23:11:15 wessels Exp $
  *
  * DEBUG: section 14    IP Cache
  * AUTHOR: Harvest Derived
@@ -557,10 +557,10 @@ ipcache_dnsHandleRead(int fd, dnsserver_t * dnsData)
            "FD %d: Connection from DNSSERVER #%d is closed, disabling\n",
            fd, dnsData->id);
        dnsData->flags = 0;
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_WRITE,
            NULL,
-           NULL);
+           NULL, 0);
        comm_close(fd);
        return 0;
     }
@@ -596,10 +596,10 @@ ipcache_dnsHandleRead(int fd, dnsserver_t * dnsData)
        dnsData->flags &= ~DNS_FLAG_BUSY;
     }
     /* reschedule */
-    comm_set_select_handler(dnsData->inpipe,
+    commSetSelect(dnsData->inpipe,
        COMM_SELECT_READ,
        (PF) ipcache_dnsHandleRead,
-       dnsData);
+       dnsData, 0);
     while ((dnsData = dnsGetFirstAvailable()) && (i = ipcacheDequeue()))
        ipcache_dnsDispatch(dnsData, i);
     return 0;
@@ -705,10 +705,10 @@ ipcache_dnsDispatch(dnsserver_t * dns, ipcache_entry * i)
        NULL,                   /* Handler */
        NULL,                   /* Handler-data */
        xfree);
-    comm_set_select_handler(dns->outpipe,
+    commSetSelect(dns->outpipe,
        COMM_SELECT_READ,
        (PF) ipcache_dnsHandleRead,
-       dns);
+       dns, 0);
     debug(14, 5, "ipcache_dnsDispatch: Request sent to DNS server #%d.\n",
        dns->id);
     dns->dispatch_time = current_time;

diff --git a/src/main.cc b/src/main.cc
index e7bea686e676768d8d2b458cfe12728a8f56442b..ca4f0840438cb13017b75212189960c9945ab67f 100644 (file)
--- a/src/main.cc
+++ b/src/main.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: main.cc,v 1.91 1996/10/10 22:20:58 wessels Exp $
+ * $Id: main.cc,v 1.92 1996/10/11 23:11:16 wessels Exp $
  *
  * DEBUG: section 1     Startup and Main Loop
  * AUTHOR: Harvest Derived
@@ -339,10 +339,10 @@ serverConnectionsOpen(void)
     }
     fd_note(theHttpConnection, "HTTP socket");
     comm_listen(theHttpConnection);
-    comm_set_select_handler(theHttpConnection,
+    commSetSelect(theHttpConnection,
        COMM_SELECT_READ,
        asciiHandleConn,
-       0);
+       NULL, 0);
     debug(1, 1, "Accepting HTTP connections on FD %d.\n",
        theHttpConnection);
 
@@ -359,10 +359,10 @@ serverConnectionsOpen(void)
            if (theInIcpConnection < 0)
                fatal("Cannot open ICP Port");
            fd_note(theInIcpConnection, "ICP socket");
-           comm_set_select_handler(theInIcpConnection,
+           commSetSelect(theInIcpConnection,
                COMM_SELECT_READ,
                icpHandleUdp,
-               0);
+               NULL, 0);
            comm_join_mcast_groups(theInIcpConnection);
            debug(1, 1, "Accepting ICP connections on FD %d.\n",
                theInIcpConnection);
@@ -378,10 +378,10 @@ serverConnectionsOpen(void)
                leave_suid();
                if (theOutIcpConnection < 0)
                    fatal("Cannot open Outgoing ICP Port");
-               comm_set_select_handler(theOutIcpConnection,
+               commSetSelect(theOutIcpConnection,
                    COMM_SELECT_READ,
                    icpHandleUdp,
-                   0);
+                   NULL, 0);
                debug(1, 1, "Accepting ICP connections on FD %d.\n",
                    theOutIcpConnection);
                fd_note(theOutIcpConnection, "Outgoing ICP socket");
@@ -406,10 +406,10 @@ serverConnectionsClose(void)
        debug(21, 1, "FD %d Closing HTTP connection\n",
            theHttpConnection);
        comm_close(theHttpConnection);
-       comm_set_select_handler(theHttpConnection,
+       commSetSelect(theHttpConnection,
            COMM_SELECT_READ,
            NULL,
-           0);
+           NULL, 0);
        theHttpConnection = -1;
     }
     if (theInIcpConnection >= 0) {
@@ -419,15 +419,15 @@ serverConnectionsClose(void)
            theInIcpConnection);
        if (theInIcpConnection != theOutIcpConnection)
            comm_close(theInIcpConnection);
-       comm_set_select_handler(theInIcpConnection,
+       commSetSelect(theInIcpConnection,
            COMM_SELECT_READ,
            NULL,
-           0);
+           NULL, 0);
        if (theInIcpConnection != theOutIcpConnection)
-           comm_set_select_handler(theOutIcpConnection,
+           commSetSelect(theOutIcpConnection,
                COMM_SELECT_READ,
                NULL,
-               0);
+               NULL, 0);
        theInIcpConnection = -1;
     }
 #if USE_ICMP

diff --git a/src/redirect.cc b/src/redirect.cc
index 55594a93b7f2fb50bfc9a51ece1daff10e8d5516..cd1dd57a1188f3f8b86fcb5515fdbbe6b3ea51e4 100644 (file)
--- a/src/redirect.cc
+++ b/src/redirect.cc
@@ -1,5 +1,5 @@
 /*
- * $Id: redirect.cc,v 1.24 1996/10/10 22:20:30 wessels Exp $
+ * $Id: redirect.cc,v 1.25 1996/10/11 23:11:17 wessels Exp $
  *
  * DEBUG: section 29    Redirector
  * AUTHOR: Duane Wessels
@@ -190,10 +190,10 @@ redirectHandleRead(int fd, redirector_t * redirector)
     redirector->offset += len;
     redirector->inbuf[redirector->offset] = '\0';
     /* reschedule */
-    comm_set_select_handler(redirector->fd,
+    commSetSelect(redirector->fd,
        COMM_SELECT_READ,
        (PF) redirectHandleRead,
-       redirector);
+       redirector, 0);
     if ((t = strchr(redirector->inbuf, '\n'))) {
        /* end of record found */
        *t = '\0';
@@ -383,10 +383,10 @@ redirectOpenServers(void)
            fd_note(redirect_child_table[k]->fd, fd_note_buf);
            commSetNonBlocking(redirect_child_table[k]->fd);
            /* set handler for incoming result */
-           comm_set_select_handler(redirect_child_table[k]->fd,
+           commSetSelect(redirect_child_table[k]->fd,
                COMM_SELECT_READ,
                (PF) redirectHandleRead,
-               (void *) redirect_child_table[k]);
+               (void *) redirect_child_table[k], 0);
            debug(29, 3, "redirectOpenServers: 'redirect_server' %d started\n",
                k);
        }

diff --git a/src/send-announce.cc b/src/send-announce.cc
index 495e492a112d90463de77aa6f210f753bc555670..66a88e4bfebcbccecd5a7db2117baecdd451dd90 100644 (file)
--- a/src/send-announce.cc
+++ b/src/send-announce.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: send-announce.cc,v 1.20 1996/10/09 22:49:42 wessels Exp $
+ * $Id: send-announce.cc,v 1.21 1996/10/11 23:11:18 wessels Exp $
  *
  * DEBUG: section 27    Cache Announcer
  * AUTHOR: Duane Wessels
@@ -86,8 +86,8 @@ send_announce(void)
     qdata->address.sin_port = htons(port);
     qdata->address.sin_addr = ia->in_addrs[0];
     AppendUdp(qdata);
-    comm_set_select_handler(theOutIcpConnection,
+    commSetSelect(theOutIcpConnection,
        COMM_SELECT_WRITE,
        (PF) icpUdpReply,
-       (void *) qdata);
+       (void *) qdata, 0);
 }

diff --git a/src/ssl.cc b/src/ssl.cc
index a3c114ff3545c62ab713222dbc08af5cd202e01f..455e4ea92a475403ec55efb05b1ed51576001773 100644 (file)
--- a/src/ssl.cc
+++ b/src/ssl.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: ssl.cc,v 1.19 1996/10/09 22:49:42 wessels Exp $
+ * $Id: ssl.cc,v 1.20 1996/10/11 23:11:18 wessels Exp $
  *
  * DEBUG: section 26    Secure Sockets Layer Proxy
  * AUTHOR: Duane Wessels
@@ -50,19 +50,20 @@ typedef struct {
 
 static char conn_established[] = "HTTP/1.0 200 Connection established\r\n\r\n";
 
-static void sslLifetimeExpire _PARAMS((int fd, SslStateData * sslState));
-static void sslReadTimeout _PARAMS((int fd, SslStateData * sslState));
-static void sslReadServer _PARAMS((int fd, SslStateData * sslState));
-static void sslReadClient _PARAMS((int fd, SslStateData * sslState));
-static void sslWriteServer _PARAMS((int fd, SslStateData * sslState));
-static void sslWriteClient _PARAMS((int fd, SslStateData * sslState));
-static void sslConnected _PARAMS((int fd, SslStateData * sslState));
-static void sslProxyConnected _PARAMS((int fd, SslStateData * sslState));
+static void sslLifetimeExpire _PARAMS((int fd, void *));
+static void sslReadTimeout _PARAMS((int fd, void *));
+static void sslReadServer _PARAMS((int fd, void *));
+static void sslReadClient _PARAMS((int fd, void *));
+static void sslWriteServer _PARAMS((int fd, void *));
+static void sslWriteClient _PARAMS((int fd, void *));
+static void sslConnected _PARAMS((int fd, void *));
+static void sslProxyConnected _PARAMS((int fd, void *));
 static void sslConnect _PARAMS((int fd, ipcache_addrs *, void *));
 static void sslErrorComplete _PARAMS((int, char *, int, int, void *));
 static void sslClose _PARAMS((SslStateData * sslState));
-static int sslClientClosed _PARAMS((int fd, SslStateData * sslState));
+static void sslClientClosed _PARAMS((int fd, void *));
 static void sslConnectDone _PARAMS((int fd, int status, void *data));
+static void sslStateFree _PARAMS((int fd, void *data));
 
 static void
 sslClose(SslStateData * sslState)
@@ -70,7 +71,7 @@ sslClose(SslStateData * sslState)
     if (sslState->client.fd > -1) {
        /* remove the "unexpected" client close handler */
        comm_remove_close_handler(sslState->client.fd,
-           (PF) sslClientClosed,
+           sslClientClosed,
            (void *) sslState);
        comm_close(sslState->client.fd);
        sslState->client.fd = -1;
@@ -82,9 +83,10 @@ sslClose(SslStateData * sslState)
 
 /* This is called only if the client connect closes unexpectedly,
  * ie from icpDetectClientClose() */
-static int
-sslClientClosed(int fd, SslStateData * sslState)
+static void
+sslClientClosed(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslClientClosed: FD %d\n", fd);
     /* we have been called from comm_close for the client side, so
      * just need to clean up the server side */
@@ -93,34 +95,34 @@ sslClientClosed(int fd, SslStateData * sslState)
        sslState->request,
        no_addr);
     comm_close(sslState->server.fd);
-    return 0;
 }
 
-static int
-sslStateFree(int fd, SslStateData * sslState)
+static void
+sslStateFree(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslStateFree: FD %d, sslState=%p\n", fd, sslState);
     if (sslState == NULL)
-       return 1;
+       return;
     if (fd != sslState->server.fd)
        fatal_dump("sslStateFree: FD mismatch!\n");
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_READ,
        NULL,
-       NULL);
+       NULL, 0);
     safe_free(sslState->server.buf);
     safe_free(sslState->client.buf);
     xfree(sslState->url);
     requestUnlink(sslState->request);
     memset(sslState, '\0', sizeof(SslStateData));
     safe_free(sslState);
-    return 0;
 }
 
 /* This will be called when the server lifetime is expired. */
 static void
-sslLifetimeExpire(int fd, SslStateData * sslState)
+sslLifetimeExpire(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 4, "sslLifeTimeExpire: FD %d: URL '%s'>\n",
        fd, sslState->url);
     sslClose(sslState);
@@ -128,8 +130,9 @@ sslLifetimeExpire(int fd, SslStateData * sslState)
 
 /* Read from server side and queue it for writing to the client */
 static void
-sslReadServer(int fd, SslStateData * sslState)
+sslReadServer(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     len = read(sslState->server.fd, sslState->server.buf, SQUID_TCP_SO_RCVBUF);
     debug(26, 5, "sslReadServer FD %d, read %d bytes\n", fd, len);
@@ -139,13 +142,13 @@ sslReadServer(int fd, SslStateData * sslState)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(sslState->server.fd,
+           commSetSelect(sslState->server.fd,
                COMM_SELECT_READ,
-               (PF) sslReadServer,
-               (void *) sslState);
-           comm_set_select_handler_plus_timeout(sslState->server.fd,
+               sslReadServer,
+               (void *) sslState, 0);
+           commSetSelect(sslState->server.fd,
                COMM_SELECT_TIMEOUT,
-               (PF) sslReadTimeout,
+               sslReadTimeout,
                (void *) sslState,
                sslState->timeout);
        } else {
@@ -157,17 +160,18 @@ sslReadServer(int fd, SslStateData * sslState)
     } else {
        sslState->server.offset = 0;
        sslState->server.len = len;
-       comm_set_select_handler(sslState->client.fd,
+       commSetSelect(sslState->client.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteClient,
-           (void *) sslState);
+           sslWriteClient,
+           (void *) sslState, 0);
     }
 }
 
 /* Read from client side and queue it for writing to the server */
 static void
-sslReadClient(int fd, SslStateData * sslState)
+sslReadClient(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     len = read(sslState->client.fd, sslState->client.buf, SQUID_TCP_SO_RCVBUF);
     debug(26, 5, "sslReadClient FD %d, read %d bytes\n",
@@ -178,10 +182,10 @@ sslReadClient(int fd, SslStateData * sslState)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(sslState->client.fd,
+           commSetSelect(sslState->client.fd,
                COMM_SELECT_READ,
-               (PF) sslReadClient,
-               (void *) sslState);
+               sslReadClient,
+               (void *) sslState, 0);
        } else {
            sslClose(sslState);
        }
@@ -191,17 +195,18 @@ sslReadClient(int fd, SslStateData * sslState)
     } else {
        sslState->client.offset = 0;
        sslState->client.len = len;
-       comm_set_select_handler(sslState->server.fd,
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteServer,
-           (void *) sslState);
+           sslWriteServer,
+           (void *) sslState, 0);
     }
 }
 
 /* Writes data from the client buffer to the server side */
 static void
-sslWriteServer(int fd, SslStateData * sslState)
+sslWriteServer(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     len = write(sslState->server.fd,
        sslState->client.buf + sslState->client.offset,
@@ -215,28 +220,29 @@ sslWriteServer(int fd, SslStateData * sslState)
     }
     if ((sslState->client.offset += len) >= sslState->client.len) {
        /* Done writing, read more */
-       comm_set_select_handler(sslState->client.fd,
+       commSetSelect(sslState->client.fd,
            COMM_SELECT_READ,
-           (PF) sslReadClient,
-           (void *) sslState);
-       comm_set_select_handler_plus_timeout(sslState->server.fd,
+           sslReadClient,
+           (void *) sslState, 0);
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_TIMEOUT,
-           (PF) sslReadTimeout,
+           sslReadTimeout,
            (void *) sslState,
            sslState->timeout);
     } else {
        /* still have more to write */
-       comm_set_select_handler(sslState->server.fd,
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteServer,
-           (void *) sslState);
+           sslWriteServer,
+           (void *) sslState, 0);
     }
 }
 
 /* Writes data from the server buffer to the client side */
 static void
-sslWriteClient(int fd, SslStateData * sslState)
+sslWriteClient(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     debug(26, 5, "sslWriteClient FD %d len=%d offset=%d\n",
        fd,
@@ -256,42 +262,44 @@ sslWriteClient(int fd, SslStateData * sslState)
        *sslState->size_ptr += len;     /* increment total object size */
     if ((sslState->server.offset += len) >= sslState->server.len) {
        /* Done writing, read more */
-       comm_set_select_handler(sslState->server.fd,
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_READ,
-           (PF) sslReadServer,
-           (void *) sslState);
+           sslReadServer,
+           (void *) sslState, 0);
     } else {
        /* still have more to write */
-       comm_set_select_handler(sslState->client.fd,
+       commSetSelect(sslState->client.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteClient,
-           (void *) sslState);
+           sslWriteClient,
+           (void *) sslState, 0);
     }
 }
 
 static void
-sslReadTimeout(int fd, SslStateData * sslState)
+sslReadTimeout(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslReadTimeout: FD %d\n", fd);
     sslClose(sslState);
 }
 
 static void
-sslConnected(int fd, SslStateData * sslState)
+sslConnected(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslConnected: FD %d sslState=%p\n", fd, sslState);
     strcpy(sslState->server.buf, conn_established);
     sslState->server.len = strlen(conn_established);
     sslState->server.offset = 0;
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_WRITE,
-       (PF) sslWriteClient,
-       (void *) sslState);
+       sslWriteClient,
+       (void *) sslState, 0);
     comm_set_fd_lifetime(fd, 86400);   /* extend lifetime */
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_READ,
-       (PF) sslReadClient,
-       (void *) sslState);
+       sslReadClient,
+       (void *) sslState, 0);
 }
 
 static void
@@ -329,18 +337,18 @@ sslConnect(int fd, ipcache_addrs * ia, void *data)
        sslState->client.fd,
        sslState->server.fd);
     /* Install lifetime handler */
-    comm_set_select_handler(sslState->server.fd,
+    commSetSelect(sslState->server.fd,
        COMM_SELECT_LIFETIME,
-       (PF) sslLifetimeExpire,
-       (void *) sslState);
+       sslLifetimeExpire,
+       (void *) sslState, 0);
     /* NOTE this changes the lifetime handler for the client side.
      * It used to be asciiConnLifetimeHandle, but it does funny things
      * like looking for read handlers and assuming it was still reading
      * the HTTP request.  sigh... */
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_LIFETIME,
-       (PF) sslLifetimeExpire,
-       (void *) sslState);
+       sslLifetimeExpire,
+       (void *) sslState, 0);
     sslState->connectState.fd = fd;
     sslState->connectState.host = sslState->host;
     sslState->connectState.port = sslState->port;
@@ -436,10 +444,10 @@ sslStart(int fd, char *url, request_t * request, char *mime_hdr, int *size_ptr)
        sslState->port = request->port;
     }
     comm_add_close_handler(sslState->server.fd,
-       (PF) sslStateFree,
+       sslStateFree,
        (void *) sslState);
     comm_add_close_handler(sslState->client.fd,
-       (PF) sslClientClosed,
+       sslClientClosed,
        (void *) sslState);
     ipcache_nbgethostbyname(sslState->host,
        sslState->server.fd,
@@ -449,20 +457,21 @@ sslStart(int fd, char *url, request_t * request, char *mime_hdr, int *size_ptr)
 }
 
 static void
-sslProxyConnected(int fd, SslStateData * sslState)
+sslProxyConnected(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslProxyConnected: FD %d sslState=%p\n", fd, sslState);
     sprintf(sslState->client.buf, "CONNECT %s HTTP/1.0\r\n\r\n", sslState->url);
     debug(26, 3, "sslProxyConnected: Sending 'CONNECT %s HTTP/1.0'\n", sslState->url);
     sslState->client.len = strlen(sslState->client.buf);
     sslState->client.offset = 0;
-    comm_set_select_handler(sslState->server.fd,
+    commSetSelect(sslState->server.fd,
        COMM_SELECT_WRITE,
-       (PF) sslWriteServer,
-       (void *) sslState);
+       sslWriteServer,
+       (void *) sslState, 0);
     comm_set_fd_lifetime(fd, 86400);   /* extend lifetime */
-    comm_set_select_handler(sslState->server.fd,
+    commSetSelect(sslState->server.fd,
        COMM_SELECT_READ,
-       (PF) sslReadServer,
-       (void *) sslState);
+       sslReadServer,
+       (void *) sslState, 0);
 }

diff --git a/src/tunnel.cc b/src/tunnel.cc
index ddddbc8053005219a837cd0f3ef53c56ee0d3e0b..9b7e9ea2fb82901a967fb4866076d72d281ed1c4 100644 (file)
--- a/src/tunnel.cc
+++ b/src/tunnel.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: tunnel.cc,v 1.19 1996/10/09 22:49:42 wessels Exp $
+ * $Id: tunnel.cc,v 1.20 1996/10/11 23:11:18 wessels Exp $
  *
  * DEBUG: section 26    Secure Sockets Layer Proxy
  * AUTHOR: Duane Wessels
@@ -50,19 +50,20 @@ typedef struct {
 
 static char conn_established[] = "HTTP/1.0 200 Connection established\r\n\r\n";
 
-static void sslLifetimeExpire _PARAMS((int fd, SslStateData * sslState));
-static void sslReadTimeout _PARAMS((int fd, SslStateData * sslState));
-static void sslReadServer _PARAMS((int fd, SslStateData * sslState));
-static void sslReadClient _PARAMS((int fd, SslStateData * sslState));
-static void sslWriteServer _PARAMS((int fd, SslStateData * sslState));
-static void sslWriteClient _PARAMS((int fd, SslStateData * sslState));
-static void sslConnected _PARAMS((int fd, SslStateData * sslState));
-static void sslProxyConnected _PARAMS((int fd, SslStateData * sslState));
+static void sslLifetimeExpire _PARAMS((int fd, void *));
+static void sslReadTimeout _PARAMS((int fd, void *));
+static void sslReadServer _PARAMS((int fd, void *));
+static void sslReadClient _PARAMS((int fd, void *));
+static void sslWriteServer _PARAMS((int fd, void *));
+static void sslWriteClient _PARAMS((int fd, void *));
+static void sslConnected _PARAMS((int fd, void *));
+static void sslProxyConnected _PARAMS((int fd, void *));
 static void sslConnect _PARAMS((int fd, ipcache_addrs *, void *));
 static void sslErrorComplete _PARAMS((int, char *, int, int, void *));
 static void sslClose _PARAMS((SslStateData * sslState));
-static int sslClientClosed _PARAMS((int fd, SslStateData * sslState));
+static void sslClientClosed _PARAMS((int fd, void *));
 static void sslConnectDone _PARAMS((int fd, int status, void *data));
+static void sslStateFree _PARAMS((int fd, void *data));
 
 static void
 sslClose(SslStateData * sslState)
@@ -70,7 +71,7 @@ sslClose(SslStateData * sslState)
     if (sslState->client.fd > -1) {
        /* remove the "unexpected" client close handler */
        comm_remove_close_handler(sslState->client.fd,
-           (PF) sslClientClosed,
+           sslClientClosed,
            (void *) sslState);
        comm_close(sslState->client.fd);
        sslState->client.fd = -1;
@@ -82,9 +83,10 @@ sslClose(SslStateData * sslState)
 
 /* This is called only if the client connect closes unexpectedly,
  * ie from icpDetectClientClose() */
-static int
-sslClientClosed(int fd, SslStateData * sslState)
+static void
+sslClientClosed(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslClientClosed: FD %d\n", fd);
     /* we have been called from comm_close for the client side, so
      * just need to clean up the server side */
@@ -93,34 +95,34 @@ sslClientClosed(int fd, SslStateData * sslState)
        sslState->request,
        no_addr);
     comm_close(sslState->server.fd);
-    return 0;
 }
 
-static int
-sslStateFree(int fd, SslStateData * sslState)
+static void
+sslStateFree(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslStateFree: FD %d, sslState=%p\n", fd, sslState);
     if (sslState == NULL)
-       return 1;
+       return;
     if (fd != sslState->server.fd)
        fatal_dump("sslStateFree: FD mismatch!\n");
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_READ,
        NULL,
-       NULL);
+       NULL, 0);
     safe_free(sslState->server.buf);
     safe_free(sslState->client.buf);
     xfree(sslState->url);
     requestUnlink(sslState->request);
     memset(sslState, '\0', sizeof(SslStateData));
     safe_free(sslState);
-    return 0;
 }
 
 /* This will be called when the server lifetime is expired. */
 static void
-sslLifetimeExpire(int fd, SslStateData * sslState)
+sslLifetimeExpire(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 4, "sslLifeTimeExpire: FD %d: URL '%s'>\n",
        fd, sslState->url);
     sslClose(sslState);
@@ -128,8 +130,9 @@ sslLifetimeExpire(int fd, SslStateData * sslState)
 
 /* Read from server side and queue it for writing to the client */
 static void
-sslReadServer(int fd, SslStateData * sslState)
+sslReadServer(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     len = read(sslState->server.fd, sslState->server.buf, SQUID_TCP_SO_RCVBUF);
     debug(26, 5, "sslReadServer FD %d, read %d bytes\n", fd, len);
@@ -139,13 +142,13 @@ sslReadServer(int fd, SslStateData * sslState)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(sslState->server.fd,
+           commSetSelect(sslState->server.fd,
                COMM_SELECT_READ,
-               (PF) sslReadServer,
-               (void *) sslState);
-           comm_set_select_handler_plus_timeout(sslState->server.fd,
+               sslReadServer,
+               (void *) sslState, 0);
+           commSetSelect(sslState->server.fd,
                COMM_SELECT_TIMEOUT,
-               (PF) sslReadTimeout,
+               sslReadTimeout,
                (void *) sslState,
                sslState->timeout);
        } else {
@@ -157,17 +160,18 @@ sslReadServer(int fd, SslStateData * sslState)
     } else {
        sslState->server.offset = 0;
        sslState->server.len = len;
-       comm_set_select_handler(sslState->client.fd,
+       commSetSelect(sslState->client.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteClient,
-           (void *) sslState);
+           sslWriteClient,
+           (void *) sslState, 0);
     }
 }
 
 /* Read from client side and queue it for writing to the server */
 static void
-sslReadClient(int fd, SslStateData * sslState)
+sslReadClient(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     len = read(sslState->client.fd, sslState->client.buf, SQUID_TCP_SO_RCVBUF);
     debug(26, 5, "sslReadClient FD %d, read %d bytes\n",
@@ -178,10 +182,10 @@ sslReadClient(int fd, SslStateData * sslState)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(sslState->client.fd,
+           commSetSelect(sslState->client.fd,
                COMM_SELECT_READ,
-               (PF) sslReadClient,
-               (void *) sslState);
+               sslReadClient,
+               (void *) sslState, 0);
        } else {
            sslClose(sslState);
        }
@@ -191,17 +195,18 @@ sslReadClient(int fd, SslStateData * sslState)
     } else {
        sslState->client.offset = 0;
        sslState->client.len = len;
-       comm_set_select_handler(sslState->server.fd,
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteServer,
-           (void *) sslState);
+           sslWriteServer,
+           (void *) sslState, 0);
     }
 }
 
 /* Writes data from the client buffer to the server side */
 static void
-sslWriteServer(int fd, SslStateData * sslState)
+sslWriteServer(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     len = write(sslState->server.fd,
        sslState->client.buf + sslState->client.offset,
@@ -215,28 +220,29 @@ sslWriteServer(int fd, SslStateData * sslState)
     }
     if ((sslState->client.offset += len) >= sslState->client.len) {
        /* Done writing, read more */
-       comm_set_select_handler(sslState->client.fd,
+       commSetSelect(sslState->client.fd,
            COMM_SELECT_READ,
-           (PF) sslReadClient,
-           (void *) sslState);
-       comm_set_select_handler_plus_timeout(sslState->server.fd,
+           sslReadClient,
+           (void *) sslState, 0);
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_TIMEOUT,
-           (PF) sslReadTimeout,
+           sslReadTimeout,
            (void *) sslState,
            sslState->timeout);
     } else {
        /* still have more to write */
-       comm_set_select_handler(sslState->server.fd,
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteServer,
-           (void *) sslState);
+           sslWriteServer,
+           (void *) sslState, 0);
     }
 }
 
 /* Writes data from the server buffer to the client side */
 static void
-sslWriteClient(int fd, SslStateData * sslState)
+sslWriteClient(int fd, void *data)
 {
+    SslStateData *sslState = data;
     int len;
     debug(26, 5, "sslWriteClient FD %d len=%d offset=%d\n",
        fd,
@@ -256,42 +262,44 @@ sslWriteClient(int fd, SslStateData * sslState)
        *sslState->size_ptr += len;     /* increment total object size */
     if ((sslState->server.offset += len) >= sslState->server.len) {
        /* Done writing, read more */
-       comm_set_select_handler(sslState->server.fd,
+       commSetSelect(sslState->server.fd,
            COMM_SELECT_READ,
-           (PF) sslReadServer,
-           (void *) sslState);
+           sslReadServer,
+           (void *) sslState, 0);
     } else {
        /* still have more to write */
-       comm_set_select_handler(sslState->client.fd,
+       commSetSelect(sslState->client.fd,
            COMM_SELECT_WRITE,
-           (PF) sslWriteClient,
-           (void *) sslState);
+           sslWriteClient,
+           (void *) sslState, 0);
     }
 }
 
 static void
-sslReadTimeout(int fd, SslStateData * sslState)
+sslReadTimeout(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslReadTimeout: FD %d\n", fd);
     sslClose(sslState);
 }
 
 static void
-sslConnected(int fd, SslStateData * sslState)
+sslConnected(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslConnected: FD %d sslState=%p\n", fd, sslState);
     strcpy(sslState->server.buf, conn_established);
     sslState->server.len = strlen(conn_established);
     sslState->server.offset = 0;
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_WRITE,
-       (PF) sslWriteClient,
-       (void *) sslState);
+       sslWriteClient,
+       (void *) sslState, 0);
     comm_set_fd_lifetime(fd, 86400);   /* extend lifetime */
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_READ,
-       (PF) sslReadClient,
-       (void *) sslState);
+       sslReadClient,
+       (void *) sslState, 0);
 }
 
 static void
@@ -329,18 +337,18 @@ sslConnect(int fd, ipcache_addrs * ia, void *data)
        sslState->client.fd,
        sslState->server.fd);
     /* Install lifetime handler */
-    comm_set_select_handler(sslState->server.fd,
+    commSetSelect(sslState->server.fd,
        COMM_SELECT_LIFETIME,
-       (PF) sslLifetimeExpire,
-       (void *) sslState);
+       sslLifetimeExpire,
+       (void *) sslState, 0);
     /* NOTE this changes the lifetime handler for the client side.
      * It used to be asciiConnLifetimeHandle, but it does funny things
      * like looking for read handlers and assuming it was still reading
      * the HTTP request.  sigh... */
-    comm_set_select_handler(sslState->client.fd,
+    commSetSelect(sslState->client.fd,
        COMM_SELECT_LIFETIME,
-       (PF) sslLifetimeExpire,
-       (void *) sslState);
+       sslLifetimeExpire,
+       (void *) sslState, 0);
     sslState->connectState.fd = fd;
     sslState->connectState.host = sslState->host;
     sslState->connectState.port = sslState->port;
@@ -436,10 +444,10 @@ sslStart(int fd, char *url, request_t * request, char *mime_hdr, int *size_ptr)
        sslState->port = request->port;
     }
     comm_add_close_handler(sslState->server.fd,
-       (PF) sslStateFree,
+       sslStateFree,
        (void *) sslState);
     comm_add_close_handler(sslState->client.fd,
-       (PF) sslClientClosed,
+       sslClientClosed,
        (void *) sslState);
     ipcache_nbgethostbyname(sslState->host,
        sslState->server.fd,
@@ -449,20 +457,21 @@ sslStart(int fd, char *url, request_t * request, char *mime_hdr, int *size_ptr)
 }
 
 static void
-sslProxyConnected(int fd, SslStateData * sslState)
+sslProxyConnected(int fd, void *data)
 {
+    SslStateData *sslState = data;
     debug(26, 3, "sslProxyConnected: FD %d sslState=%p\n", fd, sslState);
     sprintf(sslState->client.buf, "CONNECT %s HTTP/1.0\r\n\r\n", sslState->url);
     debug(26, 3, "sslProxyConnected: Sending 'CONNECT %s HTTP/1.0'\n", sslState->url);
     sslState->client.len = strlen(sslState->client.buf);
     sslState->client.offset = 0;
-    comm_set_select_handler(sslState->server.fd,
+    commSetSelect(sslState->server.fd,
        COMM_SELECT_WRITE,
-       (PF) sslWriteServer,
-       (void *) sslState);
+       sslWriteServer,
+       (void *) sslState, 0);
     comm_set_fd_lifetime(fd, 86400);   /* extend lifetime */
-    comm_set_select_handler(sslState->server.fd,
+    commSetSelect(sslState->server.fd,
        COMM_SELECT_READ,
-       (PF) sslReadServer,
-       (void *) sslState);
+       sslReadServer,
+       (void *) sslState, 0);
 }

diff --git a/src/wais.cc b/src/wais.cc
index 4a3174fea2fd91f18dfec94cc5b441e308037364..abebb02df41b5c2fc7a24dbe3bc6611c1fbc0821 100644 (file)
--- a/src/wais.cc
+++ b/src/wais.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: wais.cc,v 1.45 1996/10/09 22:49:45 wessels Exp $
+ * $Id: wais.cc,v 1.46 1996/10/11 23:11:19 wessels Exp $
  *
  * DEBUG: section 24    WAIS Relay
  * AUTHOR: Harvest Derived
@@ -147,7 +147,7 @@ waisReadReplyTimeout(int fd, WaisStateData * waisState)
     entry = waisState->entry;
     debug(24, 4, "waisReadReplyTimeout: Timeout on %d\n url: %s\n", fd, entry->url);
     squid_error_entry(entry, ERR_READ_TIMEOUT, NULL);
-    comm_set_select_handler(fd, COMM_SELECT_READ, 0, 0);
+    commSetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0);
     comm_close(fd);
 }
 
@@ -160,7 +160,7 @@ waisLifetimeExpire(int fd, WaisStateData * waisState)
     entry = waisState->entry;
     debug(24, 4, "waisLifeTimeExpire: FD %d: <URL:%s>\n", fd, entry->url);
     squid_error_entry(entry, ERR_LIFETIME_EXP, NULL);
-    comm_set_select_handler(fd, COMM_SELECT_READ | COMM_SELECT_WRITE, 0, 0);
+    commSetSelect(fd, COMM_SELECT_READ | COMM_SELECT_WRITE, NULL, NULL, 0);
     comm_close(fd);
 }
 
@@ -200,16 +200,16 @@ waisReadReply(int fd, WaisStateData * waisState)
        debug(24, 3, "                Current Gap: %d bytes\n", clen - off);
        /* reschedule, so it will automatically reactivated
         * when Gap is big enough. */
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) waisReadReply,
-           (void *) waisState);
+           (void *) waisState, 0);
        /* don't install read handler while we're above the gap */
-       comm_set_select_handler_plus_timeout(fd,
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
-           (PF) NULL,
-           (void *) NULL,
-           (time_t) 0);
+           NULL,
+           NULL,
+           0);
        if (!BIT_TEST(entry->flag, READ_DEFERRED)) {
            comm_set_fd_lifetime(fd, 3600);     /* limit during deferring */
            BIT_SET(entry->flag, READ_DEFERRED);
@@ -233,9 +233,9 @@ waisReadReply(int fd, WaisStateData * waisState)
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* reinstall handlers */
            /* XXX This may loop forever */
-           comm_set_select_handler(fd, COMM_SELECT_READ,
-               (PF) waisReadReply, (void *) waisState);
-           comm_set_select_handler_plus_timeout(fd, COMM_SELECT_TIMEOUT,
+           commSetSelect(fd, COMM_SELECT_READ,
+               (PF) waisReadReply, (void *) waisState, 0);
+           commSetSelect(fd, COMM_SELECT_TIMEOUT,
                (PF) waisReadReplyTimeout, (void *) waisState, Config.readTimeout);
        } else {
            BIT_RESET(entry->flag, ENTRY_CACHABLE);
@@ -258,22 +258,22 @@ waisReadReply(int fd, WaisStateData * waisState)
        /*  accept data, but start to delete behind it */
        storeStartDeleteBehind(entry);
        storeAppend(entry, buf, len);
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) waisReadReply,
-           (void *) waisState);
-       comm_set_select_handler_plus_timeout(fd,
+           (void *) waisState, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
            (PF) waisReadReplyTimeout,
            (void *) waisState,
            Config.readTimeout);
     } else {
        storeAppend(entry, buf, len);
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) waisReadReply,
-           (void *) waisState);
-       comm_set_select_handler_plus_timeout(fd,
+           (void *) waisState, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
            (PF) waisReadReplyTimeout,
            (void *) waisState,
@@ -296,11 +296,11 @@ waisSendComplete(int fd, char *buf, int size, int errflag, void *data)
        comm_close(fd);
     } else {
        /* Schedule read reply. */
-       comm_set_select_handler(fd,
+       commSetSelect(fd,
            COMM_SELECT_READ,
            (PF) waisReadReply,
-           (void *) waisState);
-       comm_set_select_handler_plus_timeout(fd,
+           (void *) waisState, 0);
+       commSetSelect(fd,
            COMM_SELECT_TIMEOUT,
            (PF) waisReadReplyTimeout,
            (void *) waisState,
@@ -415,12 +415,12 @@ waisConnectDone(int fd, int status, void *data)
     /* Install connection complete handler. */
     if (opt_no_ipcache)
        ipcacheInvalidate(waisState->relayhost);
-    comm_set_select_handler(fd,
+    commSetSelect(fd,
        COMM_SELECT_LIFETIME,
        (PF) waisLifetimeExpire,
-       (void *) waisState);
-    comm_set_select_handler(fd,
+       (void *) waisState, 0);
+    commSetSelect(fd,
        COMM_SELECT_WRITE,
        (PF) waisSendRequest,
-       (void *) waisState);
+       (void *) waisState, 0);
 }