peer *
netdbClosestParent(request_t * request)
{
#if USE_ICMP
peer *p = NULL;
netdbEntry *n;
const ipcache_addrs *ia;
net_db_peer *h;
int i;
n = netdbLookupHost(request->host);
if (NULL == n) {
/* try IP addr */
ia = ipcache_gethostbyname(request->host, 0);
if (NULL != ia)
n = netdbLookupAddr(ia->in_addrs[ia->cur]);
}
if (NULL == n)
return NULL;
if (0 == n->n_peers)
return NULL;
n->last_use_time = squid_curtime;
/*
* Find the parent with the least RTT to the origin server.
* Make sure we don't return a parent who is farther away than
* we are. Note, the n->peers list is pre-sorted by RTT.
*/
for (i = 0; i < n->n_peers; i++) {
h = &n->peers[i];
if (n->rtt > 0)
if (n->rtt < h->rtt)
break;
p = peerFindByName(h->peername);
if (NULL == p) /* not found */
continue;
if (neighborType(p, request) != PEER_PARENT)
continue;
if (!peerHTTPOkay(p, request)) /* not allowed */
continue;
return p;
}
#endif
return NULL;
}
int
neighborsUdpPing(request_t * request,
StoreEntry * entry,
IRCB * callback,
void *callback_data,
int *exprep,
int *timeout)
{
const char *url = storeUrl(entry);
MemObject *mem = entry->mem_obj;
peer *p = NULL;
int i;
int reqnum = 0;
int flags;
icp_common_t *query;
int queries_sent = 0;
int peers_pinged = 0;
int parent_timeout = 0, parent_exprep = 0;
int sibling_timeout = 0, sibling_exprep = 0;
int mcast_timeout = 0, mcast_exprep = 0;
if (Config.peers == NULL)
return 0;
if (theOutIcpConnection < 0)
fatal("neighborsUdpPing: There is no ICP socket!");
assert(entry->swap_status == SWAPOUT_NONE);
mem->start_ping = current_time;
mem->ping_reply_callback = callback;
mem->ircb_data = callback_data;
reqnum = icpSetCacheKey(entry->hash.key);
for (i = 0, p = first_ping; i++ < Config.npeers; p = p->next) {
if (p == NULL)
p = Config.peers;
debug(15, 5) ("neighborsUdpPing: Peer %s\n", p->name);
if (!peerWouldBePinged(p, request))
continue; /* next peer */
peers_pinged++;
debug(15, 4) ("neighborsUdpPing: pinging peer %s for '%s'\n",
p->name, url);
if (p->type == PEER_MULTICAST)
mcastSetTtl(theOutIcpConnection, p->mcast.ttl);
debug(15, 3) ("neighborsUdpPing: key = '%s'\n", storeKeyText(entry->hash.key));
debug(15, 3) ("neighborsUdpPing: reqnum = %d\n", reqnum);
#if USE_HTCP
if (p->options.htcp && !p->options.htcp_only_clr) {
debug(15, 3) ("neighborsUdpPing: sending HTCP query\n");
htcpQuery(entry, request, p);
} else
#endif
if (p->icp.port == echo_port) {
debug(15, 4) ("neighborsUdpPing: Looks like a dumb cache, send DECHO ping\n");
echo_hdr.reqnum = reqnum;
query = icpCreateMessage(ICP_DECHO, 0, url, reqnum, 0);
icpUdpSend(theOutIcpConnection,
&p->in_addr,
query,
LOG_ICP_QUERY,
0);
} else {
flags = 0;
if (Config.onoff.query_icmp)
if (p->icp.version == ICP_VERSION_2)
flags |= ICP_FLAG_SRC_RTT;
query = icpCreateMessage(ICP_QUERY, flags, url, reqnum, 0);
icpUdpSend(theOutIcpConnection,
&p->in_addr,
query,
LOG_ICP_QUERY,
0);
}
queries_sent++;
p->stats.pings_sent++;
if (p->type == PEER_MULTICAST) {
mcast_exprep += p->mcast.n_replies_expected;
mcast_timeout += (p->stats.rtt * p->mcast.n_replies_expected);
} else if (neighborUp(p)) {
/* its alive, expect a reply from it */
if (neighborType(p, request) == PEER_PARENT) {
parent_exprep++;
parent_timeout += p->stats.rtt;
} else {
sibling_exprep++;
sibling_timeout += p->stats.rtt;
}
} else {
/* Neighbor is dead; ping it anyway, but don't expect a reply */
/* log it once at the threshold */
if (p->stats.logged_state == PEER_ALIVE) {
debug(15, 1) ("Detected DEAD %s: %s\n",
neighborTypeStr(p), p->name);
p->stats.logged_state = PEER_DEAD;
}
}
p->stats.last_query = squid_curtime;
/*
* keep probe_start == 0 for a multicast peer,
* so neighborUp() never says this peer is dead.
*/
if ((p->type != PEER_MULTICAST) && (p->stats.probe_start == 0))
p->stats.probe_start = squid_curtime;
}
if ((first_ping = first_ping->next) == NULL)
first_ping = Config.peers;
#if ALLOW_SOURCE_PING
/* only do source_ping if we have neighbors */
if (Config.npeers) {
const ipcache_addrs *ia = NULL;
struct sockaddr_in to_addr;
char *host = request->host;
if (!Config.onoff.source_ping) {
debug(15, 6) ("neighborsUdpPing: Source Ping is disabled.\n");
} else if ((ia = ipcache_gethostbyname(host, 0))) {
debug(15, 6) ("neighborsUdpPing: Source Ping: to %s for '%s'\n",
host, url);
echo_hdr.reqnum = reqnum;
if (icmp_sock != -1) {
icmpSourcePing(ia->in_addrs[ia->cur], &echo_hdr, url);
} else {
to_addr.sin_family = AF_INET;
to_addr.sin_addr = ia->in_addrs[ia->cur];
to_addr.sin_port = htons(echo_port);
query = icpCreateMessage(ICP_SECHO, 0, url, reqnum, 0);
icpUdpSend(theOutIcpConnection,
&to_addr,
query,
LOG_ICP_QUERY,
0);
}
} else {
debug(15, 6) ("neighborsUdpPing: Source Ping: unknown host: %s\n",
host);
}
}
#endif
/*
* How many replies to expect?
*/
*exprep = parent_exprep + sibling_exprep + mcast_exprep;
/*
* If there is a configured timeout, use it
*/
if (Config.Timeout.icp_query)
*timeout = Config.Timeout.icp_query;
else {
if (*exprep > 0) {
if (parent_exprep)
*timeout = 2 * parent_timeout / parent_exprep;
else if (mcast_exprep)
*timeout = 2 * mcast_timeout / mcast_exprep;
else
*timeout = 2 * sibling_timeout / sibling_exprep;
} else
*timeout = 2000; /* 2 seconds */
if (Config.Timeout.icp_query_max)
if (*timeout > Config.Timeout.icp_query_max)
*timeout = Config.Timeout.icp_query_max;
if (*timeout < Config.Timeout.icp_query_min)
*timeout = Config.Timeout.icp_query_min;
}
return peers_pinged;
}
