[thirdparty/squid.git] / src / urn.cc


/*
 *
 * $Id: urn.cc,v 1.35 1998/06/04 18:57:19 wessels Exp $
 *
 * DEBUG: section 52    URN Parsing
 * AUTHOR: Kostas Anagnostakis
 *
 * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
 * --------------------------------------------------------
 *
 *  Squid is the result of efforts by numerous individuals from the
 *  Internet community.  Development is led by Duane Wessels of the
 *  National Laboratory for Applied Network Research and funded by
 *  the National Science Foundation.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *  
 */

#include "squid.h"

enum {
    URN_FORCE_MENU
};

typedef struct {
    StoreEntry *entry;
    StoreEntry *urlres_e;
    request_t *request;
    request_t *urlres_r;
    int flags;
} UrnState;

typedef struct {
    char *url;
    char *host;
    int rtt;
    struct {
	int cached;
    } flags;
} url_entry;

static STCB urnHandleReply;
static url_entry *urnParseReply(const char *inbuf, method_t);
static const char *const crlf = "\r\n";
static QS url_entry_sort;

url_entry *
urnFindMinRtt(url_entry * urls, method_t m, int *rtt_ret)
{
    int min_rtt = 0;
    url_entry *u = NULL;
    url_entry *min_u = NULL;
    int i;
    int urlcnt = 0;
    debug(52, 3) ("urnFindMinRtt\n");
    assert(urls != NULL);
    for (i = 0; NULL != urls[i].url; i++)
	urlcnt++;
    debug(0, 0) ("urnFindMinRtt: Counted %d URLs\n", i);
    if (1 == urlcnt) {
	debug(52, 3) ("urnFindMinRtt: Only one URL - return it!\n");
	return urls;
    }
    for (i = 0; i < urlcnt; i++) {
	u = &urls[i];
	debug(52, 3) ("urnFindMinRtt: %s rtt=%d\n", u->host, u->rtt);
	if (u->rtt == 0)
	    continue;
	if (u->rtt > min_rtt && min_rtt != 0)
	    continue;
	min_rtt = u->rtt;
	min_u = u;
    }
    if (rtt_ret)
	*rtt_ret = min_rtt;
    debug(52, 1) ("urnFindMinRtt: Returning '%s' RTT %d\n",
	min_u ? min_u->url : "NONE",
	min_rtt);
    return min_u;
}

void
urnStart(request_t * r, StoreEntry * e)
{
    LOCAL_ARRAY(char, urlres, 4096);
    request_t *urlres_r = NULL;
    const cache_key *k;
    const char *t;
    char *host;
    UrnState *urnState;
    StoreEntry *urlres_e;
    ErrorState *err;
    debug(52, 3) ("urnStart: '%s'\n", storeUrl(e));
    urnState = xcalloc(1, sizeof(UrnState));
    urnState->entry = e;
    urnState->request = requestLink(r);
    cbdataAdd(urnState, MEM_NONE);
    storeLockObject(urnState->entry);
    if (strncasecmp(strBuf(r->urlpath), "menu.", 5) == 0) {
	char *new_path = xstrdup(strBuf(r->urlpath) + 5);
	EBIT_SET(urnState->flags, URN_FORCE_MENU);
	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);
    k = storeKeyPublic(urlres, METHOD_GET);
    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;
    }
#if OLD_CODE
    urlres_r->headers = xstrdup("Accept: text/plain\r\n\r\n");
    urlres_r->headers_sz = strlen(urlres_r->headers);
#else
    httpHeaderPutStr(&urlres_r->header, HDR_ACCEPT, "text/plain");
#endif
    if ((urlres_e = storeGet(k)) == NULL) {
	urlres_e = storeCreateEntry(urlres, urlres, 0, METHOD_GET);
	storeClientListAdd(urlres_e, urnState);
	fwdStart(-1, urlres_e, urlres_r);
    } else {
	storeLockObject(urlres_e);
	storeClientListAdd(urlres_e, urnState);
    }
    urnState->urlres_e = urlres_e;
    urnState->urlres_r = requestLink(urlres_r);
    storeClientCopy(urlres_e,
	0,
	0,
	4096,
	memAllocate(MEM_4K_BUF),
	urnHandleReply,
	urnState);
}

