void
netdbExchangeStart(void *data)
{
#if USE_ICMP
peer *p = data;
char *uri;
netdbExchangeState *ex;
method_t *method_get;
CBDATA_INIT_TYPE(netdbExchangeState);
ex = cbdataAlloc(netdbExchangeState);
cbdataLock(p);
ex->p = p;
uri = internalRemoteUri(p->host, p->http_port, "/squid-internal-dynamic/", "netdb");
debug(38, 3) ("netdbExchangeStart: Requesting '%s'\n", uri);
assert(NULL != uri);
method_get = urlMethodGetKnownByCode(METHOD_GET);
ex->r = urlParse(method_get, uri);
if (NULL == ex->r) {
debug(38, 1) ("netdbExchangeStart: Bad URI %s\n", uri);
return;
}
requestLink(ex->r);
assert(NULL != ex->r);
httpBuildVersion(&ex->r->http_ver, 1, 0);
ex->e = storeCreateEntry(uri, null_request_flags, method_get);
assert(NULL != ex->e);
ex->sc = storeClientRegister(ex->e, ex);
storeClientRef(ex->sc, ex->e, ex->seen, ex->used, SM_PAGE_SIZE,
netdbExchangeHandleReply, ex);
ex->r->flags.loopdetect = 1; /* cheat! -- force direct */
if (p->login)
xstrncpy(ex->r->login, p->login, MAX_LOGIN_SZ);
fwdStart(-1, ex->e, ex->r);
#endif
}
static void
asnCacheStart(int as)
{
LOCAL_ARRAY(char, asres, 4096);
StoreEntry *e;
request_t *req;
ASState *asState;
method_t *method_get;
method_get = urlMethodGetKnownByCode(METHOD_GET);
asState = cbdataAlloc(ASState);
debug(53, 3) ("asnCacheStart: AS %d\n", as);
snprintf(asres, 4096, "whois://%s/!gAS%d", Config.as_whois_server, as);
asState->as_number = as;
req = urlParse(method_get, asres);
assert(NULL != req);
asState->request = requestLink(req);
if ((e = storeGetPublic(asres, method_get)) == NULL) {
e = storeCreateEntry(asres, null_request_flags, method_get);
asState->sc = storeClientRegister(e, asState);
fwdStart(-1, e, asState->request);
} else {
storeLockObject(e);
asState->sc = storeClientRegister(e, asState);
}
asState->entry = e;
asState->seen = 0;
asState->offset = 0;
storeClientRef(asState->sc,
e,
asState->seen,
asState->offset,
SM_PAGE_SIZE,
asHandleReply,
asState);
}
int
errorMapStart(const errormap * map, request_t * client_req, HttpReply * reply, const char *aclname, ERRMAPCB * callback, void *callback_data)
{
char squid_error[100];
int len = 0;
const char *errorUrl;
ErrorMapState *state;
const char *tmp;
http_status status;
request_t *req;
HttpHeaderPos hdrpos;
HttpHeaderEntry *hdr;
if (!client_req || !reply)
return 0;
status = reply->sline.status;
tmp = httpHeaderGetStr(&reply->header, HDR_X_SQUID_ERROR);
squid_error[0] = '\0';
if (tmp) {
xstrncpy(squid_error, tmp, sizeof(squid_error));
len = strcspn(squid_error, " ");
}
squid_error[len] = '\0';
errorUrl = getErrorMap(map, status, squid_error, aclname);
if (!errorUrl)
return 0;
req = urlParse(urlMethodGetKnownByCode(METHOD_GET), (char *) errorUrl);
if (!req) {
debug(0, 0) ("errorMapStart: Invalid error URL '%s'\n", errorUrl);
return 0;
}
req->urlgroup = xstrdup("error");
state = cbdataAlloc(ErrorMapState);
state->req = requestLink(req);
state->e = storeCreateEntry(errorUrl, req->flags, req->method);
state->sc = storeClientRegister(state->e, state);
state->callback = callback;
state->callback_data = callback_data;
cbdataLock(callback_data);
hdrpos = HttpHeaderInitPos;
while ((hdr = httpHeaderGetEntry(&client_req->header, &hdrpos)) != NULL) {
if (CBIT_TEST(client_headers, hdr->id))
httpHeaderAddClone(&req->header, hdr);
}
hdrpos = HttpHeaderInitPos;
while ((hdr = httpHeaderGetEntry(&reply->header, &hdrpos)) != NULL) {
if (CBIT_TEST(server_headers, hdr->id))
httpHeaderAddClone(&req->header, hdr);
}
httpHeaderPutInt(&req->header, HDR_X_ERROR_STATUS, (int) reply->sline.status);
httpHeaderPutStr(&req->header, HDR_X_REQUEST_URI, urlCanonical(client_req));
fwdStart(-1, state->e, req);
storeClientRef(state->sc, state->e, 0, 0, SM_PAGE_SIZE, errorMapFetchHeaders, state);
return 1;
}
/* starts swap out sequence for the digest */
static void
storeDigestRewriteStart(void *datanotused)
{
request_flags flags;
char *url;
StoreEntry *e;
method_t *method_get;
assert(store_digest);
method_get = urlMethodGetKnownByCode(METHOD_GET);
/* prevent overlapping if rewrite schedule is too tight */
if (sd_state.rewrite_lock) {
debug(71, 1) ("storeDigestRewriteStart: overlap detected, consider increasing rewrite period\n");
return;
}
debug(71, 2) ("storeDigestRewriteStart: start rewrite #%d\n", sd_state.rewrite_count + 1);
/* make new store entry */
url = internalStoreUri("/squid-internal-periodic/", StoreDigestFileName);
flags = null_request_flags;
flags.cachable = 1;
e = storeCreateEntry(url, flags, method_get);
assert(e);
sd_state.rewrite_lock = cbdataAlloc(generic_cbdata);
sd_state.rewrite_lock->data = e;
debug(71, 3) ("storeDigestRewriteStart: url: %s key: %s\n", url, storeKeyText(e->hash.key));
e->mem_obj->request = requestLink(urlParse(method_get, url));
/* wait for rebuild (if any) to finish */
if (sd_state.rebuild_lock) {
debug(71, 2) ("storeDigestRewriteStart: waiting for rebuild to finish.\n");
return;
}
storeDigestRewriteResume();
}
static void
peerCountMcastPeersStart(void *data)
{
peer *p = data;
ps_state *psstate;
StoreEntry *fake;
MemObject *mem;
icp_common_t *query;
int reqnum;
method_t *method_get;
LOCAL_ARRAY(char, url, MAX_URL);
assert(p->type == PEER_MULTICAST);
method_get = urlMethodGetKnownByCode(METHOD_GET);
p->mcast.flags.count_event_pending = 0;
snprintf(url, MAX_URL, "http://%s/", inet_ntoa(p->in_addr.sin_addr));
fake = storeCreateEntry(url, null_request_flags, method_get);
psstate = cbdataAlloc(ps_state);
psstate->request = requestLink(urlParse(method_get, url));
psstate->entry = fake;
psstate->callback = NULL;
psstate->callback_data = p;
cbdataLock(psstate->callback_data);
psstate->ping.start = current_time;
mem = fake->mem_obj;
mem->request = requestLink(psstate->request);
mem->start_ping = current_time;
mem->ping_reply_callback = peerCountHandleIcpReply;
mem->ircb_data = psstate;
mcastSetTtl(theOutIcpConnection, p->mcast.ttl);
p->mcast.id = mem->id;
reqnum = icpSetCacheKey(fake->hash.key);
query = icpCreateMessage(ICP_QUERY, 0, url, reqnum, 0);
icpUdpSend(theOutIcpConnection,
&p->in_addr,
query,
LOG_ICP_QUERY,
0);
fake->ping_status = PING_WAITING;
eventAdd("peerCountMcastPeersDone",
peerCountMcastPeersDone,
psstate,
Config.Timeout.mcast_icp_query / 1000.0, 1);
p->mcast.flags.counting = 1;
peerCountMcastPeersSchedule(p, MCAST_COUNT_RATE);
}
static void
peerMonitorRequest(void *data)
{
PeerMonitor *pm = data;
char *url;
request_t *req;
if (!cbdataValid(pm->peer)) {
cbdataFree(pm);
return;
}
url = pm->peer->monitor.url;
if (!url) {
cbdataFree(pm);
return;
}
req = urlParse(urlMethodGetKnownByCode(METHOD_GET), url);
if (!req) {
debug(DBG, 1) ("peerMonitorRequest: Failed to parse URL '%s' for cache_peer %s\n", url, pm->peer->name);
cbdataFree(pm);
return;
}
pm->last_probe = squid_curtime;
pm->running.timeout_set = 1;
eventAdd(pm->name, peerMonitorTimeout, pm, (double) (pm->peer->monitor.timeout ? pm->peer->monitor.timeout : pm->peer->monitor.interval), 0);
httpHeaderPutStr(&req->header, HDR_ACCEPT, "*/*");
httpHeaderPutStr(&req->header, HDR_USER_AGENT, full_appname_string);
if (pm->peer->login)
xstrncpy(req->login, pm->peer->login, MAX_LOGIN_SZ);
pm->running.req = requestLink(req);
pm->running.e = storeCreateEntry(url, req->flags, req->method);
pm->running.sc = storeClientRegister(pm->running.e, pm);
if (pm->peer->options.monitor_direct)
fwdStartPeer(NULL, pm->running.e, pm->running.req);
else
fwdStartPeer(pm->peer, pm->running.e, pm->running.req);
storeClientRef(pm->running.sc, pm->running.e, 0, 0, SM_PAGE_SIZE, peerMonitorFetchReplyHeaders, pm);
return;
}
/* ask store for a digest */
static void
peerDigestRequest(PeerDigest * pd)
{
peer *p = pd->peer;
StoreEntry *e, *old_e;
char *url;
const cache_key *key;
request_t *req;
DigestFetchState *fetch = NULL;
pd->req_result = NULL;
pd->flags.requested = 1;
/* compute future request components */
if (p->digest_url)
url = xstrdup(p->digest_url);
else
url = internalRemoteUri(p->host, p->http_port,
"/squid-internal-periodic/", StoreDigestFileName);
req = urlParse(urlMethodGetKnownByCode(METHOD_GET), url);
assert(req);
key = storeKeyPublicByRequest(req);
debug(72, 2) ("peerDigestRequest: %s key: %s\n", url, storeKeyText(key));
/* add custom headers */
assert(!req->header.len);
httpHeaderPutStr(&req->header, HDR_ACCEPT, StoreDigestMimeStr);
httpHeaderPutStr(&req->header, HDR_ACCEPT, "text/html");
if (p->login)
xstrncpy(req->login, p->login, MAX_LOGIN_SZ);
/* create fetch state structure */
CBDATA_INIT_TYPE(DigestFetchState);
fetch = cbdataAlloc(DigestFetchState);
fetch->request = requestLink(req);
fetch->pd = pd;
fetch->offset = 0;
/* update timestamps */
fetch->start_time = squid_curtime;
pd->times.requested = squid_curtime;
pd_last_req_time = squid_curtime;
req->flags.cachable = 1;
/* the rest is based on clientProcessExpired() */
req->flags.refresh = 1;
old_e = fetch->old_entry = storeGet(key);
if (old_e) {
debug(72, 5) ("peerDigestRequest: found old entry\n");
storeLockObject(old_e);
storeCreateMemObject(old_e, url);
fetch->old_sc = storeClientRegister(old_e, fetch);
}
e = fetch->entry = storeCreateEntry(url, req->flags, req->method);
assert(EBIT_TEST(e->flags, KEY_PRIVATE));
fetch->sc = storeClientRegister(e, fetch);
/* set lastmod to trigger IMS request if possible */
if (old_e)
e->lastmod = old_e->lastmod;
/* push towards peer cache */
debug(72, 3) ("peerDigestRequest: forwarding to fwdStart...\n");
fwdStart(-1, e, req);
cbdataLock(fetch->pd);
storeClientRef(fetch->sc, e, 0, 0, SM_PAGE_SIZE, peerDigestFetchReply, fetch);
}