{
method = aMethod;
url.setScheme(aProtocol);
- urlpath = aUrlpath;
+ url.path(aUrlpath);
}
void
{
method = Http::METHOD_NONE;
url.clear();
- urlpath = NULL;
#if USE_AUTH
auth_user_request = NULL;
#endif
safe_free(vary_headers);
url.clear();
- urlpath.clean();
header.clean();
HttpRequest *
HttpRequest::clone() const
{
- HttpRequest *copy = new HttpRequest(method, url.getScheme(), urlpath.termedBuf());
+ HttpRequest *copy = new HttpRequest();
+ copy->method = method;
// TODO: move common cloning clone to Msg::copyTo() or copy ctor
copy->header.append(&header);
copy->hdrCacheInit();
copy->pstate = pstate; // TODO: should we assert a specific state here?
copy->body_pipe = body_pipe;
+ copy->url.setScheme(url.getScheme());
copy->url.userInfo(url.userInfo());
copy->url.host(url.host());
copy->url.port(url.port());
+ copy->url.path(url.path());
// urlPath handled in ctor
copy->canonical = canonical ? xstrdup(canonical) : NULL;
{
assert(p);
/* pack request-line */
- p->appendf(SQUIDSBUFPH " " SQUIDSTRINGPH " HTTP/%d.%d\r\n",
- SQUIDSBUFPRINT(method.image()), SQUIDSTRINGPRINT(urlpath),
+ p->appendf(SQUIDSBUFPH " " SQUIDSBUFPH " HTTP/%d.%d\r\n",
+ SQUIDSBUFPRINT(method.image()), SQUIDSBUFPRINT(url.path()),
http_ver.major, http_ver.minor);
/* headers */
header.packInto(p);
/* returns the length of request line + headers + crlf */
int
-HttpRequest::prefixLen()
+HttpRequest::prefixLen() const
{
return method.image().length() + 1 +
- urlpath.size() + 1 +
+ url.path().length() + 1 +
4 + 1 + 3 + 2 +
header.len + 2;
}
errDetail = ERR_DETAIL_NONE;
}
-const char *HttpRequest::packableURI(bool full_uri) const
+void
+HttpRequest::packFirstLineInto(Packable * p, bool full_uri) const
{
+ SBuf tmp;
if (full_uri)
- return urlCanonical((HttpRequest*)this);
-
- if (urlpath.size())
- return urlpath.termedBuf();
+ tmp = urlCanonical((HttpRequest*)this);
+ else
+ tmp = url.path();
- return "/";
-}
-
-void HttpRequest::packFirstLineInto(Packable * p, bool full_uri) const
-{
// form HTTP request-line
- p->appendf(SQUIDSBUFPH " %s HTTP/%d.%d\r\n",
+ p->appendf(SQUIDSBUFPH " " SQUIDSBUFPH " HTTP/%d.%d\r\n",
SQUIDSBUFPRINT(method.image()),
- packableURI(full_uri),
+ SQUIDSBUFPRINT(tmp),
http_ver.major, http_ver.minor);
}
Auth::UserRequest::Pointer auth_user_request;
#endif
- String urlpath;
-
char *canonical;
/**
bool bodyNibbled() const; // the request has a [partially] consumed body
- int prefixLen();
+ int prefixLen() const;
void swapOut(StoreEntry * e);
int64_t getRangeOffsetLimit(); /* the result of this function gets cached in rangeOffsetLimit */
private:
- const char *packableURI(bool full_uri) const;
-
mutable int64_t rangeOffsetLimit; /* caches the result of getRangeOffsetLimit */
protected:
#include "rfc2181.h"
#include "SBuf.h"
+#include <iosfwd>
+
/**
* The URL class represents a Uniform Resource Location
*
void port(unsigned short p) {port_=p; touch();}
unsigned short port() const {return port_;}
+ void path(const char *p) {path_=p; touch();}
+ void path(const SBuf &p) {path_=p; touch();}
+ const SBuf &path() const;
+
+ /// the static '/' default URL-path
+ static const SBuf &SlashPath();
+
/// the static '*' pseudo-URL
static const SBuf &Asterisk();
unsigned short port_; ///< URL port
+ // XXX: for now includes query-string.
+ SBuf path_; ///< URL path segment
+
// pre-assembled URL forms
mutable SBuf authorityHttp_; ///< RFC 7230 section 5.3.3 authority, maybe without default-port
mutable SBuf authorityWithPort_; ///< RFC 7230 section 5.3.3 authority with explicit port
+ mutable SBuf canonical_; ///< full absolute-URI
};
+inline std::ostream &
+operator <<(std::ostream &os, const URL &url)
+{
+ if (const char *sc = url.getScheme().c_str())
+ os << sc << ":";
+ os << "//" << url.authority() << url.path();
+ return os;
+}
+
class HttpRequest;
class HttpRequestMethod;
int
ACLUrlPathStrategy::match (ACLData<char const *> * &data, ACLFilledChecklist *checklist, ACLFlags &)
{
- if (!checklist->request->urlpath.size())
+ if (checklist->request->url.path().isEmpty())
return -1;
- char *esc_buf = xstrdup(checklist->request->urlpath.termedBuf());
+ SBuf tmp = checklist->request->url.path();
+ char *esc_buf = xstrndup(tmp.rawContent(), tmp.length());
rfc1738_unescape(esc_buf);
int result = data->match(esc_buf);
- safe_free(esc_buf);
+ xfree(esc_buf);
return result;
}
// Sending a message to a service that does not want it is useless.
// note that we cannot check wantsUrl for service that is not "up"
// note that even essential services are skipped on unwanted URLs!
- return wantsUrl(filter.request->urlpath);
+ return wantsUrl(filter.request->url.path());
}
// The service is down and is either not bypassable or not probed due
bool wants(const ServiceFilter &filter) const;
// the methods below can only be called on an up() service
- virtual bool wantsUrl(const String &urlPath) const = 0;
+ virtual bool wantsUrl(const SBuf &urlPath) const = 0;
// called by transactions to report service failure
virtual void noteFailure() = 0;
return theService != NULL;
}
-bool Adaptation::Ecap::ServiceRep::wantsUrl(const String &urlPath) const
+bool Adaptation::Ecap::ServiceRep::wantsUrl(const SBuf &urlPath) const
{
Must(up());
- return theService->wantsUrl(urlPath.termedBuf());
+ SBuf nonConstUrlPath = urlPath;
+ // c_str() reallocates and terminates for libecap API
+ return theService->wantsUrl(nonConstUrlPath.c_str());
}
Adaptation::Initiate *
virtual bool probed() const;
virtual bool up() const;
virtual Adaptation::Initiate *makeXactLauncher(HttpMsg *virginHeader, HttpRequest *virginCause, AccessLogEntry::Pointer &alp);
- virtual bool wantsUrl(const String &urlPath) const;
+ virtual bool wantsUrl(const SBuf &urlPath) const;
virtual void noteFailure();
virtual const char *status() const;
virtual void detach();
// to simplify, we could assume that request is always available
- String urlPath;
if (request) {
- urlPath = request->urlpath;
if (ICAP::methodRespmod == m)
encapsulateHead(buf, "req-hdr", httpBuf, request);
else if (ICAP::methodReqmod == m)
return;
}
- const String urlPath = virginRequest().urlpath;
+ const SBuf urlPath(virginRequest().url.path());
size_t wantedSize;
if (!service().wantsPreview(urlPath, wantedSize)) {
- debugs(93, 5, HERE << "should not offer preview for " << urlPath);
+ debugs(93, 5, "should not offer preview for " << urlPath);
return;
}
// future optimization note: this method is called by ICAP ACL code at least
// twice for each HTTP message to see if the message should be ignored. For any
// non-ignored HTTP message, ICAP calls to check whether a preview is needed.
-Adaptation::Icap::Options::TransferKind Adaptation::Icap::Options::transferKind(const String &urlPath) const
+Adaptation::Icap::Options::TransferKind
+Adaptation::Icap::Options::transferKind(const SBuf &urlPath) const
{
if (theTransfers.preview.matches(urlPath))
return xferPreview;
if (theTransfers.ignore.matches(urlPath))
return xferIgnore;
- debugs(93,7, HERE << "url " << urlPath << " matches no extensions; " <<
+ debugs(93,7, "url " << urlPath << " matches no extensions; " <<
"using default: " << theTransfers.byDefault->name);
return theTransfers.byDefault->kind;
}
wordlistAdd(&extensions, extension);
};
-bool Adaptation::Icap::Options::TransferList::matches(const String &urlPath) const
+bool Adaptation::Icap::Options::TransferList::matches(const SBuf &urlPath) const
{
- const int urlLen = urlPath.size();
+ const SBuf::size_type urlLen = urlPath.length();
for (wordlist *e = extensions; e; e = e->next) {
// optimize: store extension lengths
- const int eLen = strlen(e->key);
+ const size_t eLen = strlen(e->key);
// assume URL contains at least '/' before the extension
if (eLen < urlLen) {
- const int eOff = urlLen - eLen;
+ const size_t eOff = urlLen - eLen;
// RFC 3507 examples imply that extensions come without leading '.'
- if (urlPath[eOff-1] == '.' &&
- strcmp(urlPath.termedBuf() + eOff, e->key) == 0) {
- debugs(93,7, HERE << "url " << urlPath << " matches " <<
- name << " extension " << e->key);
+ if (urlPath[eOff-1] == '.' && urlPath.substr(eOff).cmp(e->key, eLen) == 0) {
+ debugs(93,7, "url " << urlPath << " matches " << name << " extension " << e->key);
return true;
}
}
}
- debugs(93,8, HERE << "url " << urlPath << " matches no " << name << " extensions");
+ debugs(93,8, "url " << urlPath << " matches no " << name << " extensions");
return false;
}
time_t timestamp() const { return theTimestamp; };
typedef enum { xferNone, xferPreview, xferIgnore, xferComplete } TransferKind;
- TransferKind transferKind(const String &urlPath) const;
+ TransferKind transferKind(const SBuf &urlPath) const;
public:
const char *error; // human-readable information; set iff !valid()
TransferList();
~TransferList();
- bool matches(const String &urlPath) const;
+ bool matches(const SBuf &urlPath) const;
void parse(const String &buf, bool &foundStar);
void add(const char *extension);
return (available != 0); // it is -1 (no limit) or has available slots
}
-bool Adaptation::Icap::ServiceRep::wantsUrl(const String &urlPath) const
+bool Adaptation::Icap::ServiceRep::wantsUrl(const SBuf &urlPath) const
{
Must(hasOptions());
return theOptions->transferKind(urlPath) != Adaptation::Icap::Options::xferIgnore;
}
-bool Adaptation::Icap::ServiceRep::wantsPreview(const String &urlPath, size_t &wantedSize) const
+bool Adaptation::Icap::ServiceRep::wantsPreview(const SBuf &urlPath, size_t &wantedSize) const
{
Must(hasOptions());
void callWhenReady(AsyncCall::Pointer &cb);
// the methods below can only be called on an up() service
- bool wantsUrl(const String &urlPath) const;
- bool wantsPreview(const String &urlPath, size_t &wantedSize) const;
+ bool wantsUrl(const SBuf &urlPath) const;
+ bool wantsPreview(const SBuf &urlPath, size_t &wantedSize) const;
bool allows204() const;
bool allows206() const;
Comm::ConnectionPointer getConnection(bool isRetriable, bool &isReused);
key.appendf(":%u", request->url.port());
}
if (tp->options.carp_key.path) {
- String::size_type pos;
- if ((pos=request->urlpath.find('?'))!=String::npos)
- key.append(SBuf(request->urlpath.substr(0,pos)));
- else
- key.append(SBuf(request->urlpath));
+ // XXX: fix when path and query are separate
+ key.append(request->url.path().substr(0,request->url.path().find('?'))); // 0..N
}
if (tp->options.carp_key.params) {
- String::size_type pos;
- if ((pos=request->urlpath.find('?'))!=String::npos)
- key.append(SBuf(request->urlpath.substr(pos,request->urlpath.size())));
+ // XXX: fix when path and query are separate
+ SBuf::size_type pos;
+ if ((pos=request->url.path().find('?')) != SBuf::npos)
+ key.append(request->url.path().substr(pos)); // N..npos
}
}
// if the url-based key is empty, e.g. because the user is
clientSocketDetach, newClient, tempBuffer);
/* set url */
- // XXX: c_str() does re-allocate but here replaces explicit malloc/free.
- // when internalCheck() accepts SBuf removing this will be a net gain for performance.
- SBuf tmp(hp->requestUri());
- const char *url = tmp.c_str();
-
debugs(33,5, "Prepare absolute URL from " <<
(csd->transparent()?"intercept":(csd->port->flags.accelSurrogate ? "accel":"")));
/* Rewrite the URL in transparent or accelerator mode */
* - intercept mode (NAT)
* - intercept mode with failures
* - accelerator mode (reverse proxy)
- * - internal URL
+ * - internal relative-URL
* - mixed combos of the above with internal URL
* - remote interception with PROXY protocol
* - remote reverse-proxy with PROXY protocol
/* intercept or transparent mode, properly working with no failures */
prepareTransparentURL(csd, http, hp);
- } else if (internalCheck(url)) {
+ } else if (internalCheck(hp->requestUri())) { // NP: only matches relative-URI
/* internal URL mode */
/* prepend our name & port */
- http->uri = xstrdup(internalLocalUri(NULL, url));
+ http->uri = xstrdup(internalLocalUri(NULL, hp->requestUri()));
// We just re-wrote the URL. Must replace the Host: header.
// But have not parsed there yet!! flag for local-only handling.
http->flags.internal = true;
* requested url. may be rewritten later, so make extra room */
int url_sz = hp->requestUri().length() + Config.appendDomainLen + 5;
http->uri = (char *)xcalloc(url_sz, 1);
- strcpy(http->uri, url);
+ xstrncpy(http->uri, hp->requestUri().rawContent(), hp->requestUri().length());
}
result->flags.parsed_ok = 1;
request->flags.spoofClientIp = false;
}
- if (internalCheck(request->urlpath.termedBuf())) {
+ if (internalCheck(request->url.path())) {
if (internalHostnameIs(request->url.host()) && request->url.port() == getMyPort()) {
debugs(33, 2, "internal URL found: " << request->url.getScheme() << "://" << request->url.authority(true));
http->flags.internal = true;
- } else if (Config.onoff.global_internal_static && internalStaticCheck(request->urlpath.termedBuf())) {
+ } else if (Config.onoff.global_internal_static && internalStaticCheck(request->url.path())) {
debugs(33, 2, "internal URL found: " << request->url.getScheme() << "://" << request->url.authority(true) << " (global_internal_static on)");
request->url.setScheme(AnyP::PROTO_HTTP);
request->SetHost(internalHostname());
return 0; /* different username */
}
-static String str_type_eq;
void
Ftp::Gateway::checkUrlpath()
{
- int l;
- size_t t;
+ static SBuf str_type_eq("type=");
+ auto t = request->url.path().rfind(';');
- if (str_type_eq.size()==0) //hack. String doesn't support global-static
- str_type_eq="type=";
-
- if ((t = request->urlpath.rfind(';')) != String::npos) {
- if (request->urlpath.substr(t+1,t+1+str_type_eq.size())==str_type_eq) {
- typecode = (char)xtoupper(request->urlpath[t+str_type_eq.size()+1]);
- request->urlpath.cut(t);
+ if (t != SBuf::npos) {
+ auto filenameEnd = t-1;
+ if (request->url.path().substr(++t).cmp(str_type_eq, str_type_eq.length()) == 0) {
+ t += str_type_eq.length();
+ typecode = (char)xtoupper(request->url.path()[t]);
+ request->url.path(request->url.path().substr(0,filenameEnd));
}
}
- l = request->urlpath.size();
+ int l = request->url.path().length();
/* check for null path */
if (!l) {
flags.isdir = 1;
flags.root_dir = 1;
flags.need_base_href = 1; /* Work around broken browsers */
- } else if (!request->urlpath.cmp("/%2f/")) {
+ } else if (!request->url.path().cmp("/%2f/")) {
/* UNIX root directory */
flags.isdir = 1;
flags.root_dir = 1;
- } else if ((l >= 1) && (request->urlpath[l - 1] == '/')) {
+ } else if ((l >= 1) && (request->url.path()[l-1] == '/')) {
/* Directory URL, ending in / */
flags.isdir = 1;
SBuf authority = request->url.authority(request->url.getScheme() != AnyP::PROTO_FTP);
title_url.append(authority.rawContent(), authority.length());
- title_url.append(request->urlpath);
+ title_url.append(request->url.path().rawContent(), request->url.path().length());
base_href = "ftp://";
}
base_href.append(authority.rawContent(), authority.length());
- base_href.append(request->urlpath);
+ base_href.append(request->url.path().rawContent(), request->url.path().length());
base_href.append("/");
}
checkUrlpath();
buildTitleUrl();
- debugs(9, 5, HERE << "FD " << ctrl.conn->fd << " : host=" << request->url.host() <<
- ", path=" << request->urlpath << ", user=" << user << ", passwd=" << password);
+ debugs(9, 5, "FD " << ctrl.conn->fd << " : host=" << request->url.host() <<
+ ", path=" << request->url.path() << ", user=" << user << ", passwd=" << password);
state = BEGIN;
Ftp::Client::start();
}
static void
ftpSendType(Ftp::Gateway * ftpState)
{
- const char *t;
- const char *filename;
- char mode;
-
/* check the server control channel is still available */
if (!ftpState || !ftpState->haveControlChannel("ftpSendType"))
return;
/*
* Ref section 3.2.2 of RFC 1738
*/
- mode = ftpState->typecode;
+ char mode = ftpState->typecode;
switch (mode) {
if (ftpState->flags.isdir) {
mode = 'A';
} else {
- t = ftpState->request->urlpath.rpos('/');
- filename = t ? t + 1 : ftpState->request->urlpath.termedBuf();
- mode = mimeGetTransferMode(filename);
+ auto t = ftpState->request->url.path().rfind('/');
+ // XXX: performance regression, c_str() may reallocate
+ SBuf filename = ftpState->request->url.path().substr(t != SBuf::npos ? t + 1 : 0);
+ mode = mimeGetTransferMode(filename.c_str());
}
break;
debugs(9, 3, HERE << "code=" << code);
if (code == 200) {
- p = path = xstrdup(ftpState->request->urlpath.termedBuf());
+ const SBuf tmp = ftpState->request->url.path();
+ p = path = xstrndup(tmp.rawContent(),tmp.length());
if (*p == '/')
++p;
safe_free(ftpState->filepath);
/* Build the new path (urlpath begins with /) */
- path = xstrdup(ftpState->request->urlpath.termedBuf());
+ const SBuf tmp = ftpState->request->url.path();
+ path = xstrndup(tmp.rawContent(), tmp.length());
+ path[tmp.length()] = '\0';
rfc1738_unescape(path);
static void
ftpFail(Ftp::Gateway *ftpState)
{
- debugs(9, 6, HERE << "flags(" <<
+ const bool slashHack = ftpState->request->url.path().caseCmp("/%2f", 4)==0;
+ debugs(9, 6, "flags(" <<
(ftpState->flags.isdir?"IS_DIR,":"") <<
(ftpState->flags.try_slash_hack?"TRY_SLASH_HACK":"") << "), " <<
"mdtm=" << ftpState->mdtm << ", size=" << ftpState->theSize <<
- "slashhack=" << (ftpState->request->urlpath.caseCmp("/%2f", 4)==0? "T":"F") );
+ "slashhack=" << (slashHack? "T":"F"));
/* Try the / hack to support "Netscape" FTP URL's for retreiving files */
if (!ftpState->flags.isdir && /* Not a directory */
- !ftpState->flags.try_slash_hack && /* Not in slash hack */
- ftpState->mdtm <= 0 && ftpState->theSize < 0 && /* Not known as a file */
- ftpState->request->urlpath.caseCmp("/%2f", 4) != 0) { /* No slash encoded */
+ !ftpState->flags.try_slash_hack && !slashHack && /* Not doing slash hack */
+ ftpState->mdtm <= 0 && ftpState->theSize < 0) { /* Not known as a file */
switch (ftpState->state) {
void
Ftp::Gateway::appendSuccessHeader()
{
- const char *mime_type = NULL;
- const char *mime_enc = NULL;
- String urlpath = request->urlpath;
- const char *filename = NULL;
- const char *t = NULL;
-
debugs(9, 3, HERE);
if (flags.http_header_sent)
entry->buffer(); /* released when done processing current data payload */
- filename = (t = urlpath.rpos('/')) ? t + 1 : urlpath.termedBuf();
+ SBuf urlPath = request->url.path();
+ auto t = urlPath.rfind('/');
+ SBuf filename = urlPath.substr(t != SBuf::npos ? t : 0);
+
+ const char *mime_type = NULL;
+ const char *mime_enc = NULL;
if (flags.isdir) {
mime_type = "text/html";
case 'I':
mime_type = "application/octet-stream";
- mime_enc = mimeGetContentEncoding(filename);
+ // XXX: performance regression, c_str() may reallocate
+ mime_enc = mimeGetContentEncoding(filename.c_str());
break;
case 'A':
break;
default:
- mime_type = mimeGetContentType(filename);
- mime_enc = mimeGetContentEncoding(filename);
+ // XXX: performance regression, c_str() may reallocate
+ mime_type = mimeGetContentType(filename.c_str());
+ mime_enc = mimeGetContentEncoding(filename.c_str());
break;
}
}
const char *
Ftp::UrlWith2f(HttpRequest * request)
{
- String newbuf = "%2f";
+ SBuf newbuf("%2f");
if (request->url.getScheme() != AnyP::PROTO_FTP)
return NULL;
- if ( request->urlpath[0]=='/' ) {
- newbuf.append(request->urlpath);
- request->urlpath.absorb(newbuf);
+ if (request->url.path()[0] == '/') {
+ newbuf.append(request->url.path());
+ request->url.path(newbuf);
safe_free(request->canonical);
- } else if ( !strncmp(request->urlpath.termedBuf(), "%2f", 3) ) {
- newbuf.append(request->urlpath.substr(1,request->urlpath.size()));
- request->urlpath.absorb(newbuf);
+ } else if (!request->url.path().startsWith(newbuf)) {
+ newbuf.append(request->url.path().substr(1));
+ request->url.path(newbuf);
safe_free(request->canonical);
}
str.append("\r\n", 2);
/* - HTTP stuff */
str.append("HTTP Request:\r\n", 15);
-
- if (NULL != request) {
- String urlpath_or_slash;
-
- if (request->urlpath.size() != 0)
- urlpath_or_slash = request->urlpath;
- else
- urlpath_or_slash = "/";
-
- str.appendf(SQUIDSBUFPH " " SQUIDSTRINGPH " %s/%d.%d\n",
+ if (request) {
+ str.appendf(SQUIDSBUFPH " " SQUIDSBUFPH " %s/%d.%d\n",
SQUIDSBUFPRINT(request->method.image()),
- SQUIDSTRINGPRINT(urlpath_or_slash),
+ SQUIDSBUFPRINT(request->url.path()),
AnyP::ProtocolType_str[request->http_ver.protocol],
request->http_ver.major, request->http_ver.minor);
request->header.packInto(&str);
case 'R':
if (building_deny_info_url) {
if (request != NULL) {
- p = (request->urlpath.size() != 0 ? request->urlpath.termedBuf() : "/");
+ SBuf tmp = request->url.path();
+ p = tmp.c_str();
no_urlescape = 1;
} else
p = "[no request]";
break;
}
- if (NULL != request) {
- String urlpath_or_slash;
-
- if (request->urlpath.size() != 0)
- urlpath_or_slash = request->urlpath;
- else
- urlpath_or_slash = "/";
-
- mb.appendf(SQUIDSBUFPH " " SQUIDSTRINGPH " %s/%d.%d\n",
+ if (request != NULL) {
+ mb.appendf(SQUIDSBUFPH " " SQUIDSBUFPH " %s/%d.%d\n",
SQUIDSBUFPRINT(request->method.image()),
- SQUIDSTRINGPRINT(urlpath_or_slash),
+ SQUIDSBUFPRINT(request->url.path()),
AnyP::ProtocolType_str[request->http_ver.protocol],
request->http_ver.major, request->http_ver.minor);
request->header.packInto(&mb, true); //hide authorization data
str = buf;
break;
- case Format::LFT_CLIENT_REQ_URLPATH:
- str = request->urlpath.termedBuf();
+ case Format::LFT_CLIENT_REQ_URLPATH: {
+ SBuf tmp = request->url.path();
+ str = tmp.c_str();
+ }
break;
case Format::LFT_CLIENT_REQ_METHOD: {
case LFT_REQUEST_URLPATH_OLD_31:
case LFT_CLIENT_REQ_URLPATH:
if (al->request) {
- out = al->request->urlpath.termedBuf();
+ SBuf s = al->request->url.path();
+ out = s.c_str();
quote = 1;
}
break;
case LFT_SERVER_REQ_URLPATH:
if (al->adapted_request) {
- out = al->adapted_request->urlpath.termedBuf();
+ SBuf s = al->adapted_request->url.path();
+ out = s.c_str();
quote = 1;
}
break;
#include "HttpRequest.h"
#include "MemBuf.h"
#include "mime.h"
+#include "parser/Tokenizer.h"
#include "rfc1738.h"
#include "SquidConfig.h"
#include "SquidTime.h"
static void
gopher_request_parse(const HttpRequest * req, char *type_id, char *request)
{
- const char *path = req->urlpath.termedBuf();
+ ::Parser::Tokenizer tok(req->url.path());
if (request)
- request[0] = '\0';
+ *request = 0;
- if (path && (*path == '/'))
- ++path;
+ tok.skip('/'); // ignore failures? path could be ab-empty
- if (!path || !*path) {
+ if (tok.atEnd()) {
*type_id = GOPHER_DIRECTORY;
return;
}
- *type_id = path[0];
+ static const CharacterSet anyByte("UTF-8",0x00, 0xFF);
+
+ SBuf typeId;
+ (void)tok.prefix(typeId, anyByte, 1); // never fails since !atEnd()
+ *type_id = typeId[0];
if (request) {
- xstrncpy(request, path + 1, MAX_URL);
+ SBuf path = tok.remaining().substr(0, MAX_URL);
+ xstrncpy(request, path.rawContent(), path.length());
/* convert %xx to char */
rfc1738_unescape(request);
}
const Http::StatusCode s = vrep->sline.status();
const AnyP::ProtocolVersion &v = vrep->sline.version;
if (s == Http::scInvalidHeader && v != Http::ProtocolVersion(0,9)) {
- debugs(11, DBG_IMPORTANT, "WARNING: HTTP: Invalid Response: Bad header encountered from " << entry->url() << " AKA " << request->url.host() << request->urlpath.termedBuf());
+ debugs(11, DBG_IMPORTANT, "WARNING: HTTP: Invalid Response: Bad header encountered from " << entry->url() << " AKA " << request->url);
error = ERR_INVALID_RESP;
} else if (s == Http::scHeaderTooLarge) {
fwd->dontRetry(true);
}
} else {
// parsed headers but got no reply
- debugs(11, DBG_IMPORTANT, "WARNING: HTTP: Invalid Response: No reply at all for " << entry->url() << " AKA " << request->url.host() << request->urlpath.termedBuf());
+ debugs(11, DBG_IMPORTANT, "WARNING: HTTP: Invalid Response: No reply at all for " << entry->url() << " AKA " << request->url);
error = ERR_INVALID_RESP;
}
} else {
assert(eof);
if (inBuf.length()) {
error = ERR_INVALID_RESP;
- debugs(11, DBG_IMPORTANT, "WARNING: HTTP: Invalid Response: Headers did not parse at all for " << entry->url() << " AKA " << request->url.host() << request->urlpath.termedBuf());
+ debugs(11, DBG_IMPORTANT, "WARNING: HTTP: Invalid Response: Headers did not parse at all for " << entry->url() << " AKA " << request->url);
} else {
error = ERR_ZERO_SIZE_OBJECT;
- debugs(11, (request->flags.accelerated?DBG_IMPORTANT:2), "WARNING: HTTP: Invalid Response: No object data received for " <<
- entry->url() << " AKA " << request->url.host() << request->urlpath.termedBuf());
+ debugs(11, (request->flags.accelerated?DBG_IMPORTANT:2), "WARNING: HTTP: Invalid Response: No object data received for " << entry->url() << " AKA " << request->url);
}
}
* not the one we are sending. Needs checking.
*/
const AnyP::ProtocolVersion httpver = Http::ProtocolVersion();
- const char * url;
- if (_peer && !_peer->options.originserver)
- url = urlCanonical(request);
- else
- url = request->urlpath.termedBuf();
- mb->appendf(SQUIDSBUFPH " %s %s/%d.%d\r\n",
+ const bool canonical = (_peer && !_peer->options.originserver);
+ const SBuf url = canonical ? SBuf(urlCanonical(request)) : request->url.path();
+ mb->appendf(SQUIDSBUFPH " " SQUIDSBUFPH " %s/%d.%d\r\n",
SQUIDSBUFPRINT(request->method.image()),
- url && *url ? url : "/",
+ SQUIDSBUFPRINT(url),
AnyP::ProtocolType_str[httpver.protocol],
httpver.major,httpver.minor);
/* build and pack headers */
{
#if USE_ICMP
CachePeer *p = (CachePeer *)data;
- char *uri = internalRemoteUri(p->host, p->http_port, "/squid-internal-dynamic/", "netdb");
+ static const SBuf netDB("netdb");
+ char *uri = internalRemoteUri(p->host, p->http_port, "/squid-internal-dynamic/", netDB);
debugs(38, 3, "netdbExchangeStart: Requesting '" << uri << "'");
assert(NULL != uri);
HttpRequest *req = HttpRequest::CreateFromUrl(uri);
internalStart(const Comm::ConnectionPointer &clientConn, HttpRequest * request, StoreEntry * entry)
{
ErrorState *err;
- const char *upath = request->urlpath.termedBuf();
- debugs(76, 3, HERE << clientConn << " requesting '" << upath << "'");
+ const SBuf upath = request->url.path();
+ debugs(76, 3, clientConn << " requesting '" << upath << "'");
- if (0 == strcmp(upath, "/squid-internal-dynamic/netdb")) {
+ static const SBuf netdbUri("/squid-internal-dynamic/netdb");
+ static const SBuf storeDigestUri("/squid-internal-periodic/store_digest");
+ static const SBuf mgrPfx("/squid-internal-mgr/");
+
+ if (upath == netdbUri) {
netdbBinaryExchange(entry);
- } else if (0 == strcmp(upath, "/squid-internal-periodic/store_digest")) {
+ } else if (upath == storeDigestUri) {
#if USE_CACHE_DIGESTS
const char *msgbuf = "This cache is currently building its digest.\n";
#else
entry->replaceHttpReply(reply);
entry->append(msgbuf, strlen(msgbuf));
entry->complete();
- } else if (0 == strncmp(upath, "/squid-internal-mgr/", 20)) {
- debugs(17, 2, "calling CacheManager due to URL-path /squid-internal-mgr/");
+ } else if (upath.startsWith(mgrPfx)) {
+ debugs(17, 2, "calling CacheManager due to URL-path " << mgrPfx);
CacheManager::GetInstance()->Start(clientConn, request, entry);
} else {
debugObj(76, 1, "internalStart: unknown request:\n",
}
}
-int
-internalCheck(const char *urlpath)
+bool
+internalCheck(const SBuf &urlPath)
{
- return (0 == strncmp(urlpath, "/squid-internal-", 16));
+ static const SBuf InternalPfx("/squid-internal-");
+ return urlPath.startsWith(InternalPfx);
}
-int
-internalStaticCheck(const char *urlpath)
+bool
+internalStaticCheck(const SBuf &urlPath)
{
- return (0 == strncmp(urlpath, "/squid-internal-static", 22));
+ static const SBuf InternalStaticPfx("/squid-internal-static");
+ return urlPath.startsWith(InternalStaticPfx);
}
/*
* makes internal url with a given host and port (remote internal url)
*/
char *
-internalRemoteUri(const char *host, unsigned short port, const char *dir, const char *name)
+internalRemoteUri(const char *host, unsigned short port, const char *dir, const SBuf &name)
{
static char lc_host[SQUIDHOSTNAMELEN];
- assert(host && name);
+ assert(host && !name.isEmpty());
/* convert host name to lower case */
xstrncpy(lc_host, host, SQUIDHOSTNAMELEN);
Tolower(lc_host);
if (dir)
mb.append(dir, strlen(dir));
- mb.append(name, strlen(name));
+ mb.append(name.rawContent(), name.length());
/* return a pointer to a local static buffer */
return mb.buf;
* makes internal url with local host and port
*/
char *
-internalLocalUri(const char *dir, const char *name)
+internalLocalUri(const char *dir, const SBuf &name)
{
return internalRemoteUri(getMyHostname(),
getMyPort(), dir, name);
#define SQUID_INTERNAL_H_
#include "comm/forward.h"
+
class HttpRequest;
+class SBuf;
class StoreEntry;
void internalStart(const Comm::ConnectionPointer &clientConn, HttpRequest *, StoreEntry *);
-int internalCheck(const char *urlpath);
-int internalStaticCheck(const char *urlpath);
-char *internalLocalUri(const char *dir, const char *name);
-char *internalRemoteUri(const char *, unsigned short, const char *, const char *);
+bool internalCheck(const SBuf &urlPath);
+bool internalStaticCheck(const SBuf &urlPath);
+char *internalLocalUri(const char *dir, const SBuf &name);
+char *internalRemoteUri(const char *, unsigned short, const char *, const SBuf &);
const char *internalHostname(void);
int internalHostnameIs(const char *);
MimeIcon::MimeIcon(const char *aName) :
icon_(aName)
{
- url_ = xstrdup(internalLocalUri("/squid-internal-static/icons/", icon_.c_str()));
+ url_ = xstrdup(internalLocalUri("/squid-internal-static/icons/", icon_));
}
MimeIcon::~MimeIcon()
{
xfree(url_);
icon_ = aString;
- url_ = xstrdup(internalLocalUri("/squid-internal-static/icons/", icon_.c_str()));
+ url_ = xstrdup(internalLocalUri("/squid-internal-static/icons/", icon_));
}
SBuf
mb.append(icon);
return mb.c_str();
} else {
- return internalLocalUri("/squid-internal-static/icons/", icon.c_str());
+ return internalLocalUri("/squid-internal-static/icons/", icon);
}
}
if (p->digest_url)
url = xstrdup(p->digest_url);
else
- url = xstrdup(internalRemoteUri(p->host, p->http_port, "/squid-internal-periodic/", StoreDigestFileName));
+ url = xstrdup(internalRemoteUri(p->host, p->http_port, "/squid-internal-periodic/", SBuf(StoreDigestFileName)));
req = HttpRequest::CreateFromUrl(url);
CPPUNIT_ASSERT_EQUAL(expected_port, aRequest->url.port());
CPPUNIT_ASSERT(aRequest->method == Http::METHOD_GET);
CPPUNIT_ASSERT_EQUAL(String("foo"), String(aRequest->url.host()));
- CPPUNIT_ASSERT_EQUAL(String("/bar"), aRequest->urlpath);
+ CPPUNIT_ASSERT_EQUAL(SBuf("/bar"), aRequest->url.path());
CPPUNIT_ASSERT_EQUAL(AnyP::PROTO_HTTP, static_cast<AnyP::ProtocolType>(aRequest->url.getScheme()));
CPPUNIT_ASSERT_EQUAL(String("http://foo:90/bar"), String(url));
xfree(url);
CPPUNIT_ASSERT_EQUAL(expected_port, aRequest->url.port());
CPPUNIT_ASSERT(aRequest->method == Http::METHOD_PUT);
CPPUNIT_ASSERT_EQUAL(String("foo"), String(aRequest->url.host()));
- CPPUNIT_ASSERT_EQUAL(String("/bar"), aRequest->urlpath);
+ CPPUNIT_ASSERT_EQUAL(SBuf("/bar"), aRequest->url.path());
CPPUNIT_ASSERT_EQUAL(AnyP::PROTO_HTTP, static_cast<AnyP::ProtocolType>(aRequest->url.getScheme()));
CPPUNIT_ASSERT_EQUAL(String("http://foo/bar"), String(url));
xfree(url);
CPPUNIT_ASSERT_EQUAL(expected_port, aRequest->url.port());
CPPUNIT_ASSERT(aRequest->method == Http::METHOD_CONNECT);
CPPUNIT_ASSERT_EQUAL(String("foo"), String(aRequest->url.host()));
- CPPUNIT_ASSERT_EQUAL(String(""), aRequest->urlpath);
+ CPPUNIT_ASSERT_EQUAL(SBuf(), aRequest->url.path());
CPPUNIT_ASSERT_EQUAL(AnyP::PROTO_NONE, static_cast<AnyP::ProtocolType>(aRequest->url.getScheme()));
CPPUNIT_ASSERT_EQUAL(String("foo:45"), String(url));
xfree(url);
CPPUNIT_ASSERT_EQUAL(expected_port, aRequest->url.port());
CPPUNIT_ASSERT(aRequest->method == Http::METHOD_GET);
CPPUNIT_ASSERT_EQUAL(String("foo"), String(aRequest->url.host()));
- CPPUNIT_ASSERT_EQUAL(String("/bar"), aRequest->urlpath);
+ CPPUNIT_ASSERT_EQUAL(SBuf("/bar"), aRequest->url.path());
CPPUNIT_ASSERT_EQUAL(AnyP::PROTO_HTTP, static_cast<AnyP::ProtocolType>(aRequest->url.getScheme()));
CPPUNIT_ASSERT_EQUAL(String("http://foo:90/bar"), String(url));
xfree(url);
CPPUNIT_ASSERT_EQUAL(expected_port, aRequest->url.port());
CPPUNIT_ASSERT(aRequest->method == Http::METHOD_GET);
CPPUNIT_ASSERT_EQUAL(String("[2000:800::45]"), String(aRequest->url.host()));
- CPPUNIT_ASSERT_EQUAL(String("/foo"), aRequest->urlpath);
+ CPPUNIT_ASSERT_EQUAL(SBuf("/foo"), aRequest->url.path());
CPPUNIT_ASSERT_EQUAL(AnyP::PROTO_HTTP, static_cast<AnyP::ProtocolType>(aRequest->url.getScheme()));
CPPUNIT_ASSERT_EQUAL(String("http://[2000:800::45]/foo"), String(url));
xfree(url);
CPPUNIT_ASSERT_EQUAL(expected_port, aRequest->url.port());
CPPUNIT_ASSERT(aRequest->method == Http::METHOD_GET);
CPPUNIT_ASSERT_EQUAL(String("[2000:800::45]"), String(aRequest->url.host()));
- CPPUNIT_ASSERT_EQUAL(String("/foo"), aRequest->urlpath);
+ CPPUNIT_ASSERT_EQUAL(SBuf("/foo"), aRequest->url.path());
CPPUNIT_ASSERT_EQUAL(AnyP::PROTO_HTTP, static_cast<AnyP::ProtocolType>(aRequest->url.getScheme()));
CPPUNIT_ASSERT_EQUAL(String("http://[2000:800::45]:90/foo"), String(url));
xfree(url);
CPPUNIT_ASSERT_EQUAL(expected_port, aRequest->url.port());
CPPUNIT_ASSERT(aRequest->method == Http::METHOD_GET);
CPPUNIT_ASSERT_EQUAL(String("[2000:800::45]"), String(aRequest->url.host()));
- CPPUNIT_ASSERT_EQUAL(String("/foo"), aRequest->urlpath);
+ CPPUNIT_ASSERT_EQUAL(SBuf("/foo"), aRequest->url.path());
CPPUNIT_ASSERT_EQUAL(AnyP::PROTO_HTTP, static_cast<AnyP::ProtocolType>(aRequest->url.getScheme()));
CPPUNIT_ASSERT_EQUAL(String("http://2000:800::45/foo"), String(url));
xfree(url);
return star;
}
+const SBuf &
+URL::SlashPath()
+{
+ static SBuf slash("/");
+ return slash;
+}
+
void
URL::host(const char *src)
{
touch();
}
+const SBuf &
+URL::path() const
+{
+ // RFC 3986 section 3.3 says path can be empty (path-abempty).
+ // RFC 7230 sections 2.7.3, 5.3.1, 5.7.2 - says path cannot be empty, default to "/"
+ // at least when sending and using. We must still accept path-abempty as input.
+ if (path_.isEmpty() && (scheme_ == AnyP::PROTO_HTTP || scheme_ == AnyP::PROTO_HTTPS))
+ return SlashPath();
+
+ return path_;
+}
+
void
urlInitialize(void)
{
return request->canonical;
if (request->url.getScheme() == AnyP::PROTO_URN) {
- snprintf(urlbuf, MAX_URL, "urn:" SQUIDSTRINGPH,
- SQUIDSTRINGPRINT(request->urlpath));
+ snprintf(urlbuf, MAX_URL, "urn:" SQUIDSBUFPH,
+ SQUIDSBUFPRINT(request->url.path()));
} else {
SBuf authorityForm;
switch (request->method.id()) {
default: {
authorityForm = request->url.authority(); // host[:port]
- snprintf(urlbuf, MAX_URL, "%s://" SQUIDSBUFPH "%s" SQUIDSBUFPH SQUIDSTRINGPH,
+ snprintf(urlbuf, MAX_URL, "%s://" SQUIDSBUFPH "%s" SQUIDSBUFPH SQUIDSBUFPH,
request->url.getScheme().c_str(),
SQUIDSBUFPRINT(request->url.userInfo()),
!request->url.userInfo().isEmpty() ? "@" : "",
SQUIDSBUFPRINT(authorityForm),
- SQUIDSTRINGPRINT(request->urlpath));
+ SQUIDSBUFPRINT(request->url.path()));
}
}
}
char *t;
if (request->url.getScheme() == AnyP::PROTO_URN) {
- snprintf(buf, MAX_URL, "urn:" SQUIDSTRINGPH,
- SQUIDSTRINGPRINT(request->urlpath));
+ snprintf(buf, MAX_URL, "urn:" SQUIDSBUFPH,
+ SQUIDSBUFPRINT(request->url.path()));
} else {
SBuf authorityForm;
switch (request->method.id()) {
default: {
authorityForm = request->url.authority(); // host[:port]
- snprintf(buf, MAX_URL, "%s://" SQUIDSBUFPH "%s" SQUIDSBUFPH SQUIDSTRINGPH,
+ snprintf(buf, MAX_URL, "%s://" SQUIDSBUFPH "%s" SQUIDSBUFPH SQUIDSBUFPH,
request->url.getScheme().c_str(),
SQUIDSBUFPRINT(request->url.userInfo()),
!request->url.userInfo().isEmpty() ? "@" : "",
SQUIDSBUFPRINT(authorityForm),
- SQUIDSTRINGPRINT(request->urlpath));
+ SQUIDSBUFPRINT(request->url.path()));
// strip arguments AFTER a question-mark
if (Config.onoff.strip_query_terms)
char *urlbuf = (char *)xmalloc(MAX_URL * sizeof(char));
if (req->url.getScheme() == AnyP::PROTO_URN) {
- snprintf(urlbuf, MAX_URL, "urn:" SQUIDSTRINGPH,
- SQUIDSTRINGPRINT(req->urlpath));
+ snprintf(urlbuf, MAX_URL, "urn:" SQUIDSBUFPH,
+ SQUIDSBUFPRINT(req->url.path()));
return (urlbuf);
}
!req->url.userInfo().isEmpty() ? "@" : "",
SQUIDSBUFPRINT(authorityForm));
+ // if the first char is '/' assume its a relative path
+ // XXX: this breaks on scheme-relative URLs,
+ // but we should not see those outside ESI, and rarely there.
if (relUrl[0] == '/') {
- strncpy(&urlbuf[urllen], relUrl, MAX_URL - urllen - 1);
+ xstrncpy(&urlbuf[urllen], relUrl, MAX_URL - urllen - 1);
} else {
- const char *path = req->urlpath.termedBuf();
- const char *last_slash = strrchr(path, '/');
+ SBuf path = req->url.path();
+ SBuf::size_type lastSlashPos = path.rfind('/');
- if (last_slash == NULL) {
+ if (lastSlashPos == SBuf::npos) {
+ // replace the whole path with the given bit(s)
urlbuf[urllen] = '/';
++urllen;
- strncpy(&urlbuf[urllen], relUrl, MAX_URL - urllen - 1);
+ xstrncpy(&urlbuf[urllen], relUrl, MAX_URL - urllen - 1);
} else {
- ++last_slash;
- size_t pathlen = last_slash - path;
- if (pathlen > MAX_URL - urllen - 1) {
- pathlen = MAX_URL - urllen - 1;
+ // replace only the last (file?) segment with the given bit(s)
+ ++lastSlashPos;
+ if (lastSlashPos > MAX_URL - urllen - 1) {
+ // XXX: crops bits in the middle of the combined URL.
+ lastSlashPos = MAX_URL - urllen - 1;
}
- strncpy(&urlbuf[urllen], path, pathlen);
- urllen += pathlen;
+ xstrncpy(&urlbuf[urllen], path.rawContent(), lastSlashPos);
+ urllen += lastSlashPos;
if (urllen + 1 < MAX_URL) {
- strncpy(&urlbuf[urllen], relUrl, MAX_URL - urllen - 1);
+ xstrncpy(&urlbuf[urllen], relUrl, MAX_URL - urllen - 1);
}
}
}
// we support OPTIONS and TRACE directed at us (with a 501 reply, for now)
// we also support forwarding OPTIONS and TRACE, except for the *-URI ones
if (r->method == Http::METHOD_OPTIONS || r->method == Http::METHOD_TRACE)
- return (r->header.getInt64(HDR_MAX_FORWARDS) == 0 || URL::Asterisk().cmp(r->urlpath.rawBuf(), r->urlpath.size()) != 0);
+ return (r->header.getInt64(HDR_MAX_FORWARDS) == 0 || r->url.path() != URL::Asterisk());
if (r->method == Http::METHOD_PURGE)
return 1;
public:
void created (StoreEntry *newEntry);
void start (HttpRequest *, StoreEntry *);
- char *getHost (String &urlpath);
+ char *getHost(const SBuf &urlpath);
void setUriResFromRequest(HttpRequest *);
- bool RequestNeedsMenu(HttpRequest *r);
- void updateRequestURL(HttpRequest *r, char const *newPath, const size_t newPath_len);
- void createUriResRequest (String &uri);
virtual ~UrnState();
}
char *
-UrnState::getHost (String &urlpath)
+UrnState::getHost(const SBuf &urlpath)
{
char * result;
size_t p;
/** FIXME: this appears to be parsing the URL. *very* badly. */
/* a proper encapsulated URI/URL type needs to clear this up. */
- if ((p=urlpath.find(':')) != String::npos) {
- result=xstrndup(urlpath.rawBuf(),p-1);
+ if ((p = urlpath.find(':')) != SBuf::npos) {
+ result = xstrndup(urlpath.rawContent(), p-1);
} else {
- result = xstrndup(urlpath.rawBuf(),urlpath.size());
+ result = xstrndup(urlpath.rawContent(), urlpath.length());
}
return result;
}
-bool
-UrnState::RequestNeedsMenu(HttpRequest *r)
-{
- if (r->urlpath.size() < 5)
- return false;
- //now we're sure it's long enough
- return strncasecmp(r->urlpath.rawBuf(), "menu.", 5) == 0;
-}
-
void
-UrnState::updateRequestURL(HttpRequest *r, char const *newPath, const size_t newPath_len)
+UrnState::setUriResFromRequest(HttpRequest *r)
{
- char *new_path = xstrndup (newPath, newPath_len);
- r->urlpath = new_path;
- xfree(new_path);
-}
+ 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;
+ }
-void
-UrnState::createUriResRequest (String &uri)
-{
+ SBuf uri = r->url.path();
LOCAL_ARRAY(char, local_urlres, 4096);
- char *host = getHost (uri);
- snprintf(local_urlres, 4096, "http://%s/uri-res/N2L?urn:" SQUIDSTRINGPH,
- host, SQUIDSTRINGPRINT(uri));
+ char *host = getHost(uri);
+ snprintf(local_urlres, 4096, "http://%s/uri-res/N2L?urn:" SQUIDSBUFPH, host, SQUIDSBUFPRINT(uri));
safe_free(host);
safe_free(urlres);
urlres = xstrdup(local_urlres);
urlres_r = HttpRequest::CreateFromUrl(urlres);
-}
-
-void
-UrnState::setUriResFromRequest(HttpRequest *r)
-{
- if (RequestNeedsMenu(r)) {
- updateRequestURL(r, r->urlpath.rawBuf() + 5, r->urlpath.size() - 5 );
- flags.force_menu = true;
- }
-
- createUriResRequest (r->urlpath);
if (urlres_r == NULL) {
debugs(52, 3, "urnStart: Bad uri-res URL " << urlres);
void
whoisStart(FwdState * fwd)
{
- char *buf;
- size_t l;
WhoisState *p = new WhoisState;
p->request = fwd->request;
p->entry = fwd->entry;
p->entry->lock("whoisStart");
comm_add_close_handler(fwd->serverConnection()->fd, whoisClose, p);
- l = p->request->urlpath.size() + 3;
+ size_t l = p->request->url.path().length() + 3;
+ char *buf = (char *)xmalloc(l);
- buf = (char *)xmalloc(l);
-
- String str_print=p->request->urlpath.substr(1,p->request->urlpath.size());
- snprintf(buf, l, SQUIDSTRINGPH"\r\n", SQUIDSTRINGPRINT(str_print));
+ const SBuf str_print = p->request->url.path().substr(1);
+ snprintf(buf, l, SQUIDSBUFPH "\r\n", SQUIDSBUFPRINT(str_print));
AsyncCall::Pointer writeCall = commCbCall(5,5, "whoisWriteComplete",
CommIoCbPtrFun(whoisWriteComplete, p));
projects / thirdparty / squid.git / commitdiff
