From: Amos Jeffries <squid3@treenet.co.nz>
Date: Sat, 2 Oct 2010 11:27:52 +0000 (+1300)
Subject: Transition comm_read() from FD to Comm::Connection
X-Git-Tag: take08~55^2~124^2~53
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=ec20038e91fc1bf386a469d9a86fe0354f330cff;p=thirdparty%2Fsquid.git

Transition comm_read() from FD to Comm::Connection
---

diff --git a/src/adaptation/icap/Xaction.cc b/src/adaptation/icap/Xaction.cc
index f8642eeeac..7a286872eb 100644
--- a/src/adaptation/icap/Xaction.cc
+++ b/src/adaptation/icap/Xaction.cc
@@ -330,7 +330,7 @@ void Adaptation::Icap::Xaction::scheduleRead()
      */
     typedef CommCbMemFunT<Adaptation::Icap::Xaction, CommIoCbParams> Dialer;
     reader = JobCallback(93, 3, Dialer, this, Adaptation::Icap::Xaction::noteCommRead);
-    comm_read(connection->fd, commBuf, readBuf.spaceSize(), reader);
+    comm_read(connection, commBuf, readBuf.spaceSize(), reader);
     updateTimeout();
 }
 
diff --git a/src/client_side.cc b/src/client_side.cc
index 9e4e1c071e..7990d79da8 100644
--- a/src/client_side.cc
+++ b/src/client_side.cc
@@ -242,7 +242,7 @@ ConnStateData::readSomeData()
 
     typedef CommCbMemFunT<ConnStateData, CommIoCbParams> Dialer;
     reader = JobCallback(33, 5, Dialer, this, ConnStateData::clientReadRequest);
-    comm_read(clientConn->fd, in.addressToReadInto(), getAvailableBufferLength(), reader);
+    comm_read(clientConn, in.addressToReadInto(), getAvailableBufferLength(), reader);
 }
 
 
diff --git a/src/comm.cc b/src/comm.cc
index 9afff0463f..9ebd0d6fd8 100644
--- a/src/comm.cc
+++ b/src/comm.cc
@@ -273,35 +273,35 @@ commHandleRead(int fd, void *data)
  * completes, on error, or on file descriptor close.
  */
 void
-comm_read(int fd, char *buf, int size, IOCB *handler, void *handler_data)
+comm_read(const Comm::ConnectionPointer &conn, char *buf, int size, IOCB *handler, void *handler_data)
 {
     AsyncCall::Pointer call = commCbCall(5,4, "SomeCommReadHandler",
                                          CommIoCbPtrFun(handler, handler_data));
-    comm_read(fd, buf, size, call);
+    comm_read(conn, buf, size, call);
 }
 
 void
