/*
- * Copyright (C) 1996-2015 The Squid Software Foundation and contributors
+ * Copyright (C) 1996-2018 The Squid Software Foundation and contributors
*
* Squid software is distributed under GPLv2+ license and includes
* contributions from numerous individuals and organizations.
#include "squid.h"
#include "CachePeer.h"
#include "cbdata.h"
-#include "disk.h"
#include "event.h"
#include "fde.h"
+#include "fs_io.h"
#include "FwdState.h"
#include "HttpReply.h"
-#include "HttpRequest.h"
#include "icmp/net_db.h"
#include "internal.h"
#include "ip/Address.h"
#include "mgr/Registration.h"
#include "mime_header.h"
#include "neighbors.h"
+#include "SquidConfig.h"
#include "SquidTime.h"
#include "Store.h"
#include "StoreClient.h"
-#include "SwapDir.h"
#include "tools.h"
-#include "URL.h"
#include "wordlist.h"
#if HAVE_SYS_STAT_H
CBDATA_CLASS(netdbExchangeState);
public:
- netdbExchangeState(CachePeer *aPeer, HttpRequest *theReq) :
- p(cbdataReference(aPeer)),
- e(NULL),
- sc(NULL),
- r(theReq),
- used(0),
- buf_sz(NETDB_REQBUF_SZ),
- buf_ofs(0),
- connstate(STATE_HEADER)
+ netdbExchangeState(CachePeer *aPeer, const HttpRequestPointer &theReq) :
+ p(aPeer),
+ r(theReq)
{
*buf = 0;
-
- assert(NULL != r);
- HTTPMSGLOCK(r);
+ assert(r);
// TODO: check if we actually need to do this. should be implicit
r->http_ver = Http::ProtocolVersion();
}
debugs(38, 3, e->url());
storeUnregister(sc, e, this);
e->unlock("netdbExchangeDone");
- HTTPMSGUNLOCK(r);
- cbdataReferenceDone(p);
}
- CachePeer *p;
- StoreEntry *e;
- store_client *sc;
- HttpRequest *r;
- int64_t used;
- size_t buf_sz;
+ CbcPointer<CachePeer> p;
+ StoreEntry *e = nullptr;
+ store_client *sc = nullptr;
+ HttpRequestPointer r;
+ int64_t used = 0;
+ size_t buf_sz = NETDB_REQBUF_SZ;
char buf[NETDB_REQBUF_SZ];
- int buf_ofs;
- netdb_conn_state_t connstate;
+ int buf_ofs = 0;
+ netdb_conn_state_t connstate = STATE_HEADER;
};
CBDATA_CLASS_INIT(netdbExchangeState);
static net_db_peer *netdbPeerAdd(netdbEntry * n, CachePeer * e);
static const char *netdbPeerName(const char *name);
static IPH netdbSendPing;
-static QS sortPeerByRtt;
-static QS sortByRtt;
-static QS netdbLRU;
static FREE netdbFreeNameEntry;
static FREE netdbFreeNetdbEntry;
static STCB netdbExchangeHandleReply;
netdbHashInsert(netdbEntry * n, Ip::Address &addr)
{
networkFromInaddr(addr).toStr(n->network, MAX_IPSTRLEN);
- n->hash.key = n->network;
+ n->key = n->network;
assert(hash_lookup(addr_table, n->network) == NULL);
- hash_join(addr_table, &n->hash);
+ hash_join(addr_table, n);
}
static void
hash_remove_link(addr_table, hptr);
}
+net_db_name::net_db_name(const char *hostname, netdbEntry *e) :
+ next(e ? e->hosts : nullptr),
+ net_db_entry(e)
+{
+ key = xstrdup(hostname);
+ if (e) {
+ e->hosts = this;
+ ++ e->link_count;
+ }
+}
+
static void
netdbHostInsert(netdbEntry * n, const char *hostname)
{
- net_db_name *x = (net_db_name *)memAllocate(MEM_NET_DB_NAME);
- x->hash.key = xstrdup(hostname);
- x->next = n->hosts;
- n->hosts = x;
- x->net_db_entry = n;
+ net_db_name *x = new net_db_name(hostname, n);
assert(hash_lookup(host_table, hostname) == NULL);
- hash_join(host_table, &x->hash);
- ++ n->link_count;
+ hash_join(host_table, x);
}
static void
netdbHostDelete(const net_db_name * x)
{
- netdbEntry *n;
- net_db_name **X;
assert(x != NULL);
assert(x->net_db_entry != NULL);
- n = x->net_db_entry;
+
+ netdbEntry *n = x->net_db_entry;
-- n->link_count;
- for (X = &n->hosts; *X; X = &(*X)->next) {
+ for (auto **X = &n->hosts; *X; X = &(*X)->next) {
if (*X == x) {
*X = x->next;
break;
}
hash_remove_link(host_table, (hash_link *) x);
- xfree(x->hash.key);
- memFree((void *) x, MEM_NET_DB_NAME);
+ delete x;
}
static netdbEntry *
if (n->link_count == 0) {
netdbHashDelete(n->network);
- memFree(n, MEM_NETDBENTRY);
+ delete n;
}
}
int k = 0;
int list_count = 0;
int removed = 0;
- list = (netdbEntry **)xcalloc(memInUse(MEM_NETDBENTRY), sizeof(netdbEntry *));
+ list = (netdbEntry **)xcalloc(netdbEntry::UseCount(), sizeof(netdbEntry *));
hash_first(addr_table);
while ((n = (netdbEntry *) hash_next(addr_table))) {
- assert(list_count < memInUse(MEM_NETDBENTRY));
+ assert(list_count < netdbEntry::UseCount());
*(list + list_count) = n;
++list_count;
}
netdbLRU);
for (k = 0; k < list_count; ++k) {
- if (memInUse(MEM_NETDBENTRY) < Config.Netdb.low)
+ if (netdbEntry::UseCount() < Config.Netdb.low)
break;
netdbRelease(*(list + k));
{
netdbEntry *n;
- if (memInUse(MEM_NETDBENTRY) > Config.Netdb.high)
+ if (netdbEntry::UseCount() > Config.Netdb.high)
netdbPurgeLRU();
if ((n = netdbLookupAddr(addr)) == NULL) {
- n = (netdbEntry *)memAllocate(MEM_NETDBENTRY);
+ n = new netdbEntry;
netdbHashInsert(n, addr);
}
return;
}
- addr = ia->in_addrs[ia->cur];
+ addr = ia->current();
if ((n = netdbLookupHost(hostname)) == NULL) {
n = netdbAdd(addr);
unlink(Config.netdbFilename);
lf = logfileOpen(Config.netdbFilename, 4096, 0);
- if (NULL == lf) {
- debugs(50, DBG_IMPORTANT, "netdbSaveState: " << Config.netdbFilename << ": " << xstrerror());
+ if (lf) {
+ int xerrno = errno;
+ debugs(50, DBG_IMPORTANT, MYNAME << Config.netdbFilename << ": " << xstrerr(xerrno));
return;
}
(int) n->last_use_time);
for (x = n->hosts; x; x = x->next)
- logfilePrintf(lf, " %s", hashKeyStr(&x->hash));
+ logfilePrintf(lf, " %s", hashKeyStr(x));
logfilePrintf(lf, "\n");
N.last_use_time = (time_t) atoi(q);
- n = (netdbEntry *)memAllocate(MEM_NETDBENTRY);
+ n = new netdbEntry;
memcpy(n, &N, sizeof(netdbEntry));
{
netdbEntry *n = (netdbEntry *)data;
safe_free(n->peers);
- memFree(n, MEM_NETDBENTRY);
+ delete n;
}
static void
netdbFreeNameEntry(void *data)
{
net_db_name *x = (net_db_name *)data;
- xfree(x->hash.key);
- memFree(x, MEM_NET_DB_NAME);
+ delete x;
}
static void
rec_sz += 1 + sizeof(int);
debugs(38, 3, "netdbExchangeHandleReply: " << receivedData.length << " read bytes");
- if (!cbdataReferenceValid(ex->p)) {
+ if (!ex->p.valid()) {
debugs(38, 3, "netdbExchangeHandleReply: Peer became invalid");
delete ex;
return;
}
if (!addr.isAnyAddr() && rtt > 0)
- netdbExchangeUpdatePeer(addr, ex->p, rtt, hops);
+ netdbExchangeUpdatePeer(addr, ex->p.get(), rtt, hops);
assert(o == rec_sz);
}
}
-static void
-netdbRegisterWithCacheManager(void)
-{
- Mgr::RegisterAction("netdb", "Network Measurement Database", netdbDump, 0, 1);
-}
-
#endif /* USE_ICMP */
/* PUBLIC FUNCTIONS */
netdbInit(void)
{
#if USE_ICMP
- int n;
-
- netdbRegisterWithCacheManager();
+ Mgr::RegisterAction("netdb", "Network Measurement Database", netdbDump, 0, 1);
if (addr_table)
return;
- n = hashPrime(Config.Netdb.high / 4);
+ int n = hashPrime(Config.Netdb.high / 4);
addr_table = hash_create((HASHCMP *) strcmp, n, hash_string);
"RTT",
"Hops",
"Hostnames");
- list = (netdbEntry **)xcalloc(memInUse(MEM_NETDBENTRY), sizeof(netdbEntry *));
+ list = (netdbEntry **)xcalloc(netdbEntry::UseCount(), sizeof(netdbEntry *));
i = 0;
hash_first(addr_table);
++i;
}
- if (i != memInUse(MEM_NETDBENTRY))
+ if (i != netdbEntry::UseCount())
debugs(38, DBG_CRITICAL, "WARNING: netdb_addrs count off, found " << i <<
- ", expected " << memInUse(MEM_NETDBENTRY));
+ ", expected " << netdbEntry::UseCount());
qsort((char *) list,
i,
n->hops);
for (x = n->hosts; x; x = x->next)
- storeAppendPrintf(sentry, " %s", hashKeyStr(&x->hash));
+ storeAppendPrintf(sentry, " %s", hashKeyStr(x));
storeAppendPrintf(sentry, "\n");
{
#if USE_ICMP
CachePeer *p = (CachePeer *)data;
- char *uri = internalRemoteUri(p->host, p->http_port, "/squid-internal-dynamic/", "netdb");
- debugs(38, 3, "netdbExchangeStart: Requesting '" << uri << "'");
- assert(NULL != uri);
- HttpRequest *req = HttpRequest::CreateFromUrl(uri);
-
- if (req == NULL) {
- debugs(38, DBG_IMPORTANT, "netdbExchangeStart: Bad URI " << uri);
+ static const SBuf netDB("netdb");
+ char *uri = internalRemoteUri(p->host, p->http_port, "/squid-internal-dynamic/", netDB);
+ debugs(38, 3, "Requesting '" << uri << "'");
+ const MasterXaction::Pointer mx = new MasterXaction(XactionInitiator::initIcmp);
+ HttpRequestPointer req(HttpRequest::FromUrl(uri, mx));
+
+ if (!req) {
+ debugs(38, DBG_IMPORTANT, MYNAME << ": Bad URI " << uri);
return;
}
if (p->login)
ex->r->url.userInfo(SBuf(p->login));
- urlCanonical(ex->r);
-
- FwdState::fwdStart(Comm::ConnectionPointer(), ex->e, ex->r);
-
+ FwdState::fwdStart(Comm::ConnectionPointer(), ex->e, ex->r.getRaw());
#endif
}
ia = ipcache_gethostbyname(request->url.host(), 0);
if (NULL != ia)
- n = netdbLookupAddr(ia->in_addrs[ia->cur]);
+ n = netdbLookupAddr(ia->current());
}
if (NULL == n)
projects / thirdparty / squid.git / blobdiff