/* fetch headers from disk, pass on to SwapInCBlock */
static void
peerDigestSwapInHeaders(void *data, char *buf, ssize_t size)
{
DigestFetchState *fetch = data;
size_t hdr_size;
if (peerDigestFetchedEnough(fetch, buf, size, "peerDigestSwapInHeaders"))
return;
assert(!fetch->offset);
if ((hdr_size = headersEnd(buf, size))) {
assert(fetch->entry->mem_obj->reply);
if (!fetch->entry->mem_obj->reply->sline.status)
httpReplyParse(fetch->entry->mem_obj->reply, buf, hdr_size);
if (fetch->entry->mem_obj->reply->sline.status != HTTP_OK) {
debug(72, 1) ("peerDigestSwapInHeaders: %s status %d got cached!\n",
strBuf(fetch->pd->host), fetch->entry->mem_obj->reply->sline.status);
peerDigestFetchAbort(fetch, buf, "internal status error");
return;
}
fetch->offset += hdr_size;
storeClientCopy(fetch->entry, size, fetch->offset,
SM_PAGE_SIZE, buf,
peerDigestSwapInCBlock, fetch);
} else {
/* need more data, do we have space? */
if (size >= SM_PAGE_SIZE)
peerDigestFetchAbort(fetch, buf, "stored header too big");
else
storeClientCopy(fetch->entry, size, 0, SM_PAGE_SIZE, buf,
peerDigestSwapInHeaders, fetch);
}
}
static void
peerMonitorFetchReplyHeaders(void *data, char *buf, ssize_t size)
{
PeerMonitor *pm = data;
HttpReply *reply;
http_status status;
if (EBIT_TEST(pm->running.e->flags, ENTRY_ABORTED))
goto completed;
if (size <= 0)
goto completed;
if (!cbdataValid(pm->peer))
goto completed;
reply = pm->running.e->mem_obj->reply;
assert(reply);
status = reply->sline.status;
pm->running.status = status;
if (status != HTTP_OK)
goto completed;
if (size > reply->hdr_sz) {
pm->running.size = size - reply->hdr_sz;
pm->running.offset = size;
} else {
pm->running.size = 0;
pm->running.offset = reply->hdr_sz;
}
storeClientCopy(pm->running.sc, pm->running.e, pm->running.offset, pm->running.offset, 4096, buf, peerMonitorFetchReply, pm);
return;
completed:
/* We are fully done with this monitoring request. Clean up */
peerMonitorCompleted(pm);
return;
}
static void
asnCacheStart(int as)
{
LOCAL_ARRAY(char, asres, 4096);
StoreEntry *e;
request_t *req;
ASState *asState;
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, 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;
storeClientCopy(asState->sc,
e,
asState->seen,
asState->offset,
4096,
memAllocate(MEM_4K_BUF),
asHandleReply,
asState);
}
static void
peerDigestSwapInMask(void *data, char *buf, ssize_t size)
{
DigestFetchState *fetch = data;
PeerDigest *pd;
/* NOTE! buf points to the middle of pd->cd->mask! */
if (peerDigestFetchedEnough(fetch, NULL, size, "peerDigestSwapInMask"))
return;
pd = fetch->pd;
assert(pd->cd && pd->cd->mask);
fetch->offset += size;
fetch->mask_offset += size;
if (fetch->mask_offset >= pd->cd->mask_size) {
debug(72, 2) ("peerDigestSwapInMask: Done! Got %d, expected %d\n",
fetch->mask_offset, pd->cd->mask_size);
assert(fetch->mask_offset == pd->cd->mask_size);
assert(peerDigestFetchedEnough(fetch, NULL, 0, "peerDigestSwapInMask"));
} else {
const size_t buf_sz = pd->cd->mask_size - fetch->mask_offset;
assert(buf_sz > 0);
storeClientCopy(fetch->entry,
fetch->offset,
fetch->offset,
buf_sz,
pd->cd->mask + fetch->mask_offset,
peerDigestSwapInMask, fetch);
}
}
void
netdbExchangeStart(void *data)
{
#if USE_ICMP
peer *p = data;
char *uri;
netdbExchangeState *ex;
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);
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, uri, null_request_flags, METHOD_GET);
ex->buf_sz = 4096;
ex->buf = memAllocate(MEM_4K_BUF);
assert(NULL != ex->e);
ex->sc = storeClientRegister(ex->e, ex);
storeClientCopy(ex->sc, ex->e, ex->seen, ex->used, ex->buf_sz,
ex->buf, 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
}
void
urnStart(request_t * r, StoreEntry * e)
{
LOCAL_ARRAY(char, urlres, 4096);
request_t *urlres_r = NULL;
const char *t;
char *host;
UrnState *urnState;
StoreEntry *urlres_e;
ErrorState *err;
debug(52, 3) ("urnStart: '%s'\n", storeUrl(e));
CBDATA_INIT_TYPE(UrnState);
urnState = cbdataAlloc(UrnState);
urnState->entry = e;
urnState->request = requestLink(r);
storeLockObject(urnState->entry);
if (strncasecmp(strBuf(r->urlpath), "menu.", 5) == 0) {
char *new_path = xstrdup(strBuf(r->urlpath) + 5);
urnState->flags.force_menu = 1;
stringReset(&r->urlpath, new_path);
xfree(new_path);
}
if ((t = strChr(r->urlpath, ':')) != NULL) {
strSet(r->urlpath, t, '\0');
host = xstrdup(strBuf(r->urlpath));
strSet(r->urlpath, t, ':');
} else {
host = xstrdup(strBuf(r->urlpath));
}
snprintf(urlres, 4096, "http://%s/uri-res/N2L?urn:%s", host, strBuf(r->urlpath));
safe_free(host);
urlres_r = urlParse(METHOD_GET, urlres);
if (urlres_r == NULL) {
debug(52, 3) ("urnStart: Bad uri-res URL %s\n", urlres);
err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
err->url = xstrdup(urlres);
errorAppendEntry(e, err);
return;
}
httpHeaderPutStr(&urlres_r->header, HDR_ACCEPT, "text/plain");
if ((urlres_e = storeGetPublic(urlres, METHOD_GET)) == NULL) {
urlres_e = storeCreateEntry(urlres, urlres, null_request_flags, METHOD_GET);
urnState->sc = storeClientListAdd(urlres_e, urnState);
fwdStart(-1, urlres_e, urlres_r);
} else {
storeLockObject(urlres_e);
urnState->sc = storeClientListAdd(urlres_e, urnState);
}
urnState->urlres_e = urlres_e;
urnState->urlres_r = requestLink(urlres_r);
storeClientCopy(urnState->sc, urlres_e,
0,
0,
4096,
memAllocate(MEM_4K_BUF),
urnHandleReply,
urnState);
}
static void
peerMonitorFetchReply(void *data, char *buf, ssize_t size)
{
PeerMonitor *pm = data;
if (size <= 0 || !cbdataValid(pm->peer)) {
peerMonitorCompleted(pm);
} else {
pm->running.size += size;
pm->running.offset += size;
storeClientCopy(pm->running.sc, pm->running.e, pm->running.offset, pm->running.offset, 4096, buf, peerMonitorFetchReply, pm);
}
}
static void
peerDigestSwapInCBlock(void *data, char *buf, ssize_t size)
{
DigestFetchState *fetch = data;
if (peerDigestFetchedEnough(fetch, buf, size, "peerDigestSwapInCBlock"))
return;
if (size >= StoreDigestCBlockSize) {
PeerDigest *pd = fetch->pd;
HttpReply *rep = fetch->entry->mem_obj->reply;
const int seen = fetch->offset + size;
assert(pd && rep);
if (peerDigestSetCBlock(pd, buf)) {
/* XXX: soon we will have variable header size */
fetch->offset += StoreDigestCBlockSize;
/* switch to CD buffer and fetch digest guts */
memFree(buf, MEM_4K_BUF);
buf = NULL;
assert(pd->cd->mask);
storeClientCopy(fetch->entry,
seen,
fetch->offset,
pd->cd->mask_size,
pd->cd->mask,
peerDigestSwapInMask, fetch);
} else {
peerDigestFetchAbort(fetch, buf, "invalid digest cblock");
}
} else {
/* need more data, do we have space? */
if (size >= SM_PAGE_SIZE)
peerDigestFetchAbort(fetch, buf, "digest cblock too big");
else
storeClientCopy(fetch->entry, size, 0, SM_PAGE_SIZE, buf,
peerDigestSwapInCBlock, fetch);
}
}
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(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);
pm->running.buf = memAllocate(MEM_4K_BUF);
fwdStartPeer(pm->peer, pm->running.e, pm->running.req);
storeClientCopy(pm->running.sc, pm->running.e, 0, 0, 4096, pm->running.buf, peerMonitorFetchReplyHeaders, pm);
return;
}
static void
storeUpdateCopy(void *data, char *buf, ssize_t size)
{
StoreUpdateState *state = data;
if (EBIT_TEST(state->newentry->flags, ENTRY_ABORTED)) {
debug(20, 1) ("storeUpdateCopy: Aborted at %d (%d)\n", (int) state->offset, (int) size);
/* the abort callback deals with the needed cleanup */
return;
}
if (EBIT_TEST(state->newentry->flags, KEY_PRIVATE) && state->newentry->mem_obj->nclients == 0) {
debug(20, 2) ("storeUpdateCopy: Gone stale with no clients, skip copying of the rest\n");
storeUpdateDone(state);
return;
}
if (size < 0) {
debug(20, 1) ("storeUpdateCopy: Error at %d (%d)\n", (int) state->offset, (int) size);
storeUpdateDone(state);
return;
}
if (size > 0) {
storeAppend(state->newentry, buf, size);
if (EBIT_TEST(state->newentry->flags, ENTRY_ABORTED)) {
debug(20, 1) ("storeUpdateCopy: Aborted on write at %d (%d)\n", (int) state->offset, (int) size);
return;
}
state->offset += size;
storeClientCopy(state->sc, state->oldentry, state->offset, state->offset, sizeof(state->buf), state->buf, storeUpdateCopy, state);
return;
} else {
storeComplete(state->newentry);
storeUnlockObject(state->newentry);
state->newentry = NULL;
storeUpdateDone(state);
}
}
static void
asHandleReply(void *data, char *buf, ssize_t size)
{
ASState *asState = data;
StoreEntry *e = asState->entry;
char *s;
char *t;
debug(53, 3) ("asHandleReply: Called with size=%ld\n", (long int) size);
if (EBIT_TEST(e->flags, ENTRY_ABORTED)) {
memFree(buf, MEM_4K_BUF);
asStateFree(asState);
return;
}
if (size == 0 && e->mem_obj->inmem_hi > 0) {
memFree(buf, MEM_4K_BUF);
asStateFree(asState);
return;
} else if (size < 0) {
debug(53, 1) ("asHandleReply: Called with size=%ld\n", (long int) size);
memFree(buf, MEM_4K_BUF);
asStateFree(asState);
return;
} else if (HTTP_OK != e->mem_obj->reply->sline.status) {
debug(53, 1) ("WARNING: AS %d whois request failed\n",
asState->as_number);
memFree(buf, MEM_4K_BUF);
asStateFree(asState);
return;
}
s = buf;
while (s - buf < size && *s != '\0') {
while (*s && xisspace(*s))
s++;
for (t = s; *t; t++) {
if (xisspace(*t))
break;
}
if (*t == '\0') {
/* oof, word should continue on next block */
break;
}
*t = '\0';
debug(53, 3) ("asHandleReply: AS# %s (%d)\n", s, asState->as_number);
asnAddNet(s, asState->as_number);
s = t + 1;
}
asState->seen = asState->offset + size;
asState->offset += (s - buf);
debug(53, 3) ("asState->seen = %ld, asState->offset = %ld\n",
(long int) asState->seen, (long int) asState->offset);
if (e->store_status == STORE_PENDING) {
debug(53, 3) ("asHandleReply: store_status == STORE_PENDING: %s\n", storeUrl(e));
storeClientCopy(asState->sc,
e,
asState->seen,
asState->offset,
4096,
buf,
asHandleReply,
asState);
} else if (asState->seen < e->mem_obj->inmem_hi) {
debug(53, 3) ("asHandleReply: asState->seen < e->mem_obj->inmem_hi %s\n", storeUrl(e));
storeClientCopy(asState->sc,
e,
asState->seen,
asState->offset,
4096,
buf,
asHandleReply,
asState);
} else {
debug(53, 3) ("asHandleReply: Done: %s\n", storeUrl(e));
memFree(buf, MEM_4K_BUF);
asStateFree(asState);
}
}
/* wait for full http headers to be received then parse them */
static void
peerDigestFetchReply(void *data, char *buf, ssize_t size)
{
DigestFetchState *fetch = data;
PeerDigest *pd = fetch->pd;
size_t hdr_size;
assert(pd && buf);
assert(!fetch->offset);
if (peerDigestFetchedEnough(fetch, buf, size, "peerDigestFetchReply"))
return;
if ((hdr_size = headersEnd(buf, size))) {
http_status status;
HttpReply *reply = fetch->entry->mem_obj->reply;
assert(reply);
httpReplyParse(reply, buf, hdr_size);
status = reply->sline.status;
debug(72, 3) ("peerDigestFetchReply: %s status: %d, expires: %d (%+d)\n",
strBuf(pd->host), status,
reply->expires, reply->expires - squid_curtime);
/* this "if" is based on clientHandleIMSReply() */
if (status == HTTP_NOT_MODIFIED) {
request_t *r = NULL;
/* our old entry is fine */
assert(fetch->old_entry);
if (!fetch->old_entry->mem_obj->request)
fetch->old_entry->mem_obj->request = r =
requestLink(fetch->entry->mem_obj->request);
assert(fetch->old_entry->mem_obj->request);
httpReplyUpdateOnNotModified(fetch->old_entry->mem_obj->reply, reply);
storeTimestampsSet(fetch->old_entry);
/* get rid of 304 reply */
storeUnregister(fetch->entry, fetch);
storeUnlockObject(fetch->entry);
fetch->entry = fetch->old_entry;
fetch->old_entry = NULL;
/* preserve request -- we need its size to update counters */
/* requestUnlink(r); */
/* fetch->entry->mem_obj->request = NULL; */
} else if (status == HTTP_OK) {
/* get rid of old entry if any */
if (fetch->old_entry) {
debug(72, 3) ("peerDigestFetchReply: got new digest, releasing old one\n");
storeUnregister(fetch->old_entry, fetch);
storeReleaseRequest(fetch->old_entry);
storeUnlockObject(fetch->old_entry);
fetch->old_entry = NULL;
}
} else {
/* some kind of a bug */
peerDigestFetchAbort(fetch, buf, httpStatusLineReason(&reply->sline));
return;
}
/* must have a ready-to-use store entry if we got here */
/* can we stay with the old in-memory digest? */
if (status == HTTP_NOT_MODIFIED && fetch->pd->cd)
peerDigestFetchStop(fetch, buf, "Not modified");
else
storeClientCopy(fetch->entry, /* have to swap in */
0, 0, SM_PAGE_SIZE, buf, peerDigestSwapInHeaders, fetch);
} else {
/* need more data, do we have space? */
if (size >= SM_PAGE_SIZE)
peerDigestFetchAbort(fetch, buf, "reply header too big");
else
storeClientCopy(fetch->entry, size, 0, SM_PAGE_SIZE, buf,
peerDigestFetchReply, fetch);
}
}
/* 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);
key = storeKeyPublic(url, METHOD_GET);
debug(72, 2) ("peerDigestRequest: %s key: %s\n", url, storeKeyText(key));
req = urlParse(METHOD_GET, url);
assert(req);
/* 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 */
fetch = memAllocate(MEM_DIGEST_FETCH_STATE);
cbdataAdd(fetch, memFree, MEM_DIGEST_FETCH_STATE);
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, url);
storeClientListAdd(old_e, fetch);
}
e = fetch->entry = storeCreateEntry(url, url, req->flags, req->method);
assert(EBIT_TEST(e->flags, KEY_PRIVATE));
storeClientListAdd(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);
cbdataLock(fetch->pd);
storeClientCopy(e, 0, 0, 4096, memAllocate(MEM_4K_BUF),
peerDigestFetchReply, fetch);
}
void
storeUpdate(StoreEntry * entry, request_t * request)
{
StoreUpdateState *state;
request_flags flags = null_request_flags;
const char *vary;
if (!request)
request = entry->mem_obj->request;
if (EBIT_TEST(entry->flags, KEY_PRIVATE))
return; /* Nothing to do here... */
if (!Config.onoff.update_headers)
return; /* Disabled */
CBDATA_INIT_TYPE_FREECB(StoreUpdateState, free_StoreUpdateState);
if (entry->mem_obj)
entry->mem_obj->refresh_timestamp = 0;
state = cbdataAlloc(StoreUpdateState);
state->oldentry = entry;
storeLockObject(state->oldentry);
flags.cachable = 1;
state->newentry = storeCreateEntry(storeUrl(entry), flags, entry->mem_obj->method);
storeRegisterAbort(state->newentry, storeUpdateAbort, state);
state->sc = storeClientRegister(state->oldentry, state);
state->offset = entry->mem_obj->reply->hdr_sz;
storeBuffer(state->newentry);
httpReplySwapOut(httpReplyClone(entry->mem_obj->reply), state->newentry);
state->newentry->timestamp = entry->timestamp;
state->newentry->lastref = entry->lastref;
state->newentry->expires = entry->expires;
state->newentry->lastmod = entry->lastmod;
state->newentry->refcount = entry->refcount;
if (request) {
state->newentry->mem_obj->request = requestLink(request);
vary = httpMakeVaryMark(request, state->newentry->mem_obj->reply);
if (vary) {
state->newentry->mem_obj->vary_headers = xstrdup(vary);
if (strBuf(request->vary_encoding))
state->newentry->mem_obj->vary_encoding = xstrdup(strBuf(request->vary_encoding));
}
} else {
if (entry->mem_obj->vary_headers)
state->newentry->mem_obj->vary_headers = xstrdup(entry->mem_obj->vary_headers);
if (entry->mem_obj->vary_encoding)
state->newentry->mem_obj->vary_encoding = xstrdup(entry->mem_obj->vary_encoding);
}
storeSetPublicKey(state->newentry);
storeBufferFlush(state->newentry);
if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
/*
* the above storeBufferFlush() call could ABORT this entry,
* in that case, there's nothing for us to do.
*/
debug(20, 1) ("storeUpdate: Aborted on write\n");
return;
}
storeClientCopy(state->sc, state->oldentry, state->offset, state->offset, sizeof(state->buf), state->buf, storeUpdateCopy, state);
return;
}
static void
urnHandleReply(void *data, char *buf, ssize_t size)
{
UrnState *urnState = data;
StoreEntry *e = urnState->entry;
StoreEntry *urlres_e = urnState->urlres_e;
char *s = NULL;
size_t k;
HttpReply *rep;
url_entry *urls;
url_entry *u;
url_entry *min_u;
MemBuf mb;
ErrorState *err;
int i;
int urlcnt = 0;
http_version_t version;
debug(52, 3) ("urnHandleReply: Called with size=%d.\n", (int) size);
if (EBIT_TEST(urlres_e->flags, ENTRY_ABORTED)) {
memFree(buf, MEM_4K_BUF);
return;
}
if (size == 0) {
memFree(buf, MEM_4K_BUF);
return;
} else if (size < 0) {
memFree(buf, MEM_4K_BUF);
return;
}
if (urlres_e->store_status == STORE_PENDING && size < SM_PAGE_SIZE) {
storeClientCopy(urnState->sc, urlres_e,
size,
0,
SM_PAGE_SIZE,
buf,
urnHandleReply,
urnState);
return;
}
/* we know its STORE_OK */
k = headersEnd(buf, size);
if (0 == k) {
debug(52, 1) ("urnHandleReply: didn't find end-of-headers for %s\n",
storeUrl(e));
return;
}
s = buf + k;
assert(urlres_e->mem_obj->reply);
httpReplyParse(urlres_e->mem_obj->reply, buf, k);
debug(52, 3) ("mem->reply exists, code=%d.\n",
urlres_e->mem_obj->reply->sline.status);
if (urlres_e->mem_obj->reply->sline.status != HTTP_OK) {
debug(52, 3) ("urnHandleReply: failed.\n");
err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
err->request = requestLink(urnState->request);
err->url = xstrdup(storeUrl(e));
errorAppendEntry(e, err);
return;
}
while (xisspace(*s))
s++;
urls = urnParseReply(s, urnState->request->method);
for (i = 0; NULL != urls[i].url; i++)
urlcnt++;
debug(53, 3) ("urnFindMinRtt: Counted %d URLs\n", i);
if (urls == NULL) { /* unkown URN error */
debug(52, 3) ("urnTranslateDone: unknown URN %s\n", storeUrl(e));
err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
err->request = requestLink(urnState->request);
err->url = xstrdup(storeUrl(e));
errorAppendEntry(e, err);
return;
}
min_u = urnFindMinRtt(urls, urnState->request->method, NULL);
qsort(urls, urlcnt, sizeof(*urls), url_entry_sort);
storeBuffer(e);
memBufDefInit(&mb);
memBufPrintf(&mb,
"<TITLE>Select URL for %s</TITLE>\n"
"<STYLE type=\"text/css\"><!--BODY{background-color:#ffffff;font-family:verdana,sans-serif}--></STYLE>\n"
"<H2>Select URL for %s</H2>\n"
"<TABLE BORDER=\"0\" WIDTH=\"100%%\">\n", storeUrl(e), storeUrl(e));
for (i = 0; i < urlcnt; i++) {
u = &urls[i];
debug(52, 3) ("URL {%s}\n", u->url);
memBufPrintf(&mb,
"<TR><TD><A HREF=\"%s\">%s</A></TD>", u->url, u->url);
if (urls[i].rtt > 0)
memBufPrintf(&mb,
"<TD align=\"right\">%4d <it>ms</it></TD>", u->rtt);
else
memBufPrintf(&mb, "<TD align=\"right\">Unknown</TD>");
memBufPrintf(&mb,
"<TD>%s</TD></TR>\n", u->flags.cached ? " [cached]" : " ");
}
memBufPrintf(&mb,
"</TABLE>"
"<HR noshade size=\"1px\">\n"
"<ADDRESS>\n"
"Generated by %s@%s\n"
"</ADDRESS>\n",
full_appname_string, getMyHostname());
rep = e->mem_obj->reply;
httpReplyReset(rep);
httpBuildVersion(&version, 1, 0);
httpReplySetHeaders(rep, version, HTTP_MOVED_TEMPORARILY, NULL,
"text/html", mb.size, 0, squid_curtime);
if (urnState->flags.force_menu) {
debug(51, 3) ("urnHandleReply: forcing menu\n");
} else if (min_u) {
httpHeaderPutStr(&rep->header, HDR_LOCATION, min_u->url);
}
httpBodySet(&rep->body, &mb);
httpReplySwapOut(rep, e);
storeComplete(e);
memFree(buf, MEM_4K_BUF);
for (i = 0; i < urlcnt; i++) {
safe_free(urls[i].url);
safe_free(urls[i].host);
}
safe_free(urls);
/* mb was absorbed in httpBodySet call, so we must not clean it */
storeUnregister(urnState->sc, urlres_e, urnState);
storeUnlockObject(urlres_e);
storeUnlockObject(urnState->entry);
requestUnlink(urnState->request);
requestUnlink(urnState->urlres_r);
cbdataFree(urnState);
}
static void
netdbExchangeHandleReply(void *data, char *buf, ssize_t size)
{
netdbExchangeState *ex = data;
int rec_sz = 0;
ssize_t o;
struct in_addr addr;
double rtt;
double hops;
char *p;
int j;
HttpReply *rep;
size_t hdr_sz;
int nused = 0;
rec_sz = 0;
rec_sz += 1 + sizeof(addr.s_addr);
rec_sz += 1 + sizeof(int);
rec_sz += 1 + sizeof(int);
ex->seen = ex->used + size;
debug(38, 3) ("netdbExchangeHandleReply: %d bytes\n", (int) size);
if (!cbdataValid(ex->p)) {
debug(38, 3) ("netdbExchangeHandleReply: Peer became invalid\n");
netdbExchangeDone(ex);
return;
}
debug(38, 3) ("netdbExchangeHandleReply: for '%s:%d'\n", ex->p->host, ex->p->http_port);
p = buf;
if (0 == ex->used) {
/* skip reply headers */
if ((hdr_sz = headersEnd(p, size))) {
debug(38, 5) ("netdbExchangeHandleReply: hdr_sz = %ld\n", (long int) hdr_sz);
rep = ex->e->mem_obj->reply;
if (0 == rep->sline.status)
httpReplyParse(rep, buf, hdr_sz);
debug(38, 3) ("netdbExchangeHandleReply: reply status %d\n",
rep->sline.status);
if (HTTP_OK != rep->sline.status) {
netdbExchangeDone(ex);
return;
}
assert(size >= hdr_sz);
ex->used += hdr_sz;
size -= hdr_sz;
p += hdr_sz;
} else {
if (size >= ex->buf_sz) {
debug(38, 3) ("netdbExchangeHandleReply: Too big HTTP header, aborting\n");
netdbExchangeDone(ex);
return;
} else {
size = 0;
}
}
}
debug(38, 5) ("netdbExchangeHandleReply: start parsing loop, size = %ld\n",
(long int) size);
while (size >= rec_sz) {
debug(38, 5) ("netdbExchangeHandleReply: in parsing loop, size = %ld\n",
(long int) size);
addr.s_addr = any_addr.s_addr;
hops = rtt = 0.0;
for (o = 0; o < rec_sz;) {
switch ((int) *(p + o)) {
case NETDB_EX_NETWORK:
o++;
xmemcpy(&addr.s_addr, p + o, sizeof(addr.s_addr));
o += sizeof(addr.s_addr);
break;
case NETDB_EX_RTT:
o++;
xmemcpy(&j, p + o, sizeof(int));
o += sizeof(int);
rtt = (double) ntohl(j) / 1000.0;
break;
case NETDB_EX_HOPS:
o++;
xmemcpy(&j, p + o, sizeof(int));
o += sizeof(int);
hops = (double) ntohl(j) / 1000.0;
break;
default:
debug(38, 1) ("netdbExchangeHandleReply: corrupt data, aborting\n");
netdbExchangeDone(ex);
return;
}
}
if (addr.s_addr != any_addr.s_addr && rtt > 0)
netdbExchangeUpdatePeer(addr, ex->p, rtt, hops);
assert(o == rec_sz);
ex->used += rec_sz;
size -= rec_sz;
p += rec_sz;
/*
* This is a fairly cpu-intensive loop, break after adding
* just a few
*/
if (++nused == 20)
break;
}
debug(38, 3) ("netdbExchangeHandleReply: used %d entries, (x %d bytes) == %d bytes total\n",
nused, rec_sz, nused * rec_sz);
debug(38, 3) ("netdbExchangeHandleReply: seen %ld, used %ld\n", (long int) ex->seen, (long int) ex->used);
if (EBIT_TEST(ex->e->flags, ENTRY_ABORTED)) {
debug(38, 3) ("netdbExchangeHandleReply: ENTRY_ABORTED\n");
netdbExchangeDone(ex);
} else if (ex->e->store_status == STORE_PENDING) {
debug(38, 3) ("netdbExchangeHandleReply: STORE_PENDING\n");
storeClientCopy(ex->sc, ex->e, ex->seen, ex->used, ex->buf_sz,
ex->buf, netdbExchangeHandleReply, ex);
} else if (ex->seen < ex->e->mem_obj->inmem_hi) {
debug(38, 3) ("netdbExchangeHandleReply: ex->e->mem_obj->inmem_hi\n");
storeClientCopy(ex->sc, ex->e, ex->seen, ex->used, ex->buf_sz,
ex->buf, netdbExchangeHandleReply, ex);
} else {
debug(38, 3) ("netdbExchangeHandleReply: Done\n");
netdbExchangeDone(ex);
}
}