-comm_read(int fd, char *buf, int size, AsyncCall::Pointer &callback)
+comm_read(const Comm::ConnectionPointer &conn, char *buf, int size, AsyncCall::Pointer &callback)
 {
-    debugs(5, 5, "comm_read, queueing read for FD " << fd << "; asynCall " << callback);
+    debugs(5, 5, "comm_read, queueing read for " << conn << "; asynCall " << callback);
 
     /* Make sure we are open and not closing */
-    assert(isOpen(fd));
-    assert(!fd_table[fd].closing());
-    comm_io_callback_t *ccb = COMMIO_FD_READCB(fd);
+    assert(Comm::IsConnOpen(conn));
+    assert(!fd_table[conn->fd].closing());
+    comm_io_callback_t *ccb = COMMIO_FD_READCB(conn->fd);
 
     // Make sure we are either not reading or just passively monitoring.
     // Active/passive conflicts are OK and simply cancel passive monitoring.
     if (ccb->active()) {
         // if the assertion below fails, we have an active comm_read conflict
-        assert(fd_table[fd].halfClosedReader != NULL);
-        commStopHalfClosedMonitor(fd);
+        assert(fd_table[conn->fd].halfClosedReader != NULL);
+        commStopHalfClosedMonitor(conn->fd);
         assert(!ccb->active());
     }
 
     /* Queue the read */
-    commio_set_callback(fd, IOCB_READ, ccb, callback, (char *)buf, NULL, size);
-    commSetSelect(fd, COMM_SELECT_READ, commHandleRead, ccb, 0);
+    commio_set_callback(conn->fd, IOCB_READ, ccb, callback, (char *)buf, NULL, size);
+    commSetSelect(conn->fd, COMM_SELECT_READ, commHandleRead, ccb, 0);
 }
 
 /**
@@ -1973,13 +1973,15 @@ commHalfClosedCheck(void *)
     typedef DescriptorSet::const_iterator DSCI;
     const DSCI end = TheHalfClosed->end();
     for (DSCI i = TheHalfClosed->begin(); i != end; ++i) {
-        const int fd = *i;
-        if (!fd_table[fd].halfClosedReader) { // not reading already
+        Comm::ConnectionPointer c = new Comm::Connection; // XXX: temporary. make HalfClosed a list of these.
+        c->fd = *i;
+        if (!fd_table[c->fd].halfClosedReader) { // not reading already
             AsyncCall::Pointer call = commCbCall(5,4, "commHalfClosedReader",
                                                  CommIoCbPtrFun(&commHalfClosedReader, NULL));
-            comm_read(fd, NULL, 0, call);
-            fd_table[fd].halfClosedReader = call;
-        }
+            comm_read(c, NULL, 0, call);
+            fd_table[c->fd].halfClosedReader = call;
+        } else
+            c->fd = -1; // XXX: temporary. prevent c replacement erase closing listed FD
     }
 
     WillCheckHalfClosed = false; // as far as we know
diff --git a/src/comm.h b/src/comm.h
index 703cf32c53..aadecae261 100644
--- a/src/comm.h
+++ b/src/comm.h
@@ -76,7 +76,7 @@ extern int commSetTimeout(int fd, int, AsyncCall::Pointer &callback);
  * Set or clear the timeout for some action on an active connection.
  * API to replace commSetTimeout() when a Comm::ConnectionPointer is available.
  */
-extern int commSetConnTimeout(const Comm::ConnectionPointer &conn, int seconds, AsyncCall::Pointer &calback);
+extern int commSetConnTimeout(const Comm::ConnectionPointer &conn, int seconds, AsyncCall::Pointer &callback);
 
 SQUIDCEXTERN int ignoreErrno(int);
 SQUIDCEXTERN void commCloseAllSockets(void);
@@ -99,8 +99,8 @@ extern void comm_remove_close_handler(int fd, AsyncCall::Pointer &);
 
 extern int comm_has_pending_read_callback(int fd);
 extern bool comm_monitors_read(int fd);
-extern void comm_read(int fd, char *buf, int len, IOCB *handler, void *data);
-extern void comm_read(int fd, char *buf, int len, AsyncCall::Pointer &callback);
+extern void comm_read(const Comm::ConnectionPointer &conn, char *buf, int len, IOCB *handler, void *data);
+extern void comm_read(const Comm::ConnectionPointer &conn, char *buf, int len, AsyncCall::Pointer &callback);
 extern void comm_read_cancel(int fd, IOCB *callback, void *data);
 extern void comm_read_cancel(int fd, AsyncCall::Pointer &callback);
 extern int comm_udp_recvfrom(int fd, void *buf, size_t len, int flags, Ip::Address &from);
diff --git a/src/dns_internal.cc b/src/dns_internal.cc
index 55f683ed66..11fb152f8c 100644
--- a/src/dns_internal.cc
+++ b/src/dns_internal.cc
@@ -724,7 +724,7 @@ idnsInitVCConnected(const Comm::ConnectionPointer &conn, comm_err_t status, int
     vc->conn = conn;
 
     comm_add_close_handler(conn->fd, idnsVCClosed, vc);
-    comm_read(conn->fd, (char *)&vc->msglen, 2 , idnsReadVCHeader, vc);
+    comm_read(conn, (char *)&vc->msglen, 2 , idnsReadVCHeader, vc);
     vc->busy = 0;
     idnsDoSendQueryVC(vc);
 }
