#include "acl/FilledChecklist.h"
#include "anyp/PortCfg.h"
#include "CacheDigest.h"
+#include "CachePeer.h"
+#include "CachePeerDomainList.h"
#include "comm/Connection.h"
#include "comm/ConnOpener.h"
#include "event.h"
-#include "forward.h"
+#include "FwdState.h"
#include "globals.h"
#include "htcp.h"
#include "HttpRequest.h"
#include "mgr/Registration.h"
#include "multicast.h"
#include "neighbors.h"
+#include "NeighborTypeDomainList.h"
#include "PeerDigest.h"
#include "PeerSelectState.h"
+#include "RequestFlags.h"
+#include "SquidConfig.h"
#include "SquidMath.h"
#include "SquidTime.h"
#include "stat.h"
/* count mcast group peers every 15 minutes */
#define MCAST_COUNT_RATE 900
-bool peerAllowedToUse(const peer *, HttpRequest *);
-static int peerWouldBePinged(const peer *, HttpRequest *);
-static void neighborRemove(peer *);
-static void neighborAlive(peer *, const MemObject *, const icp_common_t *);
+bool peerAllowedToUse(const CachePeer *, HttpRequest *);
+static int peerWouldBePinged(const CachePeer *, HttpRequest *);
+static void neighborRemove(CachePeer *);
+static void neighborAlive(CachePeer *, const MemObject *, const icp_common_t *);
#if USE_HTCP
-static void neighborAliveHtcp(peer *, const MemObject *, const htcpReplyData *);
+static void neighborAliveHtcp(CachePeer *, const MemObject *, const HtcpReplyData *);
#endif
-static void neighborCountIgnored(peer *);
+static void neighborCountIgnored(CachePeer *);
static void peerRefreshDNS(void *);
static IPH peerDNSConfigure;
-static bool peerProbeConnect(peer *);
+static bool peerProbeConnect(CachePeer *);
static CNCB peerProbeConnectDone;
static void peerCountMcastPeersDone(void *data);
static void peerCountMcastPeersStart(void *data);
-static void peerCountMcastPeersSchedule(peer * p, time_t when);
+static void peerCountMcastPeersSchedule(CachePeer * p, time_t when);
static IRCB peerCountHandleIcpReply;
static void neighborIgnoreNonPeer(const Ip::Address &, icp_opcode);
static OBJH neighborDumpPeers;
static OBJH neighborDumpNonPeers;
-static void dump_peers(StoreEntry * sentry, peer * peers);
+static void dump_peers(StoreEntry * sentry, CachePeer * peers);
static unsigned short echo_port;
static int NLateReplies = 0;
-static peer *first_ping = NULL;
+static CachePeer *first_ping = NULL;
const char *
-neighborTypeStr(const peer * p)
+neighborTypeStr(const CachePeer * p)
{
if (p->type == PEER_NONE)
return "Non-Peer";
return "Parent";
}
-peer *
+CachePeer *
whichPeer(const Ip::Address &from)
{
int j;
- peer *p = NULL;
+ CachePeer *p = NULL;
debugs(15, 3, "whichPeer: from " << from);
for (p = Config.peers; p; p = p->next) {
for (j = 0; j < p->n_addresses; ++j) {
- if (from == p->addresses[j] && from.GetPort() == p->icp.port) {
+ if (from == p->addresses[j] && from.port() == p->icp.port) {
return p;
}
}
}
peer_t
-neighborType(const peer * p, const HttpRequest * request)
+neighborType(const CachePeer * p, const HttpRequest * request)
{
- const domain_type *d = NULL;
+ const NeighborTypeDomainList *d = NULL;
for (d = p->typelist; d; d = d->next) {
if (0 == matchDomainName(request->GetHost(), d->domain))
* \return Whether it is appropriate to fetch REQUEST from PEER.
*/
bool
-peerAllowedToUse(const peer * p, HttpRequest * request)
+peerAllowedToUse(const CachePeer * p, HttpRequest * request)
{
- const domain_ping *d = NULL;
+ const CachePeerDomainList *d = NULL;
assert(request != NULL);
if (neighborType(p, request) == PEER_SIBLING) {
#if PEER_MULTICAST_SIBLINGS
if (p->type == PEER_MULTICAST && p->options.mcast_siblings &&
- (request->flags.nocache || request->flags.refresh || request->flags.loopdetect || request->flags.need_validation))
+ (request->flags.noCache || request->flags.refresh || request->flags.loopDetected || request->flags.needValidation))
debugs(15, 2, "peerAllowedToUse(" << p->name << ", " << request->GetHost() << ") : multicast-siblings optimization match");
#endif
- if (request->flags.nocache)
+ if (request->flags.noCache)
return false;
if (request->flags.refresh)
return false;
- if (request->flags.loopdetect)
+ if (request->flags.loopDetected)
return false;
- if (request->flags.need_validation)
+ if (request->flags.needValidation)
return false;
}
// CONNECT requests are proxy requests. Not to be forwarded to origin servers.
- // Unless the destination port matches, in which case we MAY perform a 'DIRECT' to this peer.
- if (p->options.originserver && request->method == METHOD_CONNECT && request->port != p->in_addr.GetPort())
+ // Unless the destination port matches, in which case we MAY perform a 'DIRECT' to this CachePeer.
+ if (p->options.originserver && request->method == Http::METHOD_CONNECT && request->port != p->in_addr.port())
return false;
if (p->peer_domain == NULL && p->access == NULL)
return do_ping;
ACLFilledChecklist checklist(p->access, request, NULL);
- checklist.src_addr = request->client_addr;
- checklist.my_addr = request->my_addr;
-
-#if 0 && USE_IDENT
- /*
- * this is currently broken because 'request->user_ident' has been
- * moved to conn->rfc931 and we don't have access to the parent
- * ConnStateData here.
- */
- if (request->user_ident[0])
- xstrncpy(checklist.rfc931, request->user_ident, USER_IDENT_SZ);
-
-#endif
return (checklist.fastCheck() == ACCESS_ALLOWED);
}
-/* Return TRUE if it is okay to send an ICP request to this peer. */
+/* Return TRUE if it is okay to send an ICP request to this CachePeer. */
static int
-peerWouldBePinged(const peer * p, HttpRequest * request)
+peerWouldBePinged(const CachePeer * p, HttpRequest * request)
{
if (p->icp.port == 0)
return 0;
return 1;
}
-/* Return TRUE if it is okay to send an HTTP request to this peer. */
+/* Return TRUE if it is okay to send an HTTP request to this CachePeer. */
int
-peerHTTPOkay(const peer * p, HttpRequest * request)
+peerHTTPOkay(const CachePeer * p, HttpRequest * request)
{
if (p->max_conn)
if (p->stats.conn_open >= p->max_conn)
int
neighborsCount(HttpRequest * request)
{
- peer *p = NULL;
+ CachePeer *p = NULL;
int count = 0;
for (p = Config.peers; p; p = p->next)
return count;
}
-peer *
+CachePeer *
getFirstUpParent(HttpRequest * request)
{
- peer *p = NULL;
+ CachePeer *p = NULL;
for (p = Config.peers; p; p = p->next) {
if (!neighborUp(p))
return p;
}
-peer *
+CachePeer *
getRoundRobinParent(HttpRequest * request)
{
- peer *p;
- peer *q = NULL;
+ CachePeer *p;
+ CachePeer *q = NULL;
for (p = Config.peers; p; p = p->next) {
if (!p->options.roundrobin)
return q;
}
-peer *
+CachePeer *
getWeightedRoundRobinParent(HttpRequest * request)
{
- peer *p;
- peer *q = NULL;
+ CachePeer *p;
+ CachePeer *q = NULL;
int weighted_rtt;
for (p = Config.peers; p; p = p->next) {
}
/**
- * This gets called on startup and restart to kick off the peer round-robin
+ * This gets called on startup and restart to kick off the CachePeer round-robin
* maintenance event. It ensures that no matter how many times its called
* no more than one event is scheduled.
*/
void
peerClearRRStart(void)
{
- static int event_added = 0;
+ static bool event_added = false;
if (!event_added) {
peerClearRRLoop(NULL);
+ event_added=true;
}
}
* Called whenever the round-robin counters need to be reset to a sane state.
* So far those times are:
* - On startup and reconfigure - to set the counters to sane initial settings.
- * - When a peer has revived from dead, to prevent the revived peer being
+ * - When a CachePeer has revived from dead, to prevent the revived CachePeer being
* flooded with requests which it has 'missed' during the down period.
*/
void
peerClearRR()
{
- peer *p = NULL;
+ CachePeer *p = NULL;
for (p = Config.peers; p; p = p->next) {
p->rr_count = 0;
}
}
/**
- * Perform all actions when a peer is detected revived.
+ * Perform all actions when a CachePeer is detected revived.
*/
void
-peerAlive(peer *p)
+peerAlive(CachePeer *p)
{
if (p->stats.logged_state == PEER_DEAD && p->tcp_up) {
debugs(15, DBG_IMPORTANT, "Detected REVIVED " << neighborTypeStr(p) << ": " << p->name);
p->stats.probe_start = 0;
}
-peer *
+CachePeer *
getDefaultParent(HttpRequest * request)
{
- peer *p = NULL;
+ CachePeer *p = NULL;
for (p = Config.peers; p; p = p->next) {
if (neighborType(p, request) != PEER_PARENT)
return NULL;
}
-peer *
-getNextPeer(peer * p)
+CachePeer *
+getNextPeer(CachePeer * p)
{
return p->next;
}
-peer *
+CachePeer *
getFirstPeer(void)
{
return Config.peers;
}
static void
-neighborRemove(peer * target)
+neighborRemove(CachePeer * target)
{
- peer *p = NULL;
- peer **P = NULL;
+ CachePeer *p = NULL;
+ CachePeer **P = NULL;
p = Config.peers;
P = &Config.peers;
{
struct servent *sep = NULL;
const char *me = getMyHostname();
- peer *thisPeer = NULL;
- peer *next = NULL;
+ CachePeer *thisPeer = NULL;
+ CachePeer *next = NULL;
neighborsRegisterWithCacheManager();
continue;
for (AnyP::PortCfg *s = Config.Sockaddr.http; s; s = s->next) {
- if (thisPeer->http_port != s->s.GetPort())
+ if (thisPeer->http_port != s->s.port())
continue;
debugs(15, DBG_IMPORTANT, "WARNING: Peer looks like this host");
{
const char *url = entry->url();
MemObject *mem = entry->mem_obj;
- peer *p = NULL;
+ CachePeer *p = NULL;
int i;
int reqnum = 0;
int flags;
debugs(15, 5, "neighborsUdpPing: Peer " << p->host);
if (!peerWouldBePinged(p, request))
- continue; /* next peer */
+ continue; /* next CachePeer */
++peers_pinged;
p->stats.last_query = squid_curtime;
/*
- * keep probe_start == 0 for a multicast peer,
- * so neighborUp() never says this peer is dead.
+ * keep probe_start == 0 for a multicast CachePeer,
+ * so neighborUp() never says this CachePeer is dead.
*/
if ((p->type != PEER_MULTICAST) && (p->stats.probe_start == 0))
return peers_pinged;
}
-/* lookup the digest of a given peer */
+/* lookup the digest of a given CachePeer */
lookup_t
-peerDigestLookup(peer * p, HttpRequest * request)
+peerDigestLookup(CachePeer * p, HttpRequest * request)
{
#if USE_CACHE_DIGESTS
const cache_key *key = request ? storeKeyPublicByRequest(request) : NULL;
return LOOKUP_NONE;
}
-/* select best peer based on cache digests */
-peer *
+/* select best CachePeer based on cache digests */
+CachePeer *
neighborsDigestSelect(HttpRequest * request)
{
- peer *best_p = NULL;
+ CachePeer *best_p = NULL;
#if USE_CACHE_DIGESTS
int best_rtt = 0;
int choice_count = 0;
int ichoice_count = 0;
- peer *p;
+ CachePeer *p;
int p_rtt;
int i;
debugs(15, 5, "neighborsDigestSelect: peer " << p->host << " rtt: " << p_rtt);
- /* is this peer better than others in terms of rtt ? */
+ /* is this CachePeer better than others in terms of rtt ? */
if (!best_p || (p_rtt && p_rtt < best_rtt)) {
best_p = p;
best_rtt = p_rtt;
}
void
-peerNoteDigestLookup(HttpRequest * request, peer * p, lookup_t lookup)
+peerNoteDigestLookup(HttpRequest * request, CachePeer * p, lookup_t lookup)
{
#if USE_CACHE_DIGESTS
if (p)
- strncpy(request->hier.cd_host, p->host, sizeof(request->hier.cd_host));
+ strncpy(request->hier.cd_host, p->host, sizeof(request->hier.cd_host)-1);
else
*request->hier.cd_host = '\0';
}
static void
-neighborAlive(peer * p, const MemObject * mem, const icp_common_t * header)
+neighborAlive(CachePeer * p, const MemObject * mem, const icp_common_t * header)
{
peerAlive(p);
++ p->stats.pings_acked;
}
static void
-neighborUpdateRtt(peer * p, MemObject * mem)
+neighborUpdateRtt(CachePeer * p, MemObject * mem)
{
int rtt, rtt_av_factor;
#if USE_HTCP
static void
-neighborAliveHtcp(peer * p, const MemObject * mem, const htcpReplyData * htcp)
+neighborAliveHtcp(CachePeer * p, const MemObject * mem, const HtcpReplyData * htcp)
{
peerAlive(p);
++ p->stats.pings_acked;
#endif
static void
-neighborCountIgnored(peer * p)
+neighborCountIgnored(CachePeer * p)
{
if (p == NULL)
return;
++NLateReplies;
}
-static peer *non_peers = NULL;
+static CachePeer *non_peers = NULL;
static void
neighborIgnoreNonPeer(const Ip::Address &from, icp_opcode opcode)
{
- peer *np;
+ CachePeer *np;
for (np = non_peers; np; np = np->next) {
if (np->in_addr != from)
continue;
- if (np->in_addr.GetPort() != from.GetPort())
+ if (np->in_addr.port() != from.port())
continue;
break;
}
if (np == NULL) {
- np = (peer *)xcalloc(1, sizeof(peer));
+ np = (CachePeer *)xcalloc(1, sizeof(CachePeer));
np->in_addr = from;
- np->icp.port = from.GetPort();
+ np->icp.port = from.port();
np->type = PEER_NONE;
np->host = new char[MAX_IPSTRLEN];
- from.NtoA(np->host,MAX_IPSTRLEN);
+ from.toStr(np->host,MAX_IPSTRLEN);
np->next = non_peers;
non_peers = np;
}
/* ignoreMulticastReply
*
* * We want to ignore replies from multicast peers if the
- * * cache_host_domain rules would normally prevent the peer
+ * * cache_host_domain rules would normally prevent the CachePeer
* * from being used
*/
static int
-ignoreMulticastReply(peer * p, MemObject * mem)
+ignoreMulticastReply(CachePeer * p, MemObject * mem)
{
if (p == NULL)
return 0;
void
neighborsUdpAck(const cache_key * key, icp_common_t * header, const Ip::Address &from)
{
- peer *p = NULL;
+ CachePeer *p = NULL;
StoreEntry *entry;
MemObject *mem = NULL;
peer_t ntype = PEER_NONE;
}
}
-peer *
+CachePeer *
peerFindByName(const char *name)
{
- peer *p = NULL;
+ CachePeer *p = NULL;
for (p = Config.peers; p; p = p->next) {
if (!strcasecmp(name, p->name))
return p;
}
-peer *
+CachePeer *
peerFindByNameAndPort(const char *name, unsigned short port)
{
- peer *p = NULL;
+ CachePeer *p = NULL;
for (p = Config.peers; p; p = p->next) {
if (strcasecmp(name, p->name))
}
int
-neighborUp(const peer * p)
+neighborUp(const CachePeer * p)
{
if (!p->tcp_up) {
- if (!peerProbeConnect((peer *) p)) {
+ if (!peerProbeConnect((CachePeer *) p)) {
debugs(15, 8, "neighborUp: DOWN (probed): " << p->host << " (" << p->in_addr << ")");
return 0;
}
}
/*
- * The peer can not be UP if we don't have any IP addresses
+ * The CachePeer can not be UP if we don't have any IP addresses
* for it.
*/
if (0 == p->n_addresses) {
void
peerDestroy(void *data)
{
- peer *p = (peer *)data;
+ CachePeer *p = (CachePeer *)data;
if (p == NULL)
return;
- domain_ping *nl = NULL;
+ CachePeerDomainList *nl = NULL;
- for (domain_ping *l = p->peer_domain; l; l = nl) {
+ for (CachePeerDomainList *l = p->peer_domain; l; l = nl) {
nl = l->next;
safe_free(l->domain);
xfree(l);
}
void
-peerNoteDigestGone(peer * p)
+peerNoteDigestGone(CachePeer * p)
{
#if USE_CACHE_DIGESTS
cbdataReferenceDone(p->digest);
static void
peerDNSConfigure(const ipcache_addrs *ia, const DnsLookupDetails &, void *data)
{
- peer *p = (peer *)data;
+ CachePeer *p = (CachePeer *)data;
int j;
++ p->n_addresses;
}
- p->in_addr.SetEmpty();
+ p->in_addr.setEmpty();
p->in_addr = p->addresses[0];
- p->in_addr.SetPort(p->icp.port);
+ p->in_addr.port(p->icp.port);
if (p->type == PEER_MULTICAST)
peerCountMcastPeersSchedule(p, 10);
static void
peerRefreshDNS(void *data)
{
- peer *p = NULL;
+ CachePeer *p = NULL;
if (eventFind(peerRefreshDNS, NULL))
eventDelete(peerRefreshDNS, NULL);
}
static void
-peerConnectFailedSilent(peer * p)
+peerConnectFailedSilent(CachePeer * p)
{
p->stats.last_connect_failure = squid_curtime;
}
void
-peerConnectFailed(peer *p)
+peerConnectFailed(CachePeer *p)
{
debugs(15, DBG_IMPORTANT, "TCP connection to " << p->host << "/" << p->http_port << " failed");
peerConnectFailedSilent(p);
}
void
-peerConnectSucceded(peer * p)
+peerConnectSucceded(CachePeer * p)
{
if (!p->tcp_up) {
debugs(15, 2, "TCP connection to " << p->host << "/" << p->http_port << " succeded");
* peerProbeConnect will be called on dead peers by neighborUp
*/
static bool
-peerProbeConnect(peer * p)
+peerProbeConnect(CachePeer * p)
{
time_t ctimeout = p->connect_timeout > 0 ? p->connect_timeout : Config.Timeout.peer_connect;
bool ret = (squid_curtime - p->stats.last_connect_failure) > (ctimeout * 10);
if (squid_curtime - p->stats.last_connect_probe == 0)
return ret;/* don't probe to often */
- /* for each IP address of this peer. find one that we can connect to and probe it. */
+ /* for each IP address of this CachePeer. find one that we can connect to and probe it. */
for (int i = 0; i < p->n_addresses; ++i) {
Comm::ConnectionPointer conn = new Comm::Connection;
conn->remote = p->addresses[i];
- conn->remote.SetPort(p->http_port);
+ conn->remote.port(p->http_port);
getOutgoingAddress(NULL, conn);
++ p->testing_now;
static void
peerProbeConnectDone(const Comm::ConnectionPointer &conn, comm_err_t status, int xerrno, void *data)
{
- peer *p = (peer*)data;
+ CachePeer *p = (CachePeer*)data;
if (status == COMM_OK) {
peerConnectSucceded(p);
}
static void
-peerCountMcastPeersSchedule(peer * p, time_t when)
+peerCountMcastPeersSchedule(CachePeer * p, time_t when)
{
if (p->mcast.flags.count_event_pending)
return;
p,
(double) when, 1);
- p->mcast.flags.count_event_pending = 1;
+ p->mcast.flags.count_event_pending = true;
}
static void
peerCountMcastPeersStart(void *data)
{
- peer *p = (peer *)data;
+ CachePeer *p = (CachePeer *)data;
ps_state *psstate;
StoreEntry *fake;
MemObject *mem;
int reqnum;
LOCAL_ARRAY(char, url, MAX_URL);
assert(p->type == PEER_MULTICAST);
- p->mcast.flags.count_event_pending = 0;
+ p->mcast.flags.count_event_pending = false;
snprintf(url, MAX_URL, "http://");
- p->in_addr.ToURL(url+7, MAX_URL -8 );
+ p->in_addr.toUrl(url+7, MAX_URL -8 );
strcat(url, "/");
- fake = storeCreateEntry(url, url, request_flags(), METHOD_GET);
+ fake = storeCreateEntry(url, url, RequestFlags(), Http::METHOD_GET);
HttpRequest *req = HttpRequest::CreateFromUrl(url);
psstate = new ps_state;
- psstate->request = HTTPMSGLOCK(req);
+ psstate->request = req;
+ HTTPMSGLOCK(psstate->request);
psstate->entry = fake;
psstate->callback = NULL;
psstate->callback_data = cbdataReference(p);
psstate->ping.start = current_time;
mem = fake->mem_obj;
- mem->request = HTTPMSGLOCK(psstate->request);
+ mem->request = psstate->request;
+ HTTPMSGLOCK(mem->request);
mem->start_ping = current_time;
mem->ping_reply_callback = peerCountHandleIcpReply;
mem->ircb_data = psstate;
peerCountMcastPeersDone,
psstate,
Config.Timeout.mcast_icp_query / 1000.0, 1);
- p->mcast.flags.counting = 1;
+ p->mcast.flags.counting = true;
peerCountMcastPeersSchedule(p, MCAST_COUNT_RATE);
}
StoreEntry *fake = psstate->entry;
if (cbdataReferenceValid(psstate->callback_data)) {
- peer *p = (peer *)psstate->callback_data;
- p->mcast.flags.counting = 0;
+ CachePeer *p = (CachePeer *)psstate->callback_data;
+ p->mcast.flags.counting = false;
p->mcast.avg_n_members = Math::doubleAverage(p->mcast.avg_n_members, (double) psstate->ping.n_recv, ++p->mcast.n_times_counted, 10);
debugs(15, DBG_IMPORTANT, "Group " << p->host << ": " << psstate->ping.n_recv <<
" replies, "<< std::setw(4)<< std::setprecision(2) <<
}
static void
-peerCountHandleIcpReply(peer * p, peer_t type, AnyP::ProtocolType proto, void *hdrnotused, void *data)
+peerCountHandleIcpReply(CachePeer * p, peer_t type, AnyP::ProtocolType proto, void *hdrnotused, void *data)
{
int rtt_av_factor;
}
void
-dump_peer_options(StoreEntry * sentry, peer * p)
+dump_peer_options(StoreEntry * sentry, CachePeer * p)
{
if (p->options.proxy_only)
storeAppendPrintf(sentry, " proxy-only");
}
static void
-dump_peers(StoreEntry * sentry, peer * peers)
+dump_peers(StoreEntry * sentry, CachePeer * peers)
{
- peer *e = NULL;
+ CachePeer *e = NULL;
char ntoabuf[MAX_IPSTRLEN];
- domain_ping *d = NULL;
+ CachePeerDomainList *d = NULL;
icp_opcode op;
int i;
for (i = 0; i < e->n_addresses; ++i) {
storeAppendPrintf(sentry, "Address[%d] : %s\n", i,
- e->addresses[i].NtoA(ntoabuf,MAX_IPSTRLEN) );
+ e->addresses[i].toStr(ntoabuf,MAX_IPSTRLEN) );
}
storeAppendPrintf(sentry, "Status : %s\n",
#if USE_HTCP
void
-neighborsHtcpReply(const cache_key * key, htcpReplyData * htcp, const Ip::Address &from)
+neighborsHtcpReply(const cache_key * key, HtcpReplyData * htcp, const Ip::Address &from)
{
StoreEntry *e = Store::Root().get(key);
MemObject *mem = NULL;
- peer *p;
+ CachePeer *p;
peer_t ntype = PEER_NONE;
debugs(15, 6, "neighborsHtcpReply: " <<
(htcp->hit ? "HIT" : "MISS") << " " <<
void
neighborsHtcpClear(StoreEntry * e, const char *uri, HttpRequest * req, const HttpRequestMethod &method, htcp_clr_reason reason)
{
- peer *p;
+ CachePeer *p;
char buf[128];
for (p = Config.peers; p; p = p->next) {
if (p->options.htcp_no_purge_clr && reason == HTCP_CLR_PURGE) {
continue;
}
- debugs(15, 3, "neighborsHtcpClear: sending CLR to " << p->in_addr.ToURL(buf, 128));
+ debugs(15, 3, "neighborsHtcpClear: sending CLR to " << p->in_addr.toUrl(buf, 128));
htcpClear(e, uri, req, method, p, reason);
}
}