/*
- * Copyright (C) 1996-2015 The Squid Software Foundation and contributors
+ * Copyright (C) 1996-2021 The Squid Software Foundation and contributors
*
* Squid software is distributed under GPLv2+ license and includes
* contributions from numerous individuals and organizations.
/* DEBUG: section 52 URN Parsing */
#include "squid.h"
+#include "AccessLogEntry.h"
+#include "acl/FilledChecklist.h"
+#include "base/TextException.h"
#include "cbdata.h"
#include "errorpage.h"
#include "FwdState.h"
#include "Store.h"
#include "StoreClient.h"
#include "tools.h"
-#include "URL.h"
#include "urn.h"
#define URN_REQBUF_SZ 4096
CBDATA_CLASS(UrnState);
public:
- void created (StoreEntry *newEntry);
+ explicit UrnState(const AccessLogEntry::Pointer &anAle): ale(anAle) {}
+
void start (HttpRequest *, StoreEntry *);
- char *getHost(const SBuf &urlpath);
void setUriResFromRequest(HttpRequest *);
virtual ~UrnState();
- StoreEntry *entry;
- store_client *sc;
- StoreEntry *urlres_e;
+ StoreEntry *entry = nullptr;
+ store_client *sc = nullptr;
+ StoreEntry *urlres_e = nullptr;
HttpRequest::Pointer request;
HttpRequest::Pointer urlres_r;
+ AccessLogEntry::Pointer ale; ///< details of the requesting transaction
- struct {
- bool force_menu;
- } flags;
- char reqbuf[URN_REQBUF_SZ];
- int reqofs;
+ char reqbuf[URN_REQBUF_SZ] = { '\0' };
+ int reqofs = 0;
private:
- char *urlres;
+ /* StoreClient API */
+ virtual LogTags *loggingTags() const { return ale ? &ale->cache.code : nullptr; }
+ virtual void fillChecklist(ACLFilledChecklist &) const;
+
+ char *urlres = nullptr;
};
typedef struct {
static STCB urnHandleReply;
static url_entry *urnParseReply(const char *inbuf, const HttpRequestMethod&);
static const char *const crlf = "\r\n";
-static QS url_entry_sort;
CBDATA_CLASS_INIT(UrnState);
UrnState::~UrnState()
{
- safe_free(urlres);
+ SWALLOW_EXCEPTIONS({
+ if (urlres_e) {
+ if (sc)
+ storeUnregister(sc, urlres_e, this);
+ urlres_e->unlock("~UrnState+res");
+ }
+
+ if (entry)
+ entry->unlock("~UrnState+prime");
+
+ safe_free(urlres);
+ });
}
static url_entry *
return min_u;
}
-char *
-UrnState::getHost(const SBuf &urlpath)
-{
- /** FIXME: this appears to be parsing the URL. *very* badly. */
- /* a proper encapsulated URI/URL type needs to clear this up. */
- size_t p;
- if ((p = urlpath.find(':')) != SBuf::npos)
- return SBufToCstring(urlpath.substr(0, p-1));
-
- return SBufToCstring(urlpath);
-}
-
void
UrnState::setUriResFromRequest(HttpRequest *r)
{
- static const SBuf menu(".menu");
- if (r->url.path().startsWith(menu)) {
- r->url.path(r->url.path().substr(5)); // strip prefix "menu."
- flags.force_menu = true;
- }
-
- SBuf uri = r->url.path();
+ const auto &query = r->url.absolute();
+ const auto host = r->url.host();
+ // TODO: use class AnyP::Uri instead of generating a string and re-parsing
LOCAL_ARRAY(char, local_urlres, 4096);
- char *host = getHost(uri);
- snprintf(local_urlres, 4096, "http://%s/uri-res/N2L?urn:" SQUIDSBUFPH, host, SQUIDSBUFPRINT(uri));
- safe_free(host);
+ snprintf(local_urlres, 4096, "http://%s/uri-res/N2L?" SQUIDSBUFPH, host, SQUIDSBUFPRINT(query));
safe_free(urlres);
- urlres = xstrdup(local_urlres);
- urlres_r = HttpRequest::CreateFromUrl(urlres);
+ urlres_r = HttpRequest::FromUrlXXX(local_urlres, r->masterXaction);
- if (urlres_r == NULL) {
- debugs(52, 3, "urnStart: Bad uri-res URL " << urlres);
- ErrorState *err = new ErrorState(ERR_URN_RESOLVE, Http::scNotFound, r);
- err->url = urlres;
- urlres = NULL;
+ if (!urlres_r) {
+ debugs(52, 3, "Bad uri-res URL " << local_urlres);
+ const auto err = new ErrorState(ERR_URN_RESOLVE, Http::scNotFound, r, ale);
+ err->url = xstrdup(local_urlres);
errorAppendEntry(entry, err);
return;
}
- urlres_r->header.putStr(HDR_ACCEPT, "text/plain");
+ urlres = xstrdup(local_urlres);
+ urlres_r->header.putStr(Http::HdrType::ACCEPT, "text/plain");
}
void
if (urlres_r == NULL)
return;
- StoreEntry::getPublic (this, urlres, Http::METHOD_GET);
-}
+ auto urlEntry = storeGetPublic(urlres, Http::METHOD_GET);
-void
-UrnState::created(StoreEntry *newEntry)
-{
- urlres_e = newEntry;
-
- if (urlres_e->isNull()) {
+ if (!urlEntry || (urlEntry->hittingRequiresCollapsing() && !startCollapsingOn(*urlEntry, false))) {
urlres_e = storeCreateEntry(urlres, urlres, RequestFlags(), Http::METHOD_GET);
sc = storeClientListAdd(urlres_e, this);
- FwdState::fwdStart(Comm::ConnectionPointer(), urlres_e, urlres_r.getRaw());
+ FwdState::Start(Comm::ConnectionPointer(), urlres_e, urlres_r.getRaw(), ale);
+ if (urlEntry) {
+ urlEntry->abandon(__FUNCTION__);
+ urlEntry = nullptr;
+ }
} else {
- urlres_e->lock("UrnState::created");
+ urlres_e = urlEntry;
+ urlres_e->lock("UrnState::start");
sc = storeClientListAdd(urlres_e, this);
}
}
void
-urnStart(HttpRequest * r, StoreEntry * e)
+UrnState::fillChecklist(ACLFilledChecklist &checklist) const
+{
+ checklist.setRequest(request.getRaw());
+ checklist.al = ale;
+}
+
+void
+urnStart(HttpRequest *r, StoreEntry *e, const AccessLogEntryPointer &ale)
{
- UrnState *anUrn = new UrnState();
+ const auto anUrn = new UrnState(ale);
anUrn->start (r, e);
}
return u1->rtt - u2->rtt;
}
-static void
-urnHandleReplyError(UrnState *urnState, StoreEntry *urlres_e)
-{
- urlres_e->unlock("urnHandleReplyError+res");
- urnState->entry->unlock("urnHandleReplyError+prime");
- delete urnState;
-}
-
/* TODO: use the clientStream support for this */
static void
urnHandleReply(void *data, StoreIOBuffer result)
url_entry *urls;
url_entry *u;
url_entry *min_u;
- MemBuf *mb = NULL;
ErrorState *err;
int i;
int urlcnt = 0;
debugs(52, 3, "urnHandleReply: Called with size=" << result.length << ".");
- if (EBIT_TEST(urlres_e->flags, ENTRY_ABORTED) || result.length == 0 || result.flags.error) {
- urnHandleReplyError(urnState, urlres_e);
+ if (EBIT_TEST(urlres_e->flags, ENTRY_ABORTED) || result.flags.error) {
+ delete urnState;
+ return;
+ }
+
+ if (!e->isAccepting()) {
+ debugs(52, 3, "terminating due to bad " << *e);
+ delete urnState;
return;
}
/* Handle reqofs being bigger than normal */
if (urnState->reqofs >= URN_REQBUF_SZ) {
- urnHandleReplyError(urnState, urlres_e);
+ delete urnState;
return;
}
/* If we haven't received the entire object (urn), copy more */
- if (urlres_e->store_status == STORE_PENDING &&
- urnState->reqofs < URN_REQBUF_SZ) {
+ if (urlres_e->store_status == STORE_PENDING) {
+ Must(result.length > 0); // zero length ought to imply STORE_OK
tempBuffer.offset = urnState->reqofs;
- tempBuffer.length = URN_REQBUF_SZ;
+ tempBuffer.length = URN_REQBUF_SZ - urnState->reqofs;
tempBuffer.data = urnState->reqbuf + urnState->reqofs;
storeClientCopy(urnState->sc, urlres_e,
tempBuffer,
if (0 == k) {
debugs(52, DBG_IMPORTANT, "urnHandleReply: didn't find end-of-headers for " << e->url() );
- urnHandleReplyError(urnState, urlres_e);
+ delete urnState;
return;
}
s = buf + k;
- assert(urlres_e->getReply());
+ // TODO: Check whether we should parse urlres_e reply, as before 528b2c61.
rep = new HttpReply;
rep->parseCharBuf(buf, k);
debugs(52, 3, "reply exists, code=" << rep->sline.status() << ".");
if (rep->sline.status() != Http::scOkay) {
debugs(52, 3, "urnHandleReply: failed.");
- err = new ErrorState(ERR_URN_RESOLVE, Http::scNotFound, urnState->request.getRaw());
+ err = new ErrorState(ERR_URN_RESOLVE, Http::scNotFound, urnState->request.getRaw(), urnState->ale);
err->url = xstrdup(e->url());
errorAppendEntry(e, err);
delete rep;
- urnHandleReplyError(urnState, urlres_e);
+ delete urnState;
return;
}
urls = urnParseReply(s, urnState->request->method);
- for (i = 0; NULL != urls[i].url; ++i)
- ++urlcnt;
-
- debugs(53, 3, "urnFindMinRtt: Counted " << i << " URLs");
-
- if (urls == NULL) { /* unkown URN error */
+ if (!urls) { /* unknown URN error */
debugs(52, 3, "urnTranslateDone: unknown URN " << e->url());
- err = new ErrorState(ERR_URN_RESOLVE, Http::scNotFound, urnState->request.getRaw());
+ err = new ErrorState(ERR_URN_RESOLVE, Http::scNotFound, urnState->request.getRaw(), urnState->ale);
err->url = xstrdup(e->url());
errorAppendEntry(e, err);
- urnHandleReplyError(urnState, urlres_e);
+ delete urnState;
return;
}
+ for (i = 0; urls[i].url; ++i)
+ ++urlcnt;
+
+ debugs(53, 3, "urnFindMinRtt: Counted " << i << " URLs");
+
min_u = urnFindMinRtt(urls, urnState->request->method, NULL);
qsort(urls, urlcnt, sizeof(*urls), url_entry_sort);
e->buffer();
- mb = new MemBuf;
- mb->init();
+ SBuf body;
+ SBuf *mb = &body; // diff reduction hack; TODO: Remove
mb->appendf( "<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"
"</ADDRESS>\n",
APP_FULLNAME, getMyHostname());
rep = new HttpReply;
- rep->setHeaders(Http::scFound, NULL, "text/html", mb->contentSize(), 0, squid_curtime);
+ rep->setHeaders(Http::scFound, NULL, "text/html", mb->length(), 0, squid_curtime);
- if (urnState->flags.force_menu) {
- debugs(51, 3, "urnHandleReply: forcing menu");
- } else if (min_u) {
- rep->header.putStr(HDR_LOCATION, min_u->url);
+ if (min_u) {
+ rep->header.putStr(Http::HdrType::LOCATION, min_u->url);
}
- rep->body.setMb(mb);
- /* don't clean or delete mb; rep->body owns it now */
+ rep->body.set(body);
e->replaceHttpReply(rep);
e->complete();
}
safe_free(urls);
- /* mb was absorbed in httpBodySet call, so we must not clean it */
- storeUnregister(urnState->sc, urlres_e, urnState);
- urnHandleReplyError(urnState, urlres_e);
+ delete urnState;
}
static url_entry *
{
char *buf = xstrdup(inbuf);
char *token;
- char *url;
- char *host;
url_entry *list;
url_entry *old;
int n = 32;
safe_free(old);
}
- url = xstrdup(token);
- host = urlHostname(url);
-
- if (NULL == host)
+ AnyP::Uri uri;
+ if (!uri.parse(m, SBuf(token)) || !*uri.host())
continue;
#if USE_ICMP
- list[i].rtt = netdbHostRtt(host);
+ list[i].rtt = netdbHostRtt(uri.host());
if (0 == list[i].rtt) {
- debugs(52, 3, "urnParseReply: Pinging " << host);
- netdbPingSite(host);
+ debugs(52, 3, "Pinging " << uri.host());
+ netdbPingSite(uri.host());
}
#else
list[i].rtt = 0;
#endif
- list[i].url = url;
- list[i].host = xstrdup(host);
+ list[i].url = xstrdup(uri.absolute().c_str());
+ list[i].host = xstrdup(uri.host());
// TODO: Use storeHas() or lock/unlock entry to avoid creating unlocked
// ones.
- list[i].flags.cached = storeGetPublic(url, m) ? 1 : 0;
+ list[i].flags.cached = storeGetPublic(list[i].url, m) ? 1 : 0;
++i;
}
debugs(52, 3, "urnParseReply: Found " << i << " URLs");
+ xfree(buf);
return list;
}
projects / thirdparty / squid.git / blobdiff