static int
url_entry_sort(const void *A, const void *B)
{
    const url_entry *u1 = A;
    const url_entry *u2 = B;
    if (u2->rtt == u1->rtt)
	return 0;
    else if (0 == u1->rtt)
	return 1;
    else if (0 == u2->rtt)
	return -1;
    else
	return u1->rtt - u2->rtt;
}

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;

    debug(52, 3) ("urnHandleReply: Called with size=%d.\n", size);
    if (urlres_e->store_status == STORE_ABORTED) {
	memFree(MEM_4K_BUF, buf);
	return;
    }
    if (size == 0) {
	memFree(MEM_4K_BUF, buf);
	return;
    } else if (size < 0) {
	memFree(MEM_4K_BUF, buf);
	return;
    }
    if (urlres_e->store_status == STORE_PENDING && size < SM_PAGE_SIZE) {
	storeClientCopy(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);
    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 (isspace(*s))
	s++;
    urls = urnParseReply(s, urnState->request->method);
    for (i = 0; NULL != urls[i].url; i++)
	urlcnt++;
    debug(0, 0) ("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"
	"<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(0, 0) ("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>\n"
	"<ADDRESS>\n"
	"Generated by %s@%s\n"
	"</ADDRESS>\n",
	full_appname_string, getMyHostname());
    rep = e->mem_obj->reply;
    httpReplyReset(rep);
    httpReplySetHeaders(rep, 1.0, HTTP_MOVED_TEMPORARILY, NULL,
	"text/html", mb.size, 0, squid_curtime);
    if (EBIT_TEST(urnState->flags, URN_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.buf, mb.size + 1, memBufFreeFunc(&mb));
    httpReplySwapOut(rep, e);
    storeComplete(e);
    memFree(MEM_4K_BUF, buf);
    for (i = 0; i < urlcnt; i++) {
	safe_free(urls[i].url);
	safe_free(urls[i].host);
    }
    safe_free(urls);
    /* mb was frozen with memBufFreeFunc call, so we must not clean it */
    storeUnregister(urlres_e, urnState);
    storeUnlockObject(urlres_e);
    storeUnlockObject(urnState->entry);
    requestUnlink(urnState->request);
    requestUnlink(urnState->urlres_r);
    cbdataFree(urnState);
}

static url_entry *
urnParseReply(const char *inbuf, method_t m)
{
    char *buf = xstrdup(inbuf);
    char *token;
    char *url;
    char *host;
    const cache_key *key;
    int rtt;
    url_entry *list;
    url_entry *old;
    int n = 32;
    int i = 0;
    debug(52, 3) ("urnParseReply\n");
    list = xcalloc(n + 1, sizeof(*list));
    for (token = strtok(buf, crlf); token; token = strtok(NULL, crlf)) {
	debug(52, 3) ("urnParseReply: got '%s'\n", token);
	if (i == n) {
	    old = list;
	    n <<= 2;
	    list = xcalloc(n + 1, sizeof(*list));
	    xmemcpy(list, old, i * sizeof(*list));
	    safe_free(old);
	}
	url = xstrdup(token);
	host = urlHostname(url);
	if (NULL == host)
	    continue;
	rtt = netdbHostRtt(host);
	if (0 == rtt) {
	    debug(52, 3) ("urnParseReply: Pinging %s\n", host);
	    netdbPingSite(host);
	}
	key = storeKeyPublic(url, m);
	list[i].url = url;
	list[i].host = xstrdup(host);
	list[i].rtt = rtt;
	list[i].flags.cached = storeGet(key) ? 1 : 0;
	i++;
    }
    debug(0, 0) ("urnParseReply: Found %d URLs\n", i);
    return list;
}
Commit	Line	Data
85491f8d	1
85491f8d	2	/*
ebe14c5d	3	*
41462d93	4	* $Id: urn.cc,v 1.35 1998/06/04 18:57:19 wessels Exp $
ebe14c5d	5	*
6f6f0853	6	* DEBUG: section 52 URN Parsing
85491f8d	7	* AUTHOR: Kostas Anagnostakis
	8	*
	9	* SQUID Internet Object Cache http://squid.nlanr.net/Squid/
	10	* --------------------------------------------------------
	11	*
	12	* Squid is the result of efforts by numerous individuals from the
	13	* Internet community. Development is led by Duane Wessels of the
	14	* National Laboratory for Applied Network Research and funded by
	15	* the National Science Foundation.
	16	*
	17	* This program is free software; you can redistribute it and/or modify
	18	* it under the terms of the GNU General Public License as published by
	19	* the Free Software Foundation; either version 2 of the License, or
	20	* (at your option) any later version.
	21	*
	22	* This program is distributed in the hope that it will be useful,
	23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	25	* GNU General Public License for more details.
	26	*
	27	* You should have received a copy of the GNU General Public License
	28	* along with this program; if not, write to the Free Software
	29	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	30	*
	31	*/
	32
	33	#include "squid.h"
	34
fa040df2	35	enum {
164f7660	36	URN_FORCE_MENU
fa040df2	37	};
fa040df2	38
cf26e54c	39	typedef struct {
164f7660	40	StoreEntry *entry;
	41	StoreEntry *urlres_e;
	42	request_t *request;
40548fef	43	request_t *urlres_r;
164f7660	44	int flags;
cf26e54c	45	} UrnState;
85491f8d	46
9ce5e3e6	47	typedef struct {
	48	char *url;
	49	char *host;
	50	int rtt;
	51	struct {
	52	int cached;
	53	} flags;
	54	} url_entry;
	55
	56	static STCB urnHandleReply;
	57	static url_entry urnParseReply(const char inbuf, method_t);
	58	static const char *const crlf = "\r\n";
	59	static QS url_entry_sort;
	60
	61	url_entry *
	62	urnFindMinRtt(url_entry * urls, method_t m, int *rtt_ret)
85491f8d	63	{
23d92c64	64	int min_rtt = 0;
9ce5e3e6	65	url_entry *u = NULL;
	66	url_entry *min_u = NULL;
	67	int i;
1caf595b	68	int urlcnt = 0;
6f6f0853	69	debug(52, 3) ("urnFindMinRtt\n");
23d92c64	70	assert(urls != NULL);
00141c96	71	for (i = 0; NULL != urls[i].url; i++)
1caf595b	72	urlcnt++;
00141c96	73	debug(0, 0) ("urnFindMinRtt: Counted %d URLs\n", i);
9ce5e3e6	74	if (1 == urlcnt) {
	75	debug(52, 3) ("urnFindMinRtt: Only one URL - return it!\n");
	76	return urls;
1caf595b	77	}
00141c96	78	for (i = 0; i < urlcnt; i++) {
00141c96	79	u = &urls[i];
9ce5e3e6	80	debug(52, 3) ("urnFindMinRtt: %s rtt=%d\n", u->host, u->rtt);
9ce5e3e6	81	if (u->rtt == 0)
23d92c64	82	continue;
9ce5e3e6	83	if (u->rtt > min_rtt && min_rtt != 0)
164f7660	84	continue;
9ce5e3e6	85	min_rtt = u->rtt;
9ce5e3e6	86	min_u = u;
23d92c64	87	}
	88	if (rtt_ret)
	89	*rtt_ret = min_rtt;
6f6f0853	90	debug(52, 1) ("urnFindMinRtt: Returning '%s' RTT %d\n",
9ce5e3e6	91	min_u ? min_u->url : "NONE",
23d92c64	92	min_rtt);
9ce5e3e6	93	return min_u;
85491f8d	94	}
	95
	96	void
164f7660	97	urnStart(request_t * r, StoreEntry * e)
85491f8d	98	{
23d92c64	99	LOCAL_ARRAY(char, urlres, 4096);
23d92c64	100	request_t *urlres_r = NULL;
23d92c64	101	const cache_key *k;
02922e76	102	const char *t;
c6528ea4	103	char *host;
cf26e54c	104	UrnState *urnState;
cf26e54c	105	StoreEntry *urlres_e;
0adbab7c	106	ErrorState *err;
6f6f0853	107	debug(52, 3) ("urnStart: '%s'\n", storeUrl(e));
cf26e54c	108	urnState = xcalloc(1, sizeof(UrnState));
	109	urnState->entry = e;
	110	urnState->request = requestLink(r);
3f6c0fb2	111	cbdataAdd(urnState, MEM_NONE);
8d709a1b	112	storeLockObject(urnState->entry);
02922e76	113	if (strncasecmp(strBuf(r->urlpath), "menu.", 5) == 0) {
02922e76	114	char *new_path = xstrdup(strBuf(r->urlpath) + 5);
de28f103	115	EBIT_SET(urnState->flags, URN_FORCE_MENU);
02922e76	116	stringReset(&r->urlpath, new_path);
02922e76	117	xfree(new_path);
de28f103	118	}
02922e76	119	if ((t = strChr(r->urlpath, ':')) != NULL) {
	120	strSet(r->urlpath, t, '\0');
	121	host = xstrdup(strBuf(r->urlpath));
	122	strSet(r->urlpath, t, ':');
fa040df2	123	} else {
02922e76	124	host = xstrdup(strBuf(r->urlpath));
fa040df2	125	}
02922e76	126	snprintf(urlres, 4096, "http://%s/uri-res/N2L?urn:%s", host, strBuf(r->urlpath));
c6528ea4	127	safe_free(host);
23d92c64	128	k = storeKeyPublic(urlres, METHOD_GET);
23d92c64	129	urlres_r = urlParse(METHOD_GET, urlres);
0adbab7c	130	if (urlres_r == NULL) {
	131	debug(52, 3) ("urnStart: Bad uri-res URL %s\n", urlres);
	132	err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
	133	err->url = xstrdup(urlres);
	134	errorAppendEntry(e, err);
	135	return;
	136	}
99edd1c3	137	#if OLD_CODE
8d709a1b	138	urlres_r->headers = xstrdup("Accept: text/plain\r\n\r\n");
23d92c64	139	urlres_r->headers_sz = strlen(urlres_r->headers);
99edd1c3	140	#else
2246b732	141	httpHeaderPutStr(&urlres_r->header, HDR_ACCEPT, "text/plain");
99edd1c3	142	#endif
cf26e54c	143	if ((urlres_e = storeGet(k)) == NULL) {
	144	urlres_e = storeCreateEntry(urlres, urlres, 0, METHOD_GET);
	145	storeClientListAdd(urlres_e, urnState);
41462d93	146	fwdStart(-1, urlres_e, urlres_r);
cf26e54c	147	} else {
164f7660	148	storeLockObject(urlres_e);
164f7660	149	storeClientListAdd(urlres_e, urnState);
85491f8d	150	}
cf26e54c	151	urnState->urlres_e = urlres_e;
40548fef	152	urnState->urlres_r = requestLink(urlres_r);
cf26e54c	153	storeClientCopy(urlres_e,
	154	0,
	155	0,
	156	4096,
7021844c	157	memAllocate(MEM_4K_BUF),
cf26e54c	158	urnHandleReply,
cf26e54c	159	urnState);
85491f8d	160	}
85491f8d	161
9ce5e3e6	162	static int
	163	url_entry_sort(const void A, const void B)
	164	{
	165	const url_entry *u1 = A;
	166	const url_entry *u2 = B;
	167	if (u2->rtt == u1->rtt)
	168	return 0;
	169	else if (0 == u1->rtt)
	170	return 1;
	171	else if (0 == u2->rtt)
00141c96	172	return -1;
9ce5e3e6	173	else
00141c96	174	return u1->rtt - u2->rtt;
9ce5e3e6	175	}
9ce5e3e6	176
85491f8d	177	static void
23d92c64	178	urnHandleReply(void data, char buf, ssize_t size)
85491f8d	179	{
cf26e54c	180	UrnState *urnState = data;
	181	StoreEntry *e = urnState->entry;
	182	StoreEntry *urlres_e = urnState->urlres_e;
23d92c64	183	char *s = NULL;
2334c194	184	size_t k;
cb69b4c7	185	HttpReply *rep;
9ce5e3e6	186	url_entry *urls;
00141c96	187	url_entry *u;
9ce5e3e6	188	url_entry *min_u;
02922e76	189	MemBuf mb;
cf26e54c	190	ErrorState *err;
9ce5e3e6	191	int i;
9ce5e3e6	192	int urlcnt = 0;
cf26e54c	193
6f6f0853	194	debug(52, 3) ("urnHandleReply: Called with size=%d.\n", size);
cf26e54c	195	if (urlres_e->store_status == STORE_ABORTED) {
3f6c0fb2	196	memFree(MEM_4K_BUF, buf);
23d92c64	197	return;
85491f8d	198	}
23d92c64	199	if (size == 0) {
3f6c0fb2	200	memFree(MEM_4K_BUF, buf);
23d92c64	201	return;
23d92c64	202	} else if (size < 0) {
3f6c0fb2	203	memFree(MEM_4K_BUF, buf);
23d92c64	204	return;
85491f8d	205	}
4b534024	206	if (urlres_e->store_status == STORE_PENDING && size < SM_PAGE_SIZE) {
cf26e54c	207	storeClientCopy(urlres_e,
cf26e54c	208	size,
23d92c64	209	0,
	210	SM_PAGE_SIZE,
	211	buf,
	212	urnHandleReply,
cf26e54c	213	urnState);
85491f8d	214	return;
23d92c64	215	}
23d92c64	216	/* we know its STORE_OK */
2334c194	217	k = headersEnd(buf, size);
2334c194	218	if (0 == k) {
6f6f0853	219	debug(52, 1) ("urnHandleReply: didn't find end-of-headers for %s\n",
cf26e54c	220	storeUrl(e));
85491f8d	221	return;
85491f8d	222	}
2334c194	223	s = buf + k;
cf26e54c	224	assert(urlres_e->mem_obj->reply);
cb69b4c7	225	httpReplyParse(urlres_e->mem_obj->reply, buf);
6f6f0853	226	debug(52, 3) ("mem->reply exists, code=%d.\n",
cb69b4c7	227	urlres_e->mem_obj->reply->sline.status);
cb69b4c7	228	if (urlres_e->mem_obj->reply->sline.status != HTTP_OK) {
6f6f0853	229	debug(52, 3) ("urnHandleReply: failed.\n");
cf26e54c	230	err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
	231	err->request = requestLink(urnState->request);
	232	err->url = xstrdup(storeUrl(e));
	233	errorAppendEntry(e, err);
23d92c64	234	return;
85491f8d	235	}
23d92c64	236	while (isspace(*s))
23d92c64	237	s++;
9ce5e3e6	238	urls = urnParseReply(s, urnState->request->method);
00141c96	239	for (i = 0; NULL != urls[i].url; i++)
9ce5e3e6	240	urlcnt++;
00141c96	241	debug(0, 0) ("urnFindMinRtt: Counted %d URLs\n", i);
164f7660	242	if (urls == NULL) { /* unkown URN error */
6f6f0853	243	debug(52, 3) ("urnTranslateDone: unknown URN %s\n", storeUrl(e));
cf26e54c	244	err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
	245	err->request = requestLink(urnState->request);
	246	err->url = xstrdup(storeUrl(e));
	247	errorAppendEntry(e, err);
	248	return;
164f7660	249	}
9ce5e3e6	250	min_u = urnFindMinRtt(urls, urnState->request->method, NULL);
9ce5e3e6	251	qsort(urls, urlcnt, sizeof(*urls), url_entry_sort);
cf26e54c	252	storeBuffer(e);
02922e76	253	memBufDefInit(&mb);
02922e76	254	memBufPrintf(&mb,
cf26e54c	255	"<TITLE>Select URL for %s</TITLE>\n"
cf26e54c	256	"<H2>Select URL for %s</H2>\n"
2e141322	257	"<TABLE BORDER=0 WIDTH=\"100%%\">\n", storeUrl(e), storeUrl(e));
9ce5e3e6	258	for (i = 0; i < urlcnt; i++) {
00141c96	259	u = &urls[i];
00141c96	260	debug(0, 0) ("URL {%s}\n", u->url);
9ce5e3e6	261	memBufPrintf(&mb,
00141c96	262	"<TR><TD><A HREF=\"%s\">%s</A></TD>", u->url, u->url);
00141c96	263	if (urls[i].rtt > 0)
9ce5e3e6	264	memBufPrintf(&mb,
00141c96	265	"<TD align=right>%4d </it>ms</it></TD>", u->rtt);
164f7660	266	else
9ce5e3e6	267	memBufPrintf(&mb, "<TD align=right>Unknown</TD>");
9ce5e3e6	268	memBufPrintf(&mb,
00141c96	269	"<TD>%s</TD></TR>\n", u->flags.cached ? " [cached]" : " ");
cf26e54c	270	}
02922e76	271	memBufPrintf(&mb,
2e141322	272	"</TABLE>"
cf26e54c	273	"<HR>\n"
cf26e54c	274	"<ADDRESS>\n"
02922e76	275	"Generated by %s@%s\n"
cf26e54c	276	"</ADDRESS>\n",
02922e76	277	full_appname_string, getMyHostname());
cb69b4c7	278	rep = e->mem_obj->reply;
	279	httpReplyReset(rep);
	280	httpReplySetHeaders(rep, 1.0, HTTP_MOVED_TEMPORARILY, NULL,
02922e76	281	"text/html", mb.size, 0, squid_curtime);
cb69b4c7	282	if (EBIT_TEST(urnState->flags, URN_FORCE_MENU)) {
cb69b4c7	283	debug(51, 3) ("urnHandleReply: forcing menu\n");
9ce5e3e6	284	} else if (min_u) {
9ce5e3e6	285	httpHeaderPutStr(&rep->header, HDR_LOCATION, min_u->url);
cb69b4c7	286	}
1afe05c5	287	httpBodySet(&rep->body, mb.buf, mb.size + 1, memBufFreeFunc(&mb));
cb69b4c7	288	httpReplySwapOut(rep, e);
cf26e54c	289	storeComplete(e);
3f6c0fb2	290	memFree(MEM_4K_BUF, buf);
9ce5e3e6	291	for (i = 0; i < urlcnt; i++) {
00141c96	292	safe_free(urls[i].url);
00141c96	293	safe_free(urls[i].host);
9ce5e3e6	294	}
9ce5e3e6	295	safe_free(urls);
02922e76	296	/* mb was frozen with memBufFreeFunc call, so we must not clean it */
8d709a1b	297	storeUnregister(urlres_e, urnState);
cf26e54c	298	storeUnlockObject(urlres_e);
8d709a1b	299	storeUnlockObject(urnState->entry);
8d709a1b	300	requestUnlink(urnState->request);
40548fef	301	requestUnlink(urnState->urlres_r);
8d709a1b	302	cbdataFree(urnState);
85491f8d	303	}
85491f8d	304
9ce5e3e6	305	static url_entry *
9ce5e3e6	306	urnParseReply(const char *inbuf, method_t m)
85491f8d	307	{
23d92c64	308	char *buf = xstrdup(inbuf);
23d92c64	309	char *token;
9ce5e3e6	310	char *url;
	311	char *host;
	312	const cache_key *key;
	313	int rtt;
	314	url_entry *list;
	315	url_entry *old;
	316	int n = 32;
	317	int i = 0;
6f6f0853	318	debug(52, 3) ("urnParseReply\n");
9ce5e3e6	319	list = xcalloc(n + 1, sizeof(*list));
23d92c64	320	for (token = strtok(buf, crlf); token; token = strtok(NULL, crlf)) {
6f6f0853	321	debug(52, 3) ("urnParseReply: got '%s'\n", token);
9ce5e3e6	322	if (i == n) {
	323	old = list;
	324	n <<= 2;
	325	list = xcalloc(n + 1, sizeof(*list));
	326	xmemcpy(list, old, i * sizeof(*list));
	327	safe_free(old);
	328	}
	329	url = xstrdup(token);
	330	host = urlHostname(url);
	331	if (NULL == host)
	332	continue;
	333	rtt = netdbHostRtt(host);
	334	if (0 == rtt) {
	335	debug(52, 3) ("urnParseReply: Pinging %s\n", host);
	336	netdbPingSite(host);
	337	}
	338	key = storeKeyPublic(url, m);
00141c96	339	list[i].url = url;
	340	list[i].host = xstrdup(host);
	341	list[i].rtt = rtt;
	342	list[i].flags.cached = storeGet(key) ? 1 : 0;
9ce5e3e6	343	i++;
85491f8d	344	}
00141c96	345	debug(0, 0) ("urnParseReply: Found %d URLs\n", i);
9ce5e3e6	346	return list;
85491f8d	347	}