void
clientdbUpdate(struct in_addr addr, log_type ltype, protocol_t p, squid_off_t size)
{
const char *key;
ClientInfo *c;
if (!Config.onoff.client_db)
return;
key = xinet_ntoa(addr);
c = (ClientInfo *) hash_lookup(client_table, key);
if (c == NULL)
c = clientdbAdd(addr);
if (c == NULL)
debug_trap("clientdbUpdate: Failed to add entry");
if (p == PROTO_HTTP) {
c->Http.n_requests++;
c->Http.result_hist[ltype]++;
kb_incr(&c->Http.kbytes_out, size);
if (isTcpHit(ltype))
kb_incr(&c->Http.hit_kbytes_out, size);
} else if (p == PROTO_ICP) {
c->Icp.n_requests++;
c->Icp.result_hist[ltype]++;
kb_incr(&c->Icp.kbytes_out, size);
if (LOG_UDP_HIT == ltype)
kb_incr(&c->Icp.hit_kbytes_out, size);
}
c->last_seen = squid_curtime;
}
static void
netdbHashDelete(const char *key)
{
hash_link *hptr = hash_lookup(addr_table, key);
if (hptr == NULL) {
debug_trap("netdbHashDelete: key not found");
return;
}
hash_remove_link(addr_table, hptr);
}
/*
* clientdbEstablished()
* This function tracks the number of currently established connections
* for a client IP address. When a connection is accepted, call this
* with delta = 1. When the connection is closed, call with delta =
* -1. To get the current value, simply call with delta = 0.
*/
int
clientdbEstablished(struct in_addr addr, int delta)
{
const char *key;
ClientInfo *c;
if (!Config.onoff.client_db)
return 0;
key = xinet_ntoa(addr);
c = (ClientInfo *) hash_lookup(client_table, key);
if (c == NULL)
c = clientdbAdd(addr);
if (c == NULL)
debug_trap("clientdbUpdate: Failed to add entry");
c->n_established += delta;
return c->n_established;
}
void
eventDelete(EVH * func, void *arg)
{
struct ev_entry **E;
struct ev_entry *event;
for (E = &tasks; (event = *E) != NULL; E = &(*E)->next) {
if (event->func != func)
continue;
if (event->arg != arg)
continue;
*E = event->next;
if (NULL != event->arg)
cbdataUnlock(event->arg);
memFree(event, MEM_EVENT);
return;
}
debug_trap("eventDelete: event not found");
}
/* I should attach these records to the entry. We take the first
* hit we get our wait until everyone misses. The timeout handler
* call needs to nip this shopping list or call one of the misses.
*
* If a hit process is already started, then sobeit
*/
void
neighborsUdpAck(const cache_key * key, icp_common_t * header, const struct sockaddr_in *from)
{
peer *p = NULL;
StoreEntry *entry;
MemObject *mem = NULL;
peer_t ntype = PEER_NONE;
const char *opcode_d;
icp_opcode opcode = (icp_opcode) header->opcode;
debug(15, 6) ("neighborsUdpAck: opcode %d '%s'\n",
(int) opcode, storeKeyText(key));
if (NULL != (entry = storeGet(key)))
mem = entry->mem_obj;
if ((p = whichPeer(from)))
neighborAlive(p, mem, header);
if (opcode > ICP_END)
return;
opcode_d = icp_opcode_str[opcode];
if (p)
neighborUpdateRtt(p, mem);
/* Does the entry exist? */
if (NULL == entry) {
debug(12, 3) ("neighborsUdpAck: Cache key '%s' not found\n",
storeKeyText(key));
neighborCountIgnored(p);
return;
}
/* check if someone is already fetching it */
if (EBIT_TEST(entry->flags, ENTRY_DISPATCHED)) {
debug(15, 3) ("neighborsUdpAck: '%s' already being fetched.\n",
storeKeyText(key));
neighborCountIgnored(p);
return;
}
if (mem == NULL) {
debug(15, 2) ("Ignoring %s for missing mem_obj: %s\n",
opcode_d, storeKeyText(key));
neighborCountIgnored(p);
return;
}
if (entry->ping_status != PING_WAITING) {
debug(15, 2) ("neighborsUdpAck: Late %s for %s\n",
opcode_d, storeKeyText(key));
neighborCountIgnored(p);
return;
}
if (entry->lock_count == 0) {
debug(12, 1) ("neighborsUdpAck: '%s' has no locks\n",
storeKeyText(key));
neighborCountIgnored(p);
return;
}
debug(15, 3) ("neighborsUdpAck: %s for '%s' from %s \n",
opcode_d, storeKeyText(key), p ? p->name : "source");
if (p) {
ntype = neighborType(p, mem->request);
}
if (ignoreMulticastReply(p, mem)) {
neighborCountIgnored(p);
} else if (opcode == ICP_MISS) {
if (p == NULL) {
neighborIgnoreNonPeer(from, opcode);
} else {
mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
}
} else if (opcode == ICP_HIT) {
if (p == NULL) {
neighborIgnoreNonPeer(from, opcode);
} else {
header->opcode = ICP_HIT;
mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
}
} else if (opcode == ICP_DECHO) {
if (p == NULL) {
neighborIgnoreNonPeer(from, opcode);
} else if (ntype == PEER_SIBLING) {
debug_trap("neighborsUdpAck: Found non-ICP cache as SIBLING\n");
debug_trap("neighborsUdpAck: non-ICP neighbors must be a PARENT\n");
} else {
mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
}
} else if (opcode == ICP_SECHO) {
if (p) {
debug(15, 1) ("Ignoring SECHO from neighbor %s\n", p->name);
neighborCountIgnored(p);
#if ALLOW_SOURCE_PING
} else if (Config.onoff.source_ping) {
mem->ping_reply_callback(NULL, ntype, PROTO_ICP, header, mem->ircb_data);
#endif
} else {
debug(15, 1) ("Unsolicited SECHO from %s\n", inet_ntoa(from->sin_addr));
}
} else if (opcode == ICP_DENIED) {
if (p == NULL) {
neighborIgnoreNonPeer(from, opcode);
} else if (p->stats.pings_acked > 100) {
if (100 * p->icp.counts[ICP_DENIED] / p->stats.pings_acked > 95) {
debug(15, 0) ("95%% of replies from '%s' are UDP_DENIED\n", p->name);
debug(15, 0) ("Disabling '%s', please check your configuration.\n", p->name);
neighborRemove(p);
p = NULL;
} else {
neighborCountIgnored(p);
}
}
} else if (opcode == ICP_MISS_NOFETCH) {
mem->ping_reply_callback(p, ntype, PROTO_ICP, header, mem->ircb_data);
} else {
debug(15, 0) ("neighborsUdpAck: Unexpected ICP reply: %s\n", opcode_d);
}
}
void
unlinkdUnlink(const char *path)
{
#if USE_UNLINKD
char buf[MAXPATHLEN];
int l;
int x;
static int queuelen = 0;
if (unlinkd_wfd < 0) {
debug_trap("unlinkdUnlink: unlinkd_wfd < 0");
safeunlink(path, 0);
return;
}
/*
* If the queue length is greater than our limit, then
* we pause for up to 100ms, hoping that unlinkd
* has some feedback for us. Maybe it just needs a slice
* of the CPU's time.
*/
if (queuelen >= UNLINKD_QUEUE_LIMIT) {
struct timeval to;
fd_set R;
int x;
FD_ZERO(&R);
FD_SET(unlinkd_rfd, &R);
to.tv_sec = 0;
to.tv_usec = 100000;
x = select(unlinkd_rfd + 1, &R, NULL, NULL, &to);
}
/*
* If there is at least one outstanding unlink request, then
* try to read a response. If there's nothing to read we'll
* get an EWOULDBLOCK or whatever. If we get a response, then
* decrement the queue size by the number of newlines read.
*/
if (queuelen > 0) {
int x;
int i;
char rbuf[512];
x = read(unlinkd_rfd, rbuf, 511);
if (x > 0) {
rbuf[x] = '\0';
for (i = 0; i < x; i++)
if ('\n' == rbuf[i])
queuelen--;
assert(queuelen >= 0);
}
}
l = strlen(path);
assert(l < MAXPATHLEN);
xstrncpy(buf, path, MAXPATHLEN);
buf[l++] = '\n';
x = write(unlinkd_wfd, buf, l);
if (x < 0) {
debug(50, 1) ("unlinkdUnlink: write FD %d failed: %s\n",
unlinkd_wfd, xstrerror());
safeunlink(path, 0);
return;
} else if (x != l) {
debug(50, 1) ("unlinkdUnlink: FD %d only wrote %d of %d bytes\n",
unlinkd_wfd, x, l);
safeunlink(path, 0);
return;
}
Counter.unlink.requests++;
queuelen++;
#endif
}
void
unlinkdUnlink(const char *path)
{
char buf[MAXPATHLEN];
int l;
int x;
static int queuelen = 0;
if (unlinkd_wfd < 0) {
debug_trap("unlinkdUnlink: unlinkd_wfd < 0");
safeunlink(path, 0);
return;
}
/*
* If the queue length is greater than our limit, then
* we pause for up to 10ms, hoping that unlinkd
* has some feedback for us. Maybe it just needs a slice
* of the CPU's time.
*/
if (queuelen >= UNLINKD_QUEUE_LIMIT)
xusleep(10000);
/*
* If there is at least one outstanding unlink request, then
* try to read a response. If there's nothing to read we'll
* get an EWOULDBLOCK or whatever. If we get a response, then
* decrement the queue size by the number of newlines read.
*/
if (queuelen > 0) {
int x;
int i;
char rbuf[512];
#ifdef _SQUID_MSWIN_
x = recv(unlinkd_rfd, rbuf, 511, 0);
#else
x = read(unlinkd_rfd, rbuf, 511);
#endif
if (x > 0) {
rbuf[x] = '\0';
for (i = 0; i < x; i++)
if ('\n' == rbuf[i])
queuelen--;
assert(queuelen >= 0);
}
}
l = strlen(path);
assert(l < MAXPATHLEN);
xstrncpy(buf, path, MAXPATHLEN);
buf[l++] = '\n';
#ifdef _SQUID_MSWIN_
x = send(unlinkd_wfd, buf, l, 0);
#else
x = write(unlinkd_wfd, buf, l);
#endif
if (x < 0) {
debug(2, 1) ("unlinkdUnlink: write FD %d failed: %s\n",
unlinkd_wfd, xstrerror());
safeunlink(path, 0);
return;
} else if (x != l) {
debug(2, 1) ("unlinkdUnlink: FD %d only wrote %d of %d bytes\n",
unlinkd_wfd, x, l);
safeunlink(path, 0);
return;
}
statCounter.unlink.requests++;
statCounter.syscalls.disk.unlinks++;
queuelen++;
}