/*
- * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
+ * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
*
* Squid software is distributed under GPLv2+ license and includes
* contributions from numerous individuals and organizations.
#include "squid.h"
#if USE_IDENT
+#include "base/JobWait.h"
#include "comm.h"
#include "comm/Connection.h"
#include "comm/ConnOpener.h"
Comm::ConnectionPointer conn;
MemBuf queryMsg; ///< the lookup message sent to IDENT server
- IdentClient *clients;
+ IdentClient *clients = nullptr;
char buf[IDENT_BUFSIZE];
+
+ /// waits for a connection to the IDENT server to be established/opened
+ JobWait<Comm::ConnOpener> connWait;
+
+private:
+ // use deleteThis() to destroy
+ ~IdentStateData();
};
CBDATA_CLASS_INIT(IdentStateData);
static CLCB Close;
static CTCB Timeout;
static CNCB ConnectDone;
-static hash_table *ident_hash = NULL;
+static hash_table *ident_hash = nullptr;
static void ClientAdd(IdentStateData * state, IDCB * callback, void *callback_data);
} // namespace Ident
Ident::IdentConfig Ident::TheConfig;
void
-Ident::IdentStateData::deleteThis(const char *)
+Ident::IdentStateData::deleteThis(const char *reason)
{
+ debugs(30, 3, reason);
swanSong();
delete this;
}
void
Ident::IdentStateData::swanSong()
{
- if (clients != NULL)
- notify(NULL);
+ if (clients != nullptr)
+ notify(nullptr);
+}
+
+Ident::IdentStateData::~IdentStateData() {
+ assert(!clients);
if (Comm::IsConnOpen(conn)) {
comm_remove_close_handler(conn->fd, Ident::Close, this);
Ident::Close(const CommCloseCbParams ¶ms)
{
IdentStateData *state = (IdentStateData *)params.data;
+ if (state->conn) {
+ state->conn->noteClosure();
+ state->conn = nullptr;
+ }
state->deleteThis("connection closed");
}
void
Ident::Timeout(const CommTimeoutCbParams &io)
{
- debugs(30, 3, HERE << io.conn);
+ debugs(30, 3, io.conn);
IdentStateData *state = (IdentStateData *)io.data;
state->deleteThis("timeout");
}
Ident::ConnectDone(const Comm::ConnectionPointer &conn, Comm::Flag status, int, void *data)
{
IdentStateData *state = (IdentStateData *)data;
+ state->connWait.finish();
+
+ // Start owning the supplied connection (so that it is not orphaned if this
+ // function bails early). As a (tiny) optimization or perhaps just diff
+ // minimization, the close handler is added later, when we know we are not
+ // bailing. This delay is safe because comm_remove_close_handler() forgives
+ // missing handlers.
+ assert(conn); // but may be closed
+ assert(!state->conn);
+ state->conn = conn;
if (status != Comm::OK) {
if (status == Comm::TIMEOUT)
break;
}
- if (c == NULL) {
+ if (c == nullptr) {
state->deleteThis("client(s) aborted");
return;
}
- assert(conn != NULL && conn == state->conn);
- comm_add_close_handler(conn->fd, Ident::Close, state);
+ assert(state->conn->isOpen());
+ comm_add_close_handler(state->conn->fd, Ident::Close, state);
AsyncCall::Pointer writeCall = commCbCall(5,4, "Ident::WriteFeedback",
CommIoCbPtrFun(Ident::WriteFeedback, state));
void
Ident::WriteFeedback(const Comm::ConnectionPointer &conn, char *, size_t len, Comm::Flag flag, int xerrno, void *data)
{
- debugs(30, 5, HERE << conn << ": Wrote IDENT request " << len << " bytes.");
+ debugs(30, 5, conn << ": Wrote IDENT request " << len << " bytes.");
// TODO handle write errors better. retry or abort?
if (flag != Comm::OK) {
- debugs(30, 2, HERE << conn << " err-flags=" << flag << " IDENT write error: " << xstrerr(xerrno));
+ debugs(30, 2, conn << " err-flags=" << flag << " IDENT write error: " << xstrerr(xerrno));
IdentStateData *state = (IdentStateData *)data;
state->deleteThis("write error");
}
Ident::ReadReply(const Comm::ConnectionPointer &conn, char *buf, size_t len, Comm::Flag flag, int, void *data)
{
IdentStateData *state = (IdentStateData *)data;
- char *ident = NULL;
- char *t = NULL;
+ char *ident = nullptr;
+ char *t = nullptr;
assert(buf == state->buf);
assert(conn->fd == state->conn->fd);
if ((t = strchr(buf, '\n')))
*t = '\0';
- debugs(30, 5, HERE << conn << ": Read '" << buf << "'");
+ debugs(30, 5, conn << ": Read '" << buf << "'");
if (strstr(buf, "USERID")) {
if ((ident = strrchr(buf, ':'))) {
while (xisspace(*++ident));
if (ident && *ident == '\0')
- ident = NULL;
+ ident = nullptr;
state->notify(ident);
}
}
IdentStateData *state;
char key1[IDENT_KEY_SZ];
char key2[IDENT_KEY_SZ];
- char key[IDENT_KEY_SZ];
+ char key[IDENT_KEY_SZ*2+2]; // key1 + ',' + key2 + terminator
conn->local.toUrl(key1, IDENT_KEY_SZ);
conn->remote.toUrl(key2, IDENT_KEY_SZ);
- snprintf(key, IDENT_KEY_SZ, "%s,%s", key1, key2);
+ int res = snprintf(key, sizeof(key), "%s,%s", key1, key2);
+ assert(res > 0);
+ assert(static_cast<unsigned int>(res) < sizeof(key));
if (!ident_hash) {
- Init();
+ ident_hash = hash_create((HASHCMP *) strcmp,
+ hashPrime(Squid_MaxFD / 8),
+ hash4);
}
- if ((state = (IdentStateData *)hash_lookup(ident_hash, key)) != NULL) {
+ if ((state = (IdentStateData *)hash_lookup(ident_hash, key)) != nullptr) {
ClientAdd(state, callback, data);
return;
}
state = new IdentStateData;
state->hash.key = xstrdup(key);
- // copy the conn details. We dont want the original FD to be re-used by IDENT.
- state->conn = conn->copyDetails();
+ // copy the conn details. We do not want the original FD to be re-used by IDENT.
+ const auto identConn = conn->cloneProfile();
// NP: use random port for secure outbound to IDENT_PORT
- state->conn->local.port(0);
- state->conn->remote.port(IDENT_PORT);
+ identConn->local.port(0);
+ identConn->remote.port(IDENT_PORT);
// build our query from the original connection details
state->queryMsg.init();
hash_join(ident_hash, &state->hash);
AsyncCall::Pointer call = commCbCall(30,3, "Ident::ConnectDone", CommConnectCbPtrFun(Ident::ConnectDone, state));
- AsyncJob::Start(new Comm::ConnOpener(state->conn, call, Ident::TheConfig.timeout));
-}
-
-void
-Ident::Init(void)
-{
- if (ident_hash) {
- debugs(30, DBG_CRITICAL, "WARNING: Ident already initialized.");
- return;
- }
-
- ident_hash = hash_create((HASHCMP *) strcmp,
- hashPrime(Squid_MaxFD / 8),
- hash4);
+ const auto connOpener = new Comm::ConnOpener(identConn, call, Ident::TheConfig.timeout);
+ state->connWait.start(connOpener, call);
}
#endif /* USE_IDENT */
projects / thirdparty / squid.git / blobdiff