@@ -1273,7 +1273,7 @@ idnsReadVC(const Comm::ConnectionPointer &conn, char *buf, size_t len, comm_err_
     vc->msg->size += len;       // XXX should not access -> size directly
 
     if (vc->msg->contentSize() < vc->msglen) {
-        comm_read(conn->fd, buf + len, vc->msglen - vc->msg->contentSize(), idnsReadVC, vc);
+        comm_read(conn, buf + len, vc->msglen - vc->msg->contentSize(), idnsReadVC, vc);
         return;
     }
 
@@ -1282,7 +1282,7 @@ idnsReadVC(const Comm::ConnectionPointer &conn, char *buf, size_t len, comm_err_
 
     idnsGrokReply(vc->msg->buf, vc->msg->contentSize());
     vc->msg->clean();
-    comm_read(conn->fd, (char *)&vc->msglen, 2 , idnsReadVCHeader, vc);
+    comm_read(conn, (char *)&vc->msglen, 2 , idnsReadVCHeader, vc);
 }
 
 static void
@@ -1306,7 +1306,7 @@ idnsReadVCHeader(const Comm::ConnectionPointer &conn, char *buf, size_t len, com
     assert(vc->read_msglen <= 2);
 
     if (vc->read_msglen < 2) {
-        comm_read(conn->fd, buf + len, 2 - vc->read_msglen, idnsReadVCHeader, vc);
+        comm_read(conn, buf + len, 2 - vc->read_msglen, idnsReadVCHeader, vc);
         return;
     }
 
@@ -1315,7 +1315,7 @@ idnsReadVCHeader(const Comm::ConnectionPointer &conn, char *buf, size_t len, com
     vc->msglen = ntohs(vc->msglen);
 
     vc->msg->init(vc->msglen, vc->msglen);
-    comm_read(conn->fd, vc->msg->buf, vc->msglen, idnsReadVC, vc);
+    comm_read(conn, vc->msg->buf, vc->msglen, idnsReadVC, vc);
 }
 
 /*
diff --git a/src/ftp.cc b/src/ftp.cc
index debc7ad16c..9b34c69a95 100644
--- a/src/ftp.cc
+++ b/src/ftp.cc
@@ -1701,7 +1701,7 @@ FtpStateData::scheduleReadControlReply(int buffered_ok)
 
         typedef CommCbMemFunT<FtpStateData, CommIoCbParams> Dialer;
         AsyncCall::Pointer reader = JobCallback(9, 5, Dialer, this, FtpStateData::ftpReadControlReply);
-        comm_read(ctrl.conn->fd, ctrl.buf + ctrl.offset, ctrl.size - ctrl.offset, reader);
+        comm_read(ctrl.conn, ctrl.buf + ctrl.offset, ctrl.size - ctrl.offset, reader);
     }
 }
 
diff --git a/src/gopher.cc b/src/gopher.cc
index 6ad1e81249..48f411c6b7 100644
--- a/src/gopher.cc
+++ b/src/gopher.cc
@@ -866,7 +866,7 @@ gopherReadReply(const Comm::ConnectionPointer &conn, char *buf, size_t len, comm
     }
 
     if (do_next_read)
-        comm_read(conn->fd, buf, read_sz, gopherReadReply, gopherState);
+        comm_read(conn, buf, read_sz, gopherReadReply, gopherState);
 
     return;
 }
diff --git a/src/helper.cc b/src/helper.cc
index 15995d3145..2e0b5883c9 100644
--- a/src/helper.cc
+++ b/src/helper.cc
@@ -233,7 +233,7 @@ helperOpenServers(helper * hlp)
 
         comm_add_close_handler(rfd, helperServerFree, srv);
 
-        comm_read(srv->readPipe->fd, srv->rbuf, srv->rbuf_sz - 1, helperHandleRead, srv);
+        comm_read(srv->readPipe, srv->rbuf, srv->rbuf_sz - 1, helperHandleRead, srv);
     }
 
     hlp->last_restart = squid_curtime;
@@ -351,7 +351,7 @@ helperStatefulOpenServers(statefulhelper * hlp)
 
         comm_add_close_handler(rfd, helperStatefulServerFree, srv);
 
-        comm_read(srv->readPipe->fd, srv->rbuf, srv->rbuf_sz - 1, helperStatefulHandleRead, srv);
+        comm_read(srv->readPipe, srv->rbuf, srv->rbuf_sz - 1, helperStatefulHandleRead, srv);
     }
 
     hlp->last_restart = squid_curtime;
@@ -896,7 +896,7 @@ helperHandleRead(const Comm::ConnectionPointer &conn, char *buf, size_t len, com
     }
 
     if (Comm::IsConnOpen(srv->readPipe))
-        comm_read(srv->readPipe->fd, srv->rbuf + srv->roffset, srv->rbuf_sz - srv->roffset - 1, helperHandleRead, srv);
+        comm_read(srv->readPipe, srv->rbuf + srv->roffset, srv->rbuf_sz - srv->roffset - 1, helperHandleRead, srv);
 }
 
 static void
@@ -976,7 +976,7 @@ helperStatefulHandleRead(const Comm::ConnectionPointer &conn, char *buf, size_t
     }
 
     if (Comm::IsConnOpen(srv->readPipe))
-        comm_read(srv->readPipe->fd, srv->rbuf + srv->roffset, srv->rbuf_sz - srv->roffset - 1,
+        comm_read(srv->readPipe, srv->rbuf + srv->roffset, srv->rbuf_sz - srv->roffset - 1,
                   helperStatefulHandleRead, srv);
 }
 
diff --git a/src/ident/Ident.cc b/src/ident/Ident.cc
index a4a3b78b15..ecc069b6b0 100644
--- a/src/ident/Ident.cc
+++ b/src/ident/Ident.cc
@@ -155,7 +155,7 @@ Ident::ConnectDone(const Comm::ConnectionPointer &conn, comm_err_t status, int x
               conn->remote.GetPort(),
               conn->local.GetPort());
     comm_write_mbuf(conn, &mb, NULL, state);
-    comm_read(conn->fd, state->buf, BUFSIZ, Ident::ReadReply, state);
+    comm_read(conn, state->buf, BUFSIZ, Ident::ReadReply, state);
     commSetTimeout(conn->fd, Ident::TheConfig.timeout, Ident::Timeout, state);
 }
 
diff --git a/src/ipc/Port.cc b/src/ipc/Port.cc
index ccf6ecbee2..1b02099a6a 100644
--- a/src/ipc/Port.cc
+++ b/src/ipc/Port.cc
@@ -34,7 +34,7 @@ void Ipc::Port::listen()
     typedef CommCbMemFunT<Port, CommIoCbParams> Dialer;
     AsyncCall::Pointer readHandler = JobCallback(54, 6,
                                      Dialer, this, Port::noteRead);
-    comm_read(conn()->fd, buf.raw(), buf.size(), readHandler);
+    comm_read(conn(), buf.raw(), buf.size(), readHandler);
 }
 
 bool Ipc::Port::doneAll() const
diff --git a/src/pconn.cc b/src/pconn.cc
index d8a1e593ca..21b91e6121 100644
--- a/src/pconn.cc
+++ b/src/pconn.cc
@@ -126,8 +126,10 @@ IdleConnList::push(int fd)
     }
 
     fds[nfds++] = fd;
-    comm_read(fd, fakeReadBuf, sizeof(fakeReadBuf), IdleConnList::read, this);
-    commSetTimeout(fd, Config.Timeout.pconn, IdleConnList::timeout, this);
+    Comm::ConnectionPointer temp = new Comm::Connection; // XXX: transition. until pconn's converted to store Comm::Connection
+    temp->fd = fd; // assume control of the fd.
+    comm_read(temp, fakeReadBuf, sizeof(fakeReadBuf), IdleConnList::read, this);
+    commSetTimeout(temp->fd, Config.Timeout.pconn, IdleConnList::timeout, this);
 }
 
 /*
diff --git a/src/store.cc b/src/store.cc
index ab8d7fd275..7767dffdaa 100644
--- a/src/store.cc
+++ b/src/store.cc
@@ -34,24 +34,25 @@
  */
 
 #include "squid.h"
+#include "CacheManager.h"
+#include "comm/Connection.h"
 #include "event.h"
+#if DELAY_POOLS
+#include "DelayPools.h"
+#endif
 #include "fde.h"
-#include "Store.h"
-#include "CacheManager.h"
-#include "StoreClient.h"
-#include "stmem.h"
 #include "HttpReply.h"
 #include "HttpRequest.h"
-#include "MemObject.h"
 #include "mem_node.h"
-#include "StoreMeta.h"
-#include "SwapDir.h"
-#if DELAY_POOLS
-#include "DelayPools.h"
-#endif
-#include "Stack.h"
+#include "MemObject.h"
 #include "SquidTime.h"
+#include "Stack.h"
+#include "stmem.h"
+#include "Store.h"
+#include "StoreClient.h"
+#include "StoreMeta.h"
 #include "swap_log_op.h"
+#include "SwapDir.h"
 
 static STMCB storeWriteComplete;
 
@@ -257,11 +258,13 @@ StoreEntry::delayAwareRead(int fd, char *buf, int len, AsyncCall::Pointer callba
 
     }
 
-    comm_read(fd, buf, amountToRead, callback);
+    Comm::ConnectionPointer temp = new Comm::Connection; // XXX: transition. until conn passed in.
+    temp->fd = fd;
+    comm_read(temp, buf, amountToRead, callback);
 }
 
 size_t
-StoreEntry::bytesWanted (Range<size_t> const aRange) const
+StoreEntry::bytesWanted(Range<size_t> const aRange) const
 {
     assert (aRange.size());
 
diff --git a/src/tests/stub_comm.cc b/src/tests/stub_comm.cc
index 132d5732de..95a94f2348 100644
--- a/src/tests/stub_comm.cc
+++ b/src/tests/stub_comm.cc
@@ -60,13 +60,13 @@ DeferredReadManager::kickReads(int const count)
 }
 
 void
-comm_read(int fd, char *buf, int size, IOCB *handler, void *handler_data)
+comm_read(const Comm::ConnectionPointer &conn, char *buf, int size, IOCB *handler, void *handler_data)
 {
     fatal ("Not implemented");
 }
 
 void
-comm_read(int, char*, int, AsyncCall::Pointer &callback)
+comm_read(const Comm::ConnectionPointer &conn, char*, int, AsyncCall::Pointer &callback)
 {
     fatal ("Not implemented");
 }
diff --git a/src/tunnel.cc b/src/tunnel.cc
index 5d9d90f8ed..1c1c0a6a09 100644
--- a/src/tunnel.cc
+++ b/src/tunnel.cc
@@ -454,7 +454,7 @@ void
 TunnelStateData::copyRead(Connection &from, IOCB *completion)
 {
     assert(from.len == 0);
-    comm_read(from.conn->fd, from.buf, from.bytesWanted(1, SQUID_TCP_SO_RCVBUF), completion, this);
+    comm_read(from.conn, from.buf, from.bytesWanted(1, SQUID_TCP_SO_RCVBUF), completion, this);
 }
 
 static void
diff --git a/src/whois.cc b/src/whois.cc
index 540c7f6d91..c786686442 100644
--- a/src/whois.cc
+++ b/src/whois.cc
@@ -101,7 +101,7 @@ whoisStart(FwdState * fwd)
     snprintf(buf, l, SQUIDSTRINGPH"\r\n", SQUIDSTRINGPRINT(str_print));
 
     comm_write(fwd->serverConnection(), buf, strlen(buf), whoisWriteComplete, p, NULL);
-    comm_read(fwd->serverConnection()->fd, p->buf, BUFSIZ, whoisReadReply, p);
+    comm_read(fwd->serverConnection(), p->buf, BUFSIZ, whoisReadReply, p);
     commSetTimeout(fwd->serverConnection()->fd, Config.Timeout.read, whoisTimeout, p);
 }
 
@@ -194,7 +194,7 @@ WhoisState::readReply(const Comm::ConnectionPointer &conn, char *aBuffer, size_t
     }
 
     if (do_next_read)
-        comm_read(conn->fd, aBuffer, BUFSIZ, whoisReadReply, this);
+        comm_read(conn, aBuffer, BUFSIZ, whoisReadReply, this);
 }
 
 static void