SourceFormat Enforcement

[thirdparty/squid.git] / src / CommCalls.cc

diff --git a/src/CommCalls.cc b/src/CommCalls.cc
index b656b810405779c4710bc9fca3d8ed59ef70c443..3af2d2e14625c88b2ec0c5871fe46386b56b5c91 100644 (file)
--- a/src/CommCalls.cc
+++ b/src/CommCalls.cc
@@ -1,17 +1,27 @@
+/*
+ * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
 #include "squid.h"
-#include "fde.h"
+#include "anyp/PortCfg.h"
 #include "comm/Connection.h"
 #include "CommCalls.h"
+#include "fde.h"
+#include "globals.h"
 
 /* CommCommonCbParams */
 
 CommCommonCbParams::CommCommonCbParams(void *aData):
-        data(cbdataReference(aData)), conn(), flag(COMM_OK), xerrno(0), fd(-1)
+    data(cbdataReference(aData)), conn(), flag(Comm::OK), xerrno(0), fd(-1)
 {
 }
 
 CommCommonCbParams::CommCommonCbParams(const CommCommonCbParams &p):
-        data(cbdataReference(p.data)), conn(p.conn), flag(p.flag), xerrno(p.xerrno), fd(p.fd)
+    data(cbdataReference(p.data)), conn(p.conn), flag(p.flag), xerrno(p.xerrno), fd(p.fd)
 {
 }
 
@@ -30,25 +40,32 @@ CommCommonCbParams::print(std::ostream &os) const
 
     if (xerrno)
         os << ", errno=" << xerrno;
-    if (flag != COMM_OK)
+    if (flag != Comm::OK)
         os << ", flag=" << flag;
     if (data)
         os << ", data=" << data;
 }
 
-
 /* CommAcceptCbParams */
 
 CommAcceptCbParams::CommAcceptCbParams(void *aData):
-        CommCommonCbParams(aData)
+    CommCommonCbParams(aData), xaction()
 {
 }
 
+void
+CommAcceptCbParams::print(std::ostream &os) const
+{
+    CommCommonCbParams::print(os);
+
+    if (xaction != NULL)
+        os << ", " << xaction->id;
+}
 
 /* CommConnectCbParams */
 
 CommConnectCbParams::CommConnectCbParams(void *aData):
-        CommCommonCbParams(aData)
+    CommCommonCbParams(aData)
 {
 }
 
@@ -67,32 +84,22 @@ CommConnectCbParams::syncWithComm()
 /* CommIoCbParams */
 
 CommIoCbParams::CommIoCbParams(void *aData): CommCommonCbParams(aData),
-        buf(NULL), size(0)
+    buf(NULL), size(0)
 {
 }
 
 bool
 CommIoCbParams::syncWithComm()
 {
-    // transition only: read/write legacy code does not know about conn, it just sets FD
-    if (fd >= 0) {
-        if (conn == NULL)
-            conn = new Comm::Connection;
-        if (conn->fd != fd)
-            conn->fd = fd;
-    }
-
     // change parameters if the call was scheduled before comm_close but
     // is being fired after comm_close
-    if (conn->fd >= 0 && fd_table[conn->fd].closing() && flag != COMM_ERR_CLOSING) {
-        debugs(5, 3, HERE << "converting late call to COMM_ERR_CLOSING: " << conn);
-        flag = COMM_ERR_CLOSING;
-        size = 0;
+    if ((conn->fd < 0 || fd_table[conn->fd].closing()) && flag != Comm::ERR_CLOSING) {
+        debugs(5, 3, HERE << "converting late call to Comm::ERR_CLOSING: " << conn);
+        flag = Comm::ERR_CLOSING;
     }
     return true; // now we are in sync and can handle the call
 }
 
-
 void
 CommIoCbParams::print(std::ostream &os) const
 {
@@ -103,41 +110,46 @@ CommIoCbParams::print(std::ostream &os) const
     }
 }
 
-
 /* CommCloseCbParams */
 
 CommCloseCbParams::CommCloseCbParams(void *aData):
-        CommCommonCbParams(aData)
+    CommCommonCbParams(aData)
 {
 }
 
 /* CommTimeoutCbParams */
 
 CommTimeoutCbParams::CommTimeoutCbParams(void *aData):
-        CommCommonCbParams(aData)
+    CommCommonCbParams(aData)
 {
 }
 
+/* FdeCbParams */
+
+FdeCbParams::FdeCbParams(void *aData):
+    CommCommonCbParams(aData)
+{
+}
 
 /* CommAcceptCbPtrFun */
 
 CommAcceptCbPtrFun::CommAcceptCbPtrFun(IOACB *aHandler,
                                        const CommAcceptCbParams &aParams):
