void *operator new (size_t);
void operator delete(void *);
- struct peer *peer; /**< pointer back to peer structure, argh */
+ CachePeer *peer; /**< pointer back to peer structure, argh */
CacheDigest *cd; /**< actual digest structure */
String host; /**< copy of peer->host */
const char *req_result; /**< text status of the last request */
extern const Version CacheDigestVer;
-extern PeerDigest *peerDigestCreate(peer * p);
+extern PeerDigest *peerDigestCreate(CachePeer * p);
extern void peerDigestNeeded(PeerDigest * pd);
extern void peerDigestNotePeerGone(PeerDigest * pd);
extern void peerDigestStatsReport(const PeerDigest * pd, StoreEntry * e);
SQUIDCEXTERN void peerSelectInit(void);
/**
- * A peer which has been selected as a possible destination.
+ * A CachePeer which has been selected as a possible destination.
* Listed as pointers here so as to prevent duplicates being added but will
* be converted to a set of IP address path options before handing back out
* to the caller.
*
* Certain connection flags and outgoing settings will also be looked up and
- * set based on the received request and peer settings before handing back.
+ * set based on the received request and CachePeer settings before handing back.
*/
class FwdServer
{
public:
- peer *_peer; /* NULL --> origin server */
+ CachePeer *_peer; /* NULL --> origin server */
hier_code code;
FwdServer *next;
};
FwdServer *servers; ///< temporary linked list of peers we will pass back.
/*
- * Why are these Ip::Address instead of peer *? Because a
- * peer structure can become invalid during the peer selection
+ * Why are these Ip::Address instead of CachePeer *? Because a
+ * CachePeer structure can become invalid during the CachePeer selection
* phase, specifically after a reconfigure. Thus we need to lookup
- * the peer * based on the address when we are finally ready to
- * reference the peer structure.
+ * the CachePeer * based on the address when we are finally ready to
+ * reference the CachePeer structure.
*/
Ip::Address first_parent_miss;
Ip::Address closest_parent_miss;
/*
- * ->hit can be peer* because it should only be
+ * ->hit can be CachePeer* because it should only be
* accessed during the thread when it is set
*/
- peer *hit;
+ CachePeer *hit;
peer_t hit_type;
ping_data ping;
ACLChecklist *acl_checklist;
wordlist *hierarchy_stoplist;
wordlist *mcast_group_list;
wordlist *dns_nameservers;
- peer *peers;
+ CachePeer *peers;
int npeers;
struct {
Ip::Address src_addr;
Ip::Address dst_addr;
Ip::Address my_addr;
- struct peer *dst_peer;
+ CachePeer *dst_peer;
char *dst_rdns;
HttpRequest *request;
static peer_t parseNeighborType(const char *s);
-CBDATA_TYPE(peer);
+CBDATA_TYPE(CachePeer);
static const char *const T_MILLISECOND_STR = "millisecond";
static const char *const T_SECOND_STR = "second";
Config.ssl_client.sslContext = sslCreateClientContext(Config.ssl_client.cert, Config.ssl_client.key, Config.ssl_client.version, Config.ssl_client.cipher, Config.ssl_client.options, Config.ssl_client.flags, Config.ssl_client.cafile, Config.ssl_client.capath, Config.ssl_client.crlfile);
- for (peer *p = Config.peers; p != NULL; p = p->next) {
+ for (CachePeer *p = Config.peers; p != NULL; p = p->next) {
if (p->use_ssl) {
debugs(3, DBG_IMPORTANT, "Initializing cache_peer " << p->name << " SSL context");
p->sslContext = sslCreateClientContext(p->sslcert, p->sslkey, p->sslversion, p->sslcipher, p->ssloptions, p->sslflags, p->sslcafile, p->sslcapath, p->sslcrlfile);
}
static void
-dump_peer(StoreEntry * entry, const char *name, peer * p)
+dump_peer(StoreEntry * entry, const char *name, CachePeer * p)
{
domain_ping *d;
domain_type *t;
}
static void
-parse_peer(peer ** head)
+parse_peer(CachePeer ** head)
{
char *token = NULL;
- peer *p;
- CBDATA_INIT_TYPE_FREECB(peer, peerDestroy);
- p = cbdataAlloc(peer);
+ CachePeer *p;
+ CBDATA_INIT_TYPE_FREECB(CachePeer, peerDestroy);
+ p = cbdataAlloc(CachePeer);
p->http_port = CACHE_HTTP_PORT;
p->icp.port = CACHE_ICP_PORT;
p->weight = 1;
}
static void
-free_peer(peer ** P)
+free_peer(CachePeer ** P)
{
- peer *p;
+ CachePeer *p;
while ((p = *P) != NULL) {
*P = p->next;
parse_peer_access(void)
{
char *host = NULL;
- peer *p;
+ CachePeer *p;
if (!(host = strtok(NULL, w_space)))
self_destruct();
while ((domain = strtok(NULL, list_sep))) {
domain_ping *l = NULL;
domain_ping **L = NULL;
- peer *p;
+ CachePeer *p;
if ((p = peerFindByName(host)) == NULL) {
debugs(15, DBG_CRITICAL, "" << cfg_filename << ", line " << config_lineno << ": No cache_peer '" << host << "'");
while ((domain = strtok(NULL, list_sep))) {
domain_type *l = NULL;
domain_type **L = NULL;
- peer *p;
+ CachePeer *p;
if ((p = peerFindByName(host)) == NULL) {
debugs(15, DBG_CRITICAL, "" << cfg_filename << ", line " << config_lineno << ": No cache_peer '" << host << "'");
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
static int n_carp_peers = 0;
-static peer **carp_peers = NULL;
+static CachePeer **carp_peers = NULL;
static OBJH carpCachemgr;
static int
peerSortWeight(const void *a, const void *b)
{
- const peer *const *p1 = (const peer *const *)a;
- const peer *const *p2 = (const peer *const *)b;
+ const CachePeer *const *p1 = (const CachePeer *const *)a;
+ const CachePeer *const *p2 = (const CachePeer *const *)b;
return (*p1)->weight - (*p2)->weight;
}
int K;
int k;
double P_last, X_last, Xn;
- peer *p;
- peer **P;
+ CachePeer *p;
+ CachePeer **P;
char *t;
/* Clean up */
if (n_carp_peers == 0)
return;
- carp_peers = (peer **)xcalloc(n_carp_peers, sizeof(*carp_peers));
+ carp_peers = (CachePeer **)xcalloc(n_carp_peers, sizeof(*carp_peers));
/* Build a list of the found peers and calculate hashes and load factors */
for (P = carp_peers, p = Config.peers; p; p = p->next) {
}
}
-peer *
+CachePeer *
carpSelectParent(HttpRequest * request)
{
int k;
- peer *p = NULL;
- peer *tp;
+ CachePeer *p = NULL;
+ CachePeer *tp;
unsigned int user_hash = 0;
unsigned int combined_hash;
double score;
/* calculate hash key */
debugs(39, 2, "carpSelectParent: Calculating hash for " << urlCanonical(request));
- /* select peer */
+ /* select CachePeer */
for (k = 0; k < n_carp_peers; ++k) {
String key;
tp = carp_peers[k];
static void
carpCachemgr(StoreEntry * sentry)
{
- peer *p;
+ CachePeer *p;
int sumfetches = 0;
storeAppendPrintf(sentry, "%24s %10s %10s %10s %10s\n",
"Hostname",
#ifndef SQUID_CARP_H_
#define SQUID_CARP_H_
-class peer;
+class CachePeer;
class HttpRequest;
extern void carpInit(void);
-extern peer *carpSelectParent(HttpRequest *);
+extern CachePeer *carpSelectParent(HttpRequest *);
#endif /* SQUID_CARP_H_ */
else if (rep->content_length != http->memObject()->getReply()->content_length)
range_err = "INCONSISTENT length"; /* a bug? */
- /* hits only - upstream peer determines correct behaviour on misses, and client_side_reply determines
+ /* hits only - upstream CachePeer determines correct behaviour on misses, and client_side_reply determines
* hits candidates
*/
else if (logTypeIsATcpHit(http->logType) && http->request->header.has(HDR_IF_RANGE) && !clientIfRangeMatch(http, rep))
repContext->setReplyToError(error, scode,
repContext->http->request->method,
repContext->http->uri,
- peer,
+ CachePeer,
repContext->http->request,
in.buf, NULL);
context->pullData();
clientReplyContext *repContext = dynamic_cast<clientReplyContext *>(node->data.getRaw());
assert (repContext);
repContext->setReplyToError(ERR_LIFETIME_EXP,
- HTTP_REQUEST_TIMEOUT, METHOD_NONE, "N/A", &peer.sin_addr,
+ HTTP_REQUEST_TIMEOUT, METHOD_NONE, "N/A", &CachePeer.sin_addr,
NULL, NULL, NULL);
/* No requests can be outstanded */
assert(chr == NULL);
// commSetConnTimeout() was called for this request before we switched.
- // Disable the client read handler until peer selection is complete
+ // Disable the client read handler until CachePeer selection is complete
Comm::SetSelect(clientConnection->fd, COMM_SELECT_READ, NULL, NULL, 0);
Comm::SetSelect(clientConnection->fd, COMM_SELECT_READ, clientNegotiateSSL, this, 0);
switchedToHttps_ = true;
}
void
-ConnStateData::pinConnection(const Comm::ConnectionPointer &pinServer, HttpRequest *request, struct peer *aPeer, bool auth)
+ConnStateData::pinConnection(const Comm::ConnectionPointer &pinServer, HttpRequest *request, CachePeer *aPeer, bool auth)
{
char desc[FD_DESC_SZ];
}
const Comm::ConnectionPointer
-ConnStateData::validatePinnedConnection(HttpRequest *request, const struct peer *aPeer)
+ConnStateData::validatePinnedConnection(HttpRequest *request, const CachePeer *aPeer)
{
debugs(33, 7, HERE << pinning.serverConnection);
int port; /* port of pinned connection */
bool pinned; /* this connection was pinned */
bool auth; /* pinned for www authentication */
- struct peer *peer; /* peer the connection goes via */
+ CachePeer *peer; /* CachePeer the connection goes via */
AsyncCall::Pointer closeHandler; /*The close handler for pinned server side connection*/
} pinning;
/**
* Correlate the current ConnStateData object with the pinning_fd socket descriptor.
*/
- void pinConnection(const Comm::ConnectionPointer &pinServerConn, HttpRequest *request, struct peer *peer, bool auth);
+ void pinConnection(const Comm::ConnectionPointer &pinServerConn, HttpRequest *request, CachePeer *peer, bool auth);
/**
- * Decorrelate the ConnStateData object from its pinned peer
+ * Decorrelate the ConnStateData object from its pinned CachePeer
*/
void unpinConnection();
/**
* Checks if there is pinning info if it is valid. It can close the server side connection
* if pinned info is not valid.
\param request if it is not NULL also checks if the pinning info refers to the request client side HttpRequest
- \param peer if it is not NULL also check if the peer is the pinning peer
+ \param CachePeer if it is not NULL also check if the CachePeer is the pinning CachePeer
\return The details of the server side connection (may be closed if failures were present).
*/
- const Comm::ConnectionPointer validatePinnedConnection(HttpRequest *request, const struct peer *peer);
+ const Comm::ConnectionPointer validatePinnedConnection(HttpRequest *request, const CachePeer *peer);
/**
- * returts the pinned peer if exists, NULL otherwise
+ * returts the pinned CachePeer if exists, NULL otherwise
*/
- struct peer *pinnedPeer() const {return pinning.peer;}
+ CachePeer *pinnedPeer() const {return pinning.peer;}
bool pinnedAuth() const {return pinning.auth;}
// pining related comm callbacks
/*
* stats.conn_open is used to account for the number of
- * connections that we have open to the peer, so we can limit
+ * connections that we have open to the CachePeer, so we can limit
* based on the max-conn option. We need to increment here,
* even if the connection may fail.
*/
- if (peer *peer=(conn_->getPeer()))
+ if (CachePeer *peer=(conn_->getPeer()))
++peer->stats.conn_open;
lookupLocalAddress();
fd(-1),
tos(0),
flags(COMM_NONBLOCKING),
- _peer(NULL)
+ peer_(NULL)
{
*rfc931 = 0; // quick init the head. the rest does not matter.
}
close();
}
- cbdataReferenceDone(_peer);
+ cbdataReferenceDone(peer_);
}
Comm::ConnectionPointer
// ensure FD is not open in the new copy.
c->fd = -1;
- // ensure we have a cbdata reference to _peer not a straight ptr copy.
- c->_peer = cbdataReference(getPeer());
+ // ensure we have a cbdata reference to peer_ not a straight ptr copy.
+ c->peer_ = cbdataReference(getPeer());
return c;
}
if (isOpen()) {
comm_close(fd);
fd = -1;
- if (peer *p=getPeer())
+ if (CachePeer *p=getPeer())
-- p->stats.conn_open;
}
}
-peer *
+CachePeer *
Comm::Connection::getPeer() const
{
- if (cbdataReferenceValid(_peer))
- return _peer;
+ if (cbdataReferenceValid(peer_))
+ return peer_;
return NULL;
}
void
-Comm::Connection::setPeer(peer *p)
+Comm::Connection::setPeer(CachePeer *p)
{
/* set to self. nothing to do. */
if (getPeer() == p)
return;
- cbdataReferenceDone(_peer);
+ cbdataReferenceDone(peer_);
if (p) {
- _peer = cbdataReference(p);
+ peer_ = cbdataReference(p);
}
}
#include <ostream>
#endif
-struct peer;
+class CachePeer;
namespace Comm
{
/** determine whether this object describes an active connection or not. */
bool isOpen() const { return (fd >= 0); }
- /** retrieve the peer pointer for use.
+ /** retrieve the CachePeer pointer for use.
* The caller is responsible for all CBDATA operations regarding the
* used of the pointer returned.
*/
- peer * getPeer() const;
+ CachePeer * getPeer() const;
- /** alter the stored peer pointer.
- * Perform appropriate CBDATA operations for locking the peer pointer
+ /** alter the stored CachePeer pointer.
+ * Perform appropriate CBDATA operations for locking the CachePeer pointer
*/
- void setPeer(peer * p);
+ void setPeer(CachePeer * p);
private:
/** These objects may not be exactly duplicated. Use copyDetails() instead. */
#endif
private:
- // XXX: we need to call this member peer_ but the struct peer_ global type
- // behind peer* clashes despite our private Comm:: namespace
- // (it being global gets inherited here too).
-
/** cache_peer data object (if any) */
- peer *_peer;
+ CachePeer *peer_;
};
}; // namespace Comm
{
SSL *ssl;
SSL_CTX *sslContext = NULL;
- const peer *peer = serverConnection()->getPeer();
+ const CachePeer *peer = serverConnection()->getPeer();
int fd = serverConnection()->fd;
if (peer) {
static void
htcpForwardClr(char *buf, int sz)
{
- peer *p;
+ CachePeer *p;
for (p = Config.peers; p; p = p->next) {
if (!p->options.htcp) {
}
int
-htcpQuery(StoreEntry * e, HttpRequest * req, peer * p)
+htcpQuery(StoreEntry * e, HttpRequest * req, CachePeer * p)
{
cache_key *save_key;
static char pkt[8192];
}
/*
- * Send an HTCP CLR message for a specified item to a given peer.
+ * Send an HTCP CLR message for a specified item to a given CachePeer.
*/
void
-htcpClear(StoreEntry * e, const char *uri, HttpRequest * req, const HttpRequestMethod &method, peer * p, htcp_clr_reason reason)
+htcpClear(StoreEntry * e, const char *uri, HttpRequest * req, const HttpRequestMethod &method, CachePeer * p, htcp_clr_reason reason)
{
static char pkt[8192];
ssize_t pktlen;
* Don't wait for a reply or count in stats as sent.
* \retval -1 Error sending request.
*/
-SQUIDCEXTERN int htcpQuery(StoreEntry * e, HttpRequest * req, peer * p);
+SQUIDCEXTERN int htcpQuery(StoreEntry * e, HttpRequest * req, CachePeer * p);
/// \ingroup ServerProtocolHTCP
-SQUIDCEXTERN void htcpClear(StoreEntry * e, const char *uri, HttpRequest * req, const HttpRequestMethod &method, peer * p, htcp_clr_reason reason);
+SQUIDCEXTERN void htcpClear(StoreEntry * e, const char *uri, HttpRequest * req, const HttpRequestMethod &method, CachePeer * p, htcp_clr_reason reason);
/// \ingroup ServerProtocolHTCP
SQUIDCEXTERN void htcpSocketShutdown(void);
virtual void maybeReadVirginBody(); // read response data from the network
int cacheableReply();
- peer *_peer; /* peer request made to */
+ CachePeer *_peer; /* CachePeer request made to */
int eof; /* reached end-of-object? */
int lastChunk; /* reached last chunk of a chunk-encoded reply */
http_state_flags flags;
} netdb_conn_state_t;
typedef struct {
- peer *p;
+ CachePeer *p;
StoreEntry *e;
store_client *sc;
HttpRequest *r;
static void netdbPurgeLRU(void);
static netdbEntry *netdbLookupHost(const char *key);
static net_db_peer *netdbPeerByName(const netdbEntry * n, const char *);
-static net_db_peer *netdbPeerAdd(netdbEntry * n, peer * e);
+static net_db_peer *netdbPeerAdd(netdbEntry * n, CachePeer * e);
static const char *netdbPeerName(const char *name);
static IPH netdbSendPing;
static QS sortPeerByRtt;
static STCB netdbExchangeHandleReply;
static void netdbExchangeDone(void *);
-/* We have to keep a local list of peer names. The Peers structure
+/* We have to keep a local list of CachePeer names. The Peers structure
* gets freed during a reconfigure. We want this database to
* remain persisitent, so _net_db_peer->peername points into this
* linked list */
}
static net_db_peer *
-netdbPeerAdd(netdbEntry * n, peer * e)
+netdbPeerAdd(netdbEntry * n, CachePeer * e)
{
net_db_peer *p;
net_db_peer *o;
}
void
-netdbUpdatePeer(HttpRequest * r, peer * e, int irtt, int ihops)
+netdbUpdatePeer(HttpRequest * r, CachePeer * e, int irtt, int ihops)
{
#if USE_ICMP
netdbEntry *n;
}
void
-netdbExchangeUpdatePeer(Ip::Address &addr, peer * e, double rtt, double hops)
+netdbExchangeUpdatePeer(Ip::Address &addr, CachePeer * e, double rtt, double hops)
{
#if USE_ICMP
netdbEntry *n;
netdbExchangeStart(void *data)
{
#if USE_ICMP
- peer *p = (peer *)data;
+ CachePeer *p = (CachePeer *)data;
char *uri;
netdbExchangeState *ex;
StoreIOBuffer tempBuffer;
#endif
}
-peer *
+CachePeer *
netdbClosestParent(HttpRequest * request)
{
#if USE_ICMP
- peer *p = NULL;
+ CachePeer *p = NULL;
netdbEntry *n;
const ipcache_addrs *ia;
net_db_peer *h;
class StoreEntry;
class HttpRequest;
-/* for struct peer */
+/* for CachePeer */
#include "structs.h"
SQUIDCEXTERN void netdbInit(void);
SQUIDCEXTERN void netdbFreeMemory(void);
SQUIDCEXTERN int netdbHostHops(const char *host);
SQUIDCEXTERN int netdbHostRtt(const char *host);
-SQUIDCEXTERN void netdbUpdatePeer(HttpRequest *, peer * e, int rtt, int hops);
+SQUIDCEXTERN void netdbUpdatePeer(HttpRequest *, CachePeer * e, int rtt, int hops);
SQUIDCEXTERN void netdbDeleteAddrNetwork(Ip::Address &addr);
SQUIDCEXTERN void netdbBinaryExchange(StoreEntry *);
SQUIDCEXTERN void netdbExchangeStart(void *);
-SQUIDCEXTERN void netdbExchangeUpdatePeer(Ip::Address &, peer *, double, double);
-SQUIDCEXTERN peer *netdbClosestParent(HttpRequest *);
+SQUIDCEXTERN void netdbExchangeUpdatePeer(Ip::Address &, CachePeer *, double, double);
+SQUIDCEXTERN CachePeer *netdbClosestParent(HttpRequest *);
SQUIDCEXTERN void netdbHostData(const char *host, int *samp, int *rtt, int *hops);
#endif /* ICMP_NET_DB_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) {
}
peer_t
-neighborType(const peer * p, const HttpRequest * request)
+neighborType(const CachePeer * p, const HttpRequest * request)
{
const domain_type *d = NULL;
* \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;
}
// 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.
+ // 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())
return false;
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.
*/
* 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();
{
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)
}
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)
}
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->type = PEER_NONE;
/* 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;
}
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;
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];
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;
static void
peerCountMcastPeersStart(void *data)
{
- peer *p = (peer *)data;
+ CachePeer *p = (CachePeer *)data;
ps_state *psstate;
StoreEntry *fake;
MemObject *mem;
StoreEntry *fake = psstate->entry;
if (cbdataReferenceValid(psstate->callback_data)) {
- peer *p = (peer *)psstate->callback_data;
+ CachePeer *p = (CachePeer *)psstate->callback_data;
p->mcast.flags.counting = 0;
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 <<
}
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;
icp_opcode op;
{
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) {
class HttpRequest;
class HttpRequestMethod;
-class peer;
+class CachePeer;
class StoreEntry;
-extern peer *getFirstPeer(void);
-extern peer *getFirstUpParent(HttpRequest *);
-extern peer *getNextPeer(peer *);
-extern peer *getSingleParent(HttpRequest *);
+extern CachePeer *getFirstPeer(void);
+extern CachePeer *getFirstUpParent(HttpRequest *);
+extern CachePeer *getNextPeer(CachePeer *);
+extern CachePeer *getSingleParent(HttpRequest *);
extern int neighborsCount(HttpRequest *);
extern int neighborsUdpPing(HttpRequest *,
StoreEntry *,
#if USE_HTCP
extern void neighborsHtcpClear(StoreEntry *, const char *, HttpRequest *, const HttpRequestMethod &, htcp_clr_reason);
#endif
-extern peer *peerFindByName(const char *);
-extern peer *peerFindByNameAndPort(const char *, unsigned short);
-extern peer *getDefaultParent(HttpRequest * request);
-extern peer *getRoundRobinParent(HttpRequest * request);
-extern peer *getWeightedRoundRobinParent(HttpRequest * request);
+extern CachePeer *peerFindByName(const char *);
+extern CachePeer *peerFindByNameAndPort(const char *, unsigned short);
+extern CachePeer *getDefaultParent(HttpRequest * request);
+extern CachePeer *getRoundRobinParent(HttpRequest * request);
+extern CachePeer *getWeightedRoundRobinParent(HttpRequest * request);
extern void peerClearRRStart(void);
extern void peerClearRR(void);
-extern lookup_t peerDigestLookup(peer * p, HttpRequest * request);
-extern peer *neighborsDigestSelect(HttpRequest * request);
-extern void peerNoteDigestLookup(HttpRequest * request, peer * p, lookup_t lookup);
-extern void peerNoteDigestGone(peer * p);
-extern int neighborUp(const peer * e);
+extern lookup_t peerDigestLookup(CachePeer * p, HttpRequest * request);
+extern CachePeer *neighborsDigestSelect(HttpRequest * request);
+extern void peerNoteDigestLookup(HttpRequest * request, CachePeer * p, lookup_t lookup);
+extern void peerNoteDigestGone(CachePeer * p);
+extern int neighborUp(const CachePeer * e);
extern CBDUNL peerDestroy;
-extern const char *neighborTypeStr(const peer * e);
-extern peer_t neighborType(const peer *, const HttpRequest *);
-extern void peerConnectFailed(peer *);
-extern void peerConnectSucceded(peer *);
-extern void dump_peer_options(StoreEntry *, peer *);
-extern int peerHTTPOkay(const peer *, HttpRequest *);
+extern const char *neighborTypeStr(const CachePeer * e);
+extern peer_t neighborType(const CachePeer *, const HttpRequest *);
+extern void peerConnectFailed(CachePeer *);
+extern void peerConnectSucceded(CachePeer *);
+extern void dump_peer_options(StoreEntry *, CachePeer *);
+extern int peerHTTPOkay(const CachePeer *, HttpRequest *);
-extern peer *whichPeer(const Ip::Address &from);
+extern CachePeer *whichPeer(const Ip::Address &from);
#endif /* SQUID_NEIGHBORS_H_ */
/* initialize peer digest */
static void
-peerDigestInit(PeerDigest * pd, peer * p)
+peerDigestInit(PeerDigest * pd, CachePeer * p)
{
assert(pd && p);
/* allocate new peer digest, call Init, and lock everything */
PeerDigest *
-peerDigestCreate(peer * p)
+peerDigestCreate(CachePeer * p)
{
PeerDigest *pd;
assert(p);
* tell it that the digest is gone.
*/
if (cbdataReferenceValidDone(peerTmp, &p))
- peerNoteDigestGone((peer *)p);
+ peerNoteDigestGone((CachePeer *)p);
peerDigestClean(pd);
static void
peerDigestRequest(PeerDigest * pd)
{
- peer *p = pd->peer;
+ CachePeer *p = pd->peer;
StoreEntry *e, *old_e;
char *url;
const cache_key *key;
static void peerPingTimeout(void *data);
static IRCB peerHandlePingReply;
static void peerSelectStateFree(ps_state * psstate);
-static void peerIcpParentMiss(peer *, icp_common_t *, ps_state *);
+static void peerIcpParentMiss(CachePeer *, icp_common_t *, ps_state *);
#if USE_HTCP
-static void peerHtcpParentMiss(peer *, htcpReplyData *, ps_state *);
-static void peerHandleHtcpReply(peer *, peer_t, htcpReplyData *, void *);
+static void peerHtcpParentMiss(CachePeer *, htcpReplyData *, ps_state *);
+static void peerHandleHtcpReply(CachePeer *, peer_t, htcpReplyData *, void *);
#endif
static int peerCheckNetdbDirect(ps_state * psstate);
static void peerGetSomeNeighbor(ps_state *);
static void peerGetSomeDirect(ps_state *);
static void peerGetSomeParent(ps_state *);
static void peerGetAllParents(ps_state *);
-static void peerAddFwdServer(FwdServer **, peer *, hier_code);
+static void peerAddFwdServer(FwdServer **, CachePeer *, hier_code);
static void peerSelectPinned(ps_state * ps);
static void peerSelectDnsResults(const ipcache_addrs *ia, const DnsLookupDetails &details, void *data);
peerCheckNetdbDirect(ps_state * psstate)
{
#if USE_ICMP
- peer *p;
+ CachePeer *p;
int myrtt;
int myhops;
peerSelectDnsPaths(ps);
}
-bool peerAllowedToUse(const peer * p, HttpRequest * request);
+bool peerAllowedToUse(const CachePeer * p, HttpRequest * request);
/**
* peerSelectPinned
HttpRequest *request = ps->request;
if (!request->pinnedConnection())
return;
- peer *pear = request->pinnedConnection()->pinnedPeer();
+ CachePeer *pear = request->pinnedConnection()->pinnedPeer();
if (Comm::IsConnOpen(request->pinnedConnection()->validatePinnedConnection(request, pear))) {
if (pear && peerAllowedToUse(pear, request)) {
peerAddFwdServer(&ps->servers, pear, PINNED);
{
StoreEntry *entry = ps->entry;
HttpRequest *request = ps->request;
- peer *p;
+ CachePeer *p;
hier_code code = HIER_NONE;
assert(entry->ping_status == PING_NONE);
peerGetSomeNeighborReplies(ps_state * ps)
{
HttpRequest *request = ps->request;
- peer *p = NULL;
+ CachePeer *p = NULL;
hier_code code = HIER_NONE;
assert(ps->entry->ping_status == PING_WAITING);
assert(ps->direct != DIRECT_YES);
static void
peerGetSomeParent(ps_state * ps)
{
- peer *p;
+ CachePeer *p;
HttpRequest *request = ps->request;
hier_code code = HIER_NONE;
debugs(44, 3, "peerGetSomeParent: " << RequestMethodStr(request->method) << " " << request->GetHost());
static void
peerGetAllParents(ps_state * ps)
{
- peer *p;
+ CachePeer *p;
HttpRequest *request = ps->request;
/* Add all alive parents */
}
static void
-peerIcpParentMiss(peer * p, icp_common_t * header, ps_state * ps)
+peerIcpParentMiss(CachePeer * p, icp_common_t * header, ps_state * ps)
{
int rtt;
}
static void
-peerHandleIcpReply(peer * p, peer_t type, icp_common_t * header, void *data)
+peerHandleIcpReply(CachePeer * p, peer_t type, icp_common_t * header, void *data)
{
ps_state *psstate = (ps_state *)data;
icp_opcode op = header->getOpCode();
#if USE_HTCP
static void
-peerHandleHtcpReply(peer * p, peer_t type, htcpReplyData * htcp, void *data)
+peerHandleHtcpReply(CachePeer * p, peer_t type, htcpReplyData * htcp, void *data)
{
ps_state *psstate = (ps_state *)data;
debugs(44, 3, "peerHandleHtcpReply: " <<
}
static void
-peerHtcpParentMiss(peer * p, htcpReplyData * htcp, ps_state * ps)
+peerHtcpParentMiss(CachePeer * p, htcpReplyData * htcp, ps_state * ps)
{
int rtt;
#endif
static void
-peerHandlePingReply(peer * p, peer_t type, AnyP::ProtocolType proto, void *pingdata, void *data)
+peerHandlePingReply(CachePeer * p, peer_t type, AnyP::ProtocolType proto, void *pingdata, void *data)
{
if (proto == AnyP::PROTO_ICP)
peerHandleIcpReply(p, type, (icp_common_t *)pingdata, data);
}
static void
-peerAddFwdServer(FwdServer ** FSVR, peer * p, hier_code code)
+peerAddFwdServer(FwdServer ** FSVR, CachePeer * p, hier_code code)
{
FwdServer *fs = (FwdServer *)memAllocate(MEM_FWD_SERVER);
debugs(44, 5, "peerAddFwdServer: adding " <<
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
static int n_sourcehash_peers = 0;
-static peer **sourcehash_peers = NULL;
+static CachePeer **sourcehash_peers = NULL;
static OBJH peerSourceHashCachemgr;
static void peerSourceHashRegisterWithCacheManager(void);
static int
peerSortWeight(const void *a, const void *b)
{
- const peer *const *p1 = (const peer *const *)a;
- const peer *const *p2 = (const peer *const *)b;
+ const CachePeer *const *p1 = (const CachePeer *const *)a;
+ const CachePeer *const *p2 = (const CachePeer *const *)b;
return (*p1)->weight - (*p2)->weight;
}
int K;
int k;
double P_last, X_last, Xn;
- peer *p;
- peer **P;
+ CachePeer *p;
+ CachePeer **P;
char *t;
/* Clean up */
if (n_sourcehash_peers == 0)
return;
- sourcehash_peers = (peer **)xcalloc(n_sourcehash_peers, sizeof(*sourcehash_peers));
+ sourcehash_peers = (CachePeer **)xcalloc(n_sourcehash_peers, sizeof(*sourcehash_peers));
/* Build a list of the found peers and calculate hashes and load factors */
for (P = sourcehash_peers, p = Config.peers; p; p = p->next) {
peerSourceHashCachemgr, 0, 1);
}
-peer *
+CachePeer *
peerSourceHashSelectParent(HttpRequest * request)
{
int k;
const char *c;
- peer *p = NULL;
- peer *tp;
+ CachePeer *p = NULL;
+ CachePeer *tp;
unsigned int user_hash = 0;
unsigned int combined_hash;
double score;
for (c = key; *c != 0; ++c)
user_hash += ROTATE_LEFT(user_hash, 19) + *c;
- /* select peer */
+ /* select CachePeer */
for (k = 0; k < n_sourcehash_peers; ++k) {
tp = sourcehash_peers[k];
combined_hash = (user_hash ^ tp->sourcehash.hash);
static void
peerSourceHashCachemgr(StoreEntry * sentry)
{
- peer *p;
+ CachePeer *p;
int sumfetches = 0;
storeAppendPrintf(sentry, "%24s %10s %10s %10s %10s\n",
"Hostname",
#ifndef SQUID_PEER_SOURCEHASH_H_
#define SQUID_PEER_SOURCEHASH_H_
-class peer;
+class CachePeer;
class HttpRequest;
extern void peerSourceHashInit(void);
-extern peer * peerSourceHashSelectParent(HttpRequest * request);
+extern CachePeer * peerSourceHashSelectParent(HttpRequest * request);
#endif /* SQUID_PEER_SOURCEHASH_H_ */
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
static int n_userhash_peers = 0;
-static peer **userhash_peers = NULL;
+static CachePeer **userhash_peers = NULL;
static OBJH peerUserHashCachemgr;
static void peerUserHashRegisterWithCacheManager(void);
static int
peerSortWeight(const void *a, const void *b)
{
- const peer *const *p1 = (const peer *const *)a;
- const peer *const *p2 = (const peer *const *)b;
+ const CachePeer *const *p1 = (const CachePeer *const *)a;
+ const CachePeer *const *p2 = (const CachePeer *const *)b;
return (*p1)->weight - (*p2)->weight;
}
int K;
int k;
double P_last, X_last, Xn;
- peer *p;
- peer **P;
+ CachePeer *p;
+ CachePeer **P;
char *t;
/* Clean up */
if (n_userhash_peers == 0)
return;
- userhash_peers = (peer **)xcalloc(n_userhash_peers, sizeof(*userhash_peers));
+ userhash_peers = (CachePeer **)xcalloc(n_userhash_peers, sizeof(*userhash_peers));
/* Build a list of the found peers and calculate hashes and load factors */
for (P = userhash_peers, p = Config.peers; p; p = p->next) {
0, 1);
}
-peer *
+CachePeer *
peerUserHashSelectParent(HttpRequest * request)
{
int k;
const char *c;
- peer *p = NULL;
- peer *tp;
+ CachePeer *p = NULL;
+ CachePeer *tp;
unsigned int user_hash = 0;
unsigned int combined_hash;
double score;
for (c = key; *c != 0; ++c)
user_hash += ROTATE_LEFT(user_hash, 19) + *c;
- /* select peer */
+ /* select CachePeer */
for (k = 0; k < n_userhash_peers; ++k) {
tp = userhash_peers[k];
combined_hash = (user_hash ^ tp->userhash.hash);
static void
peerUserHashCachemgr(StoreEntry * sentry)
{
- peer *p;
+ CachePeer *p;
int sumfetches = 0;
storeAppendPrintf(sentry, "%24s %10s %10s %10s %10s\n",
"Hostname",
#ifndef SQUID_PEER_USERHASH_H_
#define SQUID_PEER_USERHASH_H_
-class peer;
+class CachePeer;
class HttpRequest;
extern void peerUserHashInit(void);
-extern peer * peerUserHashSelectParent(HttpRequest * request);
+extern CachePeer * peerUserHashSelectParent(HttpRequest * request);
#endif /* SQUID_PEER_USERHASH_H_ */
Ip::Address laddr;
char *cp = NULL;
- peer *p = NULL;
+ CachePeer *p = NULL;
int cnt = 0;
debugs(49, 5, "snmp_meshPtblFn: peer " << Var->name[LEN_SQ_MESH + 3] << " requested!");
*ErrP = SNMP_ERR_NOERROR;
peer_Inst(oid * name, snint * len, mib_tree_entry * current, oid_ParseFn ** Fn)
{
oid *instance = NULL;
- peer *peers = Config.peers;
+ CachePeer *peers = Config.peers;
if (peers == NULL) {
debugs(49, 6, "snmp peer_Inst: No Peers.");
{
#if USE_CACHE_DIGESTS
StatCounters *f = &statCounter;
- peer *peer;
+ CachePeer *peer;
const int tot_used = f->cd.times_used + f->icp.times_used;
/* totals */
class PeerDigest;
-struct peer {
+class CachePeer {
+public:
u_int index;
char *name;
char *host;
Ip::Address addresses[10];
int n_addresses;
int rr_count;
- peer *next;
+ CachePeer *next;
int testing_now;
struct {
Comm::Connection::~Connection() STUB
Comm::ConnectionPointer Comm::Connection::copyDetails() const STUB_RETVAL(NULL)
void Comm::Connection::close() STUB
-peer * Comm::Connection::getPeer() const STUB_RETVAL(NULL)
-void Comm::Connection::setPeer(peer * p) STUB
+CachePeer * Comm::Connection::getPeer() const STUB_RETVAL(NULL)
+void Comm::Connection::setPeer(CachePeer * p) STUB
#include "comm/ConnOpener.h"
CBDATA_NAMESPACED_CLASS_INIT(Comm, ConnOpener);
void netdbFreeMemory(void) STUB
int netdbHostHops(const char *host) STUB_RETVAL(-1)
int netdbHostRtt(const char *host) STUB_RETVAL(-1)
-void netdbUpdatePeer(HttpRequest *, peer * e, int rtt, int hops) STUB
+void netdbUpdatePeer(HttpRequest *, CachePeer * e, int rtt, int hops) STUB
void netdbDeleteAddrNetwork(Ip::Address &addr) STUB
void netdbBinaryExchange(StoreEntry *) STUB
void netdbExchangeStart(void *) STUB
-void netdbExchangeUpdatePeer(Ip::Address &, peer *, double, double) STUB
-peer *netdbClosestParent(HttpRequest *) STUB_RETVAL(NULL)
+void netdbExchangeUpdatePeer(Ip::Address &, CachePeer *, double, double) STUB
+CachePeer *netdbClosestParent(HttpRequest *) STUB_RETVAL(NULL)
void netdbHostData(const char *host, int *samp, int *rtt, int *hops) STUB
typedef void IDCB(const char *ident, void *data);
#include "anyp/ProtocolType.h"
-typedef void IRCB(struct peer *, peer_t, AnyP::ProtocolType, void *, void *data);
+class CachePeer;
+typedef void IRCB(CachePeer *, peer_t, AnyP::ProtocolType, void *, void *data);
typedef void RH(void *data, char *);
/* in wordlist.h */
projects / thirdparty / squid.git / commitdiff
