#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"
static void neighborRemove(CachePeer *);
static void neighborAlive(CachePeer *, const MemObject *, const icp_common_t *);
#if USE_HTCP
-static void neighborAliveHtcp(CachePeer *, const MemObject *, const htcpReplyData *);
+static void neighborAliveHtcp(CachePeer *, const MemObject *, const HtcpReplyData *);
#endif
static void neighborCountIgnored(CachePeer *);
static void peerRefreshDNS(void *);
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;
}
}
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))
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 CachePeer.
- if (p->options.originserver && request->method == METHOD_CONNECT && request->port != p->in_addr.GetPort())
+ 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;
return (checklist.fastCheck() == ACCESS_ALLOWED);
}
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");
{
#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';
#if USE_HTCP
static void
-neighborAliveHtcp(CachePeer * p, const MemObject * mem, const htcpReplyData * htcp)
+neighborAliveHtcp(CachePeer * p, const MemObject * mem, const HtcpReplyData * htcp)
{
peerAlive(p);
++ p->stats.pings_acked;
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 = (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;
}
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);
++ 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);
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;
p,
(double) when, 1);
- p->mcast.flags.count_event_pending = 1;
+ p->mcast.flags.count_event_pending = true;
}
static void
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, RequestFlags(), 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);
}
if (cbdataReferenceValid(psstate->callback_data)) {
CachePeer *p = (CachePeer *)psstate->callback_data;
- p->mcast.flags.counting = 0;
+ 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) <<
{
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;
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);
}
}
projects / thirdparty / squid.git / blobdiff