Renamed squid.h to squid-old.h and config.h to squid.h

[thirdparty/squid.git] / src / ident / Ident.cc

diff --git a/src/ident/Ident.cc b/src/ident/Ident.cc
index 1955f182412bc0fd62c9b3e57338593c60b9e536..46d97b851f45df28cbc687dd5555b7370e563c53 100644 (file)
--- a/src/ident/Ident.cc
+++ b/src/ident/Ident.cc
@@ -32,7 +32,7 @@
  *
  */
 
-#include "squid.h"
+#include "squid-old.h"
 
 #if USE_IDENT
 
@@ -40,6 +40,7 @@
 #include "comm/Connection.h"
 #include "comm/ConnOpener.h"
 #include "CommCalls.h"
+#include "comm/Write.h"
 #include "ident/Config.h"
 #include "ident/Ident.h"
 #include "MemBuf.h"
@@ -49,6 +50,7 @@ namespace Ident
 
 #define IDENT_PORT 113
 #define IDENT_KEY_SZ 50
+#define IDENT_BUFSIZE 4096
 
 typedef struct _IdentClient {
     IDCB *callback;
@@ -61,19 +63,19 @@ typedef struct _IdentStateData {
     hash_link hash;            /* must be first */
     Comm::ConnectionPointer conn;
     IdentClient *clients;
-    char buf[4096];
+    char buf[IDENT_BUFSIZE];
 } IdentStateData;
 
-// TODO: make these all a series of Async jobs. They are self-contained callbacks now.
+// TODO: make these all a series of Async job calls. They are self-contained callbacks now.
 static IOCB ReadReply;
-static PF Close;
-static PF Timeout;
+static CLCB Close;
+static CTCB Timeout;
 static CNCB ConnectDone;
 static hash_table *ident_hash = NULL;
 static void ClientAdd(IdentStateData * state, IDCB * callback, void *callback_data);
 static void identCallback(IdentStateData * state, char *result);
 
-}; // namespace Ident
+} // namespace Ident
 
 Ident::IdentConfig Ident::TheConfig;
 
@@ -99,9 +101,9 @@ Ident::identCallback(IdentStateData * state, char *result)
 }
 
 void
-Ident::Close(int fdnotused, void *data)
+Ident::Close(const CommCloseCbParams &params)
 {
-    IdentStateData *state = (IdentStateData *)data;
+    IdentStateData *state = (IdentStateData *)params.data;
     identCallback(state, NULL);
     state->conn->close();
     hash_remove_link(ident_hash, (hash_link *) state);
@@ -110,15 +112,14 @@ Ident::Close(int fdnotused, void *data)
 }
 
 void
-Ident::Timeout(int fd, void *data)
+Ident::Timeout(const CommTimeoutCbParams &io)
 {
-    IdentStateData *state = (IdentStateData *)data;
-    debugs(30, 3, HERE << "FD " << fd << ", " << state->conn->remote);
-    state->conn->close();
+    debugs(30, 3, HERE << io.conn);
+    io.conn->close();
 }
 
 void
-Ident::ConnectDone(Comm::ConnectionPointer &conn, comm_err_t status, int xerrno, void *data)
+Ident::ConnectDone(const Comm::ConnectionPointer &conn, comm_err_t status, int xerrno, void *data)
 {
     IdentStateData *state = (IdentStateData *)data;
 
@@ -153,20 +154,25 @@ Ident::ConnectDone(Comm::ConnectionPointer &conn, comm_err_t status, int xerrno,
     mb.Printf("%d, %d\r\n",
               conn->remote.GetPort(),
               conn->local.GetPort());
-    comm_write_mbuf(conn->fd, &mb, NULL, state);
-    comm_read(conn->fd, state->buf, BUFSIZ, Ident::ReadReply, state);
-    commSetTimeout(conn->fd, Ident::TheConfig.timeout, Ident::Timeout, state);
+    AsyncCall::Pointer nil;
+    Comm::Write(conn, &mb, nil);
+    AsyncCall::Pointer readCall = commCbCall(5,4, "Ident::ReadReply",
+                                  CommIoCbPtrFun(Ident::ReadReply, state));
+    comm_read(conn, state->buf, IDENT_BUFSIZE, readCall);
+    AsyncCall::Pointer timeoutCall = commCbCall(5,4, "Ident::Timeout",
+                                     CommTimeoutCbPtrFun(Ident::Timeout, state));
+    commSetConnTimeout(conn, Ident::TheConfig.timeout, timeoutCall);
 }
 
 void
-Ident::ReadReply(int fd, char *buf, size_t len, comm_err_t flag, int xerrno, void *data)
+Ident::ReadReply(const Comm::ConnectionPointer &conn, char *buf, size_t len, comm_err_t flag, int xerrno, void *data)
 {
     IdentStateData *state = (IdentStateData *)data;
     char *ident = NULL;
     char *t = NULL;
 
     assert(buf == state->buf);
-    assert(fd == state->conn->fd);
+    assert(conn->fd == state->conn->fd);
 
     if (flag != COMM_OK || len <= 0) {
         state->conn->close();
@@ -186,7 +192,7 @@ Ident::ReadReply(int fd, char *buf, size_t len, comm_err_t flag, int xerrno, voi
     if ((t = strchr(buf, '\n')))
         *t = '\0';
 
-    debugs(30, 5, HERE << "FD " << fd << ": Read '" << buf << "'");
+    debugs(30, 5, HERE << conn << ": Read '" << buf << "'");
 
     if (strstr(buf, "USERID")) {
         if ((ident = strrchr(buf, ':'))) {
@@ -218,7 +224,7 @@ CBDATA_TYPE(IdentStateData);
  * start a TCP connection to the peer host on port 113
  */
 void
-Ident::Start(Comm::ConnectionPointer &conn, IDCB * callback, void *data)
+Ident::Start(const Comm::ConnectionPointer &conn, IDCB * callback, void *data)
 {
     IdentStateData *state;
     char key1[IDENT_KEY_SZ];
@@ -250,7 +256,7 @@ Ident::Start(Comm::ConnectionPointer &conn, IDCB * callback, void *data)
     hash_join(ident_hash, &state->hash);
 
     AsyncCall::Pointer call = commCbCall(30,3, "Ident::ConnectDone", CommConnectCbPtrFun(Ident::ConnectDone, state));
-    AsyncJob::AsyncStart(new Comm::ConnOpener(state->conn, call, Ident::TheConfig.timeout));
+    AsyncJob::Start(new Comm::ConnOpener(state->conn, call, Ident::TheConfig.timeout));
 }
 
 void