-        CommDialerParamsT<CommAcceptCbParams>(aParams),
-        handler(aHandler)
+    CommDialerParamsT<CommAcceptCbParams>(aParams),
+    handler(aHandler)
 {
 }
 
 CommAcceptCbPtrFun::CommAcceptCbPtrFun(const CommAcceptCbPtrFun &o):
-        CommDialerParamsT<CommAcceptCbParams>(o.params),
-        handler(o.handler)
+    CommDialerParamsT<CommAcceptCbParams>(o.params),
+    handler(o.handler)
 {
 }
 
 void
 CommAcceptCbPtrFun::dial()
 {
-    handler(params.fd, params.conn, params.flag, params.xerrno, params.data);
+    handler(params);
 }
 
 void
@@ -148,13 +160,12 @@ CommAcceptCbPtrFun::print(std::ostream &os) const
     os << ')';
 }
 
-
 /* CommConnectCbPtrFun */
 
 CommConnectCbPtrFun::CommConnectCbPtrFun(CNCB *aHandler,
         const CommConnectCbParams &aParams):
-        CommDialerParamsT<CommConnectCbParams>(aParams),
-        handler(aHandler)
+    CommDialerParamsT<CommConnectCbParams>(aParams),
+    handler(aHandler)
 {
 }
 
@@ -172,12 +183,11 @@ CommConnectCbPtrFun::print(std::ostream &os) const
     os << ')';
 }
 
-
 /* CommIoCbPtrFun */
 
 CommIoCbPtrFun::CommIoCbPtrFun(IOCB *aHandler, const CommIoCbParams &aParams):
-        CommDialerParamsT<CommIoCbParams>(aParams),
-        handler(aHandler)
+    CommDialerParamsT<CommIoCbParams>(aParams),
+    handler(aHandler)
 {
 }
 
@@ -195,20 +205,19 @@ CommIoCbPtrFun::print(std::ostream &os) const
     os << ')';
 }
 
-
 /* CommCloseCbPtrFun */
 
-CommCloseCbPtrFun::CommCloseCbPtrFun(PF *aHandler,
+CommCloseCbPtrFun::CommCloseCbPtrFun(CLCB *aHandler,
                                      const CommCloseCbParams &aParams):
-        CommDialerParamsT<CommCloseCbParams>(aParams),
-        handler(aHandler)
+    CommDialerParamsT<CommCloseCbParams>(aParams),
+    handler(aHandler)
 {
 }
 
 void
 CommCloseCbPtrFun::dial()
 {
-    handler(params.fd, params.data);
+    handler(params);
 }
 
 void
@@ -221,27 +230,17 @@ CommCloseCbPtrFun::print(std::ostream &os) const
 
 /* CommTimeoutCbPtrFun */
 
-CommTimeoutCbPtrFun::CommTimeoutCbPtrFun(PF *aHandler,
+CommTimeoutCbPtrFun::CommTimeoutCbPtrFun(CTCB *aHandler,
         const CommTimeoutCbParams &aParams):
-        CommDialerParamsT<CommTimeoutCbParams>(aParams),
-        handler(aHandler)
+    CommDialerParamsT<CommTimeoutCbParams>(aParams),
+    handler(aHandler)
 {
 }
 
 void
 CommTimeoutCbPtrFun::dial()
 {
-    // AYJ NP: since the old code is still used by pipes and IPC
-    // we cant discard the params.fd functions entirely for old callbacks.
-    // new callers supposed to only set conn.
-    // sync FD and conn fields at this single failure point before dialing.
-    if (params.conn != NULL) {
-        if (params.fd < 0 && params.conn->fd > 0)
-            params.fd = params.conn->fd;
-        assert(params.fd == params.conn->fd); // Must() ?
-    }
-
-    handler(params.fd, params.data);
+    handler(params);
 }
 
 void
@@ -251,3 +250,26 @@ CommTimeoutCbPtrFun::print(std::ostream &os) const
     params.print(os);
     os << ')';
 }
+
+/* FdeCbPtrFun */
+
+FdeCbPtrFun::FdeCbPtrFun(FDECB *aHandler, const FdeCbParams &aParams) :
+    CommDialerParamsT<FdeCbParams>(aParams),
+    handler(aHandler)
+{
+}
+
+void
+FdeCbPtrFun::dial()
+{
+    handler(params);
+}
+
+void
+FdeCbPtrFun::print(std::ostream &os) const
+{
+    os << '(';
+    params.print(os);
+    os << ')';
+}
+