-
/*
- * $Id$
- *
* DEBUG: section 61 Redirector
* AUTHOR: Duane Wessels
*
*/
#include "squid.h"
-#include "auth/UserRequest.h"
+#include "acl/Checklist.h"
+#include "client_side.h"
+#include "client_side_reply.h"
+#include "client_side_request.h"
#include "comm/Connection.h"
-#include "mgr/Registration.h"
-#include "Store.h"
#include "fde.h"
-#include "client_side_request.h"
-#include "acl/Checklist.h"
+#include "fqdncache.h"
+#include "format/Format.h"
+#include "globals.h"
#include "HttpRequest.h"
-#include "client_side.h"
-#include "helper.h"
+#include "mgr/Registration.h"
+#include "redirect.h"
#include "rfc1738.h"
+#include "SBuf.h"
+#include "SquidConfig.h"
+#include "Store.h"
+#if USE_AUTH
+#include "auth/UserRequest.h"
+#endif
+#if USE_SSL
+#include "ssl/support.h"
+#endif
+
+/// url maximum lengh + extra informations passed to redirector
+#define MAX_REDIRECTOR_REQUEST_STRLEN (MAX_URL + 1024)
+
+class RedirectStateData
+{
+public:
+ explicit RedirectStateData(const char *url);
+ ~RedirectStateData();
-typedef struct {
void *data;
- char *orig_url;
+ SBuf orig_url;
Ip::Address client_addr;
const char *client_ident;
const char *method_s;
- RH *handler;
-} redirectStateData;
+ HLPCB *handler;
+
+private:
+ CBDATA_CLASS2(RedirectStateData);
+};
static HLPCB redirectHandleReply;
-static void redirectStateFree(redirectStateData * r);
+static HLPCB storeIdHandleReply;
static helper *redirectors = NULL;
+static helper *storeIds = NULL;
static OBJH redirectStats;
-static int n_bypassed = 0;
-CBDATA_TYPE(redirectStateData);
-
-static void
-redirectHandleReply(void *data, char *reply)
+static OBJH storeIdStats;
+static int redirectorBypassed = 0;
+static int storeIdBypassed = 0;
+static Format::Format *redirectorExtrasFmt = NULL;
+static Format::Format *storeIdExtrasFmt = NULL;
+
+CBDATA_CLASS_INIT(RedirectStateData);
+
+RedirectStateData::RedirectStateData(const char *url) :
+ data(NULL),
+ orig_url(url),
+ client_addr(),
+ client_ident(NULL),
+ method_s(NULL),
+ handler(NULL)
{
- redirectStateData *r = static_cast<redirectStateData *>(data);
- char *t;
- void *cbdata;
- debugs(61, 5, "redirectHandleRead: {" << (reply && *reply != '\0' ? reply : "<NULL>") << "}");
+}
- if (reply) {
- if ((t = strchr(reply, ' ')))
- *t = '\0';
+RedirectStateData::~RedirectStateData()
+{
+}
- if (*reply == '\0')
- reply = NULL;
+static void
+redirectHandleReply(void *data, const HelperReply &reply)
+{
+ RedirectStateData *r = static_cast<RedirectStateData *>(data);
+ debugs(61, 5, HERE << "reply=" << reply);
+
+ // XXX: This function is now kept only to check for and display the garbage use-case
+ // and to map the old helper response format(s) into new format result code and key=value pairs
+ // it can be removed when the helpers are all updated to the normalized "OK/ERR kv-pairs" format
+
+ if (reply.result == HelperReply::Unknown) {
+ // BACKWARD COMPATIBILITY 2012-06-15:
+ // Some nasty old helpers send back the entire input line including extra format keys.
+ // This is especially bad for simple perl search-replace filter scripts.
+ //
+ // * trim all but the first word off the response.
+ // * warn once every 50 responses that this will stop being fixed-up soon.
+ //
+ if (const char * res = reply.other().content()) {
+ if (const char *t = strchr(res, ' ')) {
+ static int warn = 0;
+ debugs(61, (!(warn++%50)? DBG_CRITICAL:2), "UPGRADE WARNING: URL rewriter reponded with garbage '" << t <<
+ "'. Future Squid will treat this as part of the URL.");
+ const mb_size_t garbageLength = reply.other().contentSize() - (t-res);
+ reply.modifiableOther().truncate(garbageLength);
+ }
+ if (reply.other().hasContent() && *res == '\0')
+ reply.modifiableOther().clean(); // drop the whole buffer of garbage.
+
+ // if we still have anything in other() after all that
+ // parse it into status=, url= and rewrite-url= keys
+ if (reply.other().hasContent()) {
+ /* 2012-06-28: This cast is due to urlParse() truncating too-long URLs itself.
+ * At this point altering the helper buffer in that way is not harmful, but annoying.
+ * When Bug 1961 is resolved and urlParse has a const API, this needs to die.
+ */
+ const char * result = reply.other().content();
+ const Http::StatusCode status = static_cast<Http::StatusCode>(atoi(result));
+
+ HelperReply newReply;
+ // BACKWARD COMPATIBILITY 2012-06-15:
+ // We got HelperReply::Unknown reply result but new
+ // RedirectStateData handlers require HelperReply::Okay,
+ // else will drop the helper reply
+ newReply.result = HelperReply::Okay;
+ newReply.notes.append(&reply.notes);
+
+ if (status == Http::scMovedPermanently
+ || status == Http::scMovedTemporarily
+ || status == Http::scSeeOther
+ || status == Http::scPermanentRedirect
+ || status == Http::scTemporaryRedirect) {
+
+ if (const char *t = strchr(result, ':')) {
+ char statusBuf[4];
+ snprintf(statusBuf, sizeof(statusBuf),"%3u",status);
+ newReply.notes.add("status", statusBuf);
+ ++t;
+ // TODO: validate the URL produced here is RFC 2616 compliant URI
+ newReply.notes.add("url", t);
+ } else {
+ debugs(85, DBG_CRITICAL, "ERROR: URL-rewrite produces invalid " << status << " redirect Location: " << result);
+ }
+ } else {
+ // status code is not a redirect code (or does not exist)
+ // treat as a re-write URL request
+ // TODO: validate the URL produced here is RFC 2616 compliant URI
+ newReply.notes.add("rewrite-url", reply.other().content());
+ }
+
+ void *cbdata;
+ if (cbdataReferenceValidDone(r->data, &cbdata))
+ r->handler(cbdata, newReply);
+
+ delete r;
+ return;
+ }
+ }
}
+ void *cbdata;
if (cbdataReferenceValidDone(r->data, &cbdata))
r->handler(cbdata, reply);
- redirectStateFree(r);
+ delete r;
}
static void
-redirectStateFree(redirectStateData * r)
+storeIdHandleReply(void *data, const HelperReply &reply)
{
- safe_free(r->orig_url);
- cbdataFree(r);
+ RedirectStateData *r = static_cast<RedirectStateData *>(data);
+ debugs(61, 5,"StoreId helper: reply=" << reply);
+
+ // XXX: This function is now kept only to check for and display the garbage use-case
+ // and to map the old helper response format(s) into new format result code and key=value pairs
+ // it can be removed when the helpers are all updated to the normalized "OK/ERR kv-pairs" format
+ void *cbdata;
+ if (cbdataReferenceValidDone(r->data, &cbdata))
+ r->handler(cbdata, reply);
+
+ delete r;
}
static void
if (Config.onoff.redirector_bypass)
storeAppendPrintf(sentry, "\nNumber of requests bypassed "
- "because all redirectors were busy: %d\n", n_bypassed);
+ "because all redirectors were busy: %d\n", redirectorBypassed);
}
-/**** PUBLIC FUNCTIONS ****/
-
-void
-redirectStart(ClientHttpRequest * http, RH * handler, void *data)
+static void
+storeIdStats(StoreEntry * sentry)
{
- ConnStateData * conn = http->getConn();
- redirectStateData *r = NULL;
- const char *fqdn;
- char buf[8192];
- char claddr[MAX_IPSTRLEN];
- char myaddr[MAX_IPSTRLEN];
- assert(http);
- assert(handler);
- debugs(61, 5, "redirectStart: '" << http->uri << "'");
-
- if (Config.onoff.redirector_bypass && redirectors->stats.queue_size) {
- /* Skip redirector if there is one request queued */
- n_bypassed++;
- handler(data, NULL);
+ if (storeIds == NULL) {
+ storeAppendPrintf(sentry, "No StoreId helpers defined\n");
return;
}
- r = cbdataAlloc(redirectStateData);
- r->orig_url = xstrdup(http->uri);
+ helperStats(sentry, storeIds, "StoreId helper Statistics");
+
+ if (Config.onoff.store_id_bypass)
+ storeAppendPrintf(sentry, "\nNumber of requests bypassed "
+ "because all StoreId helpers were busy: %d\n", storeIdBypassed);
+}
+
+static void
+constructHelperQuery(const char *name, helper *hlp, HLPCB *replyHandler, ClientHttpRequest * http, HLPCB *handler, void *data, Format::Format *requestExtrasFmt)
+{
+ ConnStateData * conn = http->getConn();
+ const char *fqdn;
+ char buf[MAX_REDIRECTOR_REQUEST_STRLEN];
+ int sz;
+ Http::StatusCode status;
+
+ /** TODO: create a standalone method to initialize
+ * the RedirectStateData for all the helpers.
+ */
+ RedirectStateData *r = new RedirectStateData(http->uri);
if (conn != NULL)
r->client_addr = conn->log_addr;
else
- r->client_addr.SetNoAddr();
+ r->client_addr.setNoAddr();
r->client_ident = NULL;
-
- if (http->request->auth_user_request != NULL)
+#if USE_AUTH
+ if (http->request->auth_user_request != NULL) {
r->client_ident = http->request->auth_user_request->username();
- else if (http->request->extacl_user.defined()) {
+ debugs(61, 5, HERE << "auth-user=" << (r->client_ident?r->client_ident:"NULL"));
+ }
+#endif
+
+ if (!r->client_ident && http->request->extacl_user.size() > 0) {
r->client_ident = http->request->extacl_user.termedBuf();
+ debugs(61, 5, HERE << "acl-user=" << (r->client_ident?r->client_ident:"NULL"));
}
- if (!r->client_ident && (conn != NULL && conn->rfc931[0]))
- r->client_ident = conn->rfc931;
+ if (!r->client_ident && conn != NULL && conn->clientConnection != NULL && conn->clientConnection->rfc931[0]) {
+ r->client_ident = conn->clientConnection->rfc931;
+ debugs(61, 5, HERE << "ident-user=" << (r->client_ident?r->client_ident:"NULL"));
+ }
#if USE_SSL
- if (!r->client_ident && conn != NULL && Comm::IsConnOpen(conn->clientConn))
- r->client_ident = sslGetUserEmail(fd_table[conn->clientConn->fd].ssl);
-
+ if (!r->client_ident && conn != NULL && Comm::IsConnOpen(conn->clientConnection)) {
+ r->client_ident = sslGetUserEmail(fd_table[conn->clientConnection->fd].ssl);
+ debugs(61, 5, HERE << "ssl-user=" << (r->client_ident?r->client_ident:"NULL"));
+ }
#endif
if (!r->client_ident)
if ((fqdn = fqdncache_gethostbyaddr(r->client_addr, 0)) == NULL)
fqdn = dash_str;
- snprintf(buf, 8192, "%s %s/%s %s %s myip=%s myport=%d\n",
- r->orig_url,
- r->client_addr.NtoA(claddr,MAX_IPSTRLEN),
- fqdn,
- r->client_ident[0] ? rfc1738_escape(r->client_ident) : dash_str,
- r->method_s,
- http->request->my_addr.NtoA(myaddr,MAX_IPSTRLEN),
- http->request->my_addr.GetPort());
+ static MemBuf requestExtras;
+ requestExtras.reset();
+ if (requestExtrasFmt)
+ requestExtrasFmt->assemble(requestExtras, http->al, 0);
+
+ sz = snprintf(buf, MAX_REDIRECTOR_REQUEST_STRLEN, "%s%s%s\n",
+ r->orig_url.c_str(),
+ requestExtras.hasContent() ? " " : "",
+ requestExtras.hasContent() ? requestExtras.content() : "");
+
+ if ((sz<=0) || (sz>=MAX_REDIRECTOR_REQUEST_STRLEN)) {
+ if (sz<=0) {
+ status = Http::scInternalServerError;
+ debugs(61, DBG_CRITICAL, "ERROR: Gateway Failure. Can not build request to be passed to " << name << ". Request ABORTED.");
+ } else {
+ status = Http::scRequestUriTooLarge;
+ debugs(61, DBG_CRITICAL, "ERROR: Gateway Failure. Request passed to " << name << " exceeds MAX_REDIRECTOR_REQUEST_STRLEN (" << MAX_REDIRECTOR_REQUEST_STRLEN << "). Request ABORTED.");
+ }
+
+ clientStreamNode *node = (clientStreamNode *)http->client_stream.tail->prev->data;
+ clientReplyContext *repContext = dynamic_cast<clientReplyContext *>(node->data.getRaw());
+ assert (repContext);
+ Ip::Address tmpnoaddr;
+ tmpnoaddr.setNoAddr();
+ repContext->setReplyToError(ERR_GATEWAY_FAILURE, status,
+ http->request->method, NULL,
+ http->getConn() != NULL && http->getConn()->clientConnection != NULL ?
+ http->getConn()->clientConnection->remote : tmpnoaddr,
+ http->request,
+ NULL,
+#if USE_AUTH
+ http->getConn() != NULL && http->getConn()->getAuth() != NULL ?
+ http->getConn()->getAuth() : http->request->auth_user_request);
+#else
+ NULL);
+#endif
+
+ node = (clientStreamNode *)http->client_stream.tail->data;
+ clientStreamRead(node, http, node->readBuffer);
+ return;
+ }
- helperSubmit(redirectors, buf, redirectHandleReply, r);
+ debugs(61,6, HERE << "sending '" << buf << "' to the " << name << " helper");
+ helperSubmit(hlp, buf, replyHandler, r);
}
-static void
-redirectRegisterWithCacheManager(void)
+/**** PUBLIC FUNCTIONS ****/
+
+void
+redirectStart(ClientHttpRequest * http, HLPCB * handler, void *data)
{
- Mgr::RegisterAction("redirector", "URL Redirector Stats", redirectStats, 0, 1);
+ assert(http);
+ assert(handler);
+ debugs(61, 5, "redirectStart: '" << http->uri << "'");
+
+ if (Config.onoff.redirector_bypass && redirectors->stats.queue_size) {
+ /* Skip redirector if there is one request queued */
+ ++redirectorBypassed;
+ HelperReply bypassReply;
+ bypassReply.result = HelperReply::Okay;
+ bypassReply.notes.add("message","URL rewrite/redirect queue too long. Bypassed.");
+ handler(data, bypassReply);
+ return;
+ }
+
+ constructHelperQuery("redirector", redirectors, redirectHandleReply, http, handler, data, redirectorExtrasFmt);
}
+/**
+ * Handles the StoreID feature helper starting.
+ * For now it cannot be done using the redirectStart method.
+ */
void
-redirectInit(void)
+storeIdStart(ClientHttpRequest * http, HLPCB * handler, void *data)
{
- static int init = 0;
+ assert(http);
+ assert(handler);
+ debugs(61, 5, "storeIdStart: '" << http->uri << "'");
+
+ if (Config.onoff.store_id_bypass && storeIds->stats.queue_size) {
+ /* Skip StoreID Helper if there is one request queued */
+ ++storeIdBypassed;
+ HelperReply bypassReply;
- redirectRegisterWithCacheManager();
+ bypassReply.result = HelperReply::Okay;
- if (!Config.Program.redirect)
+ bypassReply.notes.add("message","StoreId helper queue too long. Bypassed.");
+ handler(data, bypassReply);
return;
+ }
+
+ constructHelperQuery("storeId helper", storeIds, storeIdHandleReply, http, handler, data, storeIdExtrasFmt);
+}
+
+void
+redirectInit(void)
+{
+ static bool init = false;
- if (redirectors == NULL)
- redirectors = new helper("redirector");
+ if (!init) {
+ Mgr::RegisterAction("redirector", "URL Redirector Stats", redirectStats, 0, 1);
+ Mgr::RegisterAction("store_id", "StoreId helper Stats", storeIdStats, 0, 1);
+ }
- redirectors->cmdline = Config.Program.redirect;
+ if (Config.Program.redirect) {
- redirectors->childs = Config.redirectChildren;
+ if (redirectors == NULL)
+ redirectors = new helper("redirector");
- redirectors->ipc_type = IPC_STREAM;
+ redirectors->cmdline = Config.Program.redirect;
- helperOpenServers(redirectors);
+ redirectors->childs.updateLimits(Config.redirectChildren);
- if (!init) {
- init = 1;
- CBDATA_INIT_TYPE(redirectStateData);
+ redirectors->ipc_type = IPC_STREAM;
+
+ helperOpenServers(redirectors);
}
+
+ if (Config.Program.store_id) {
+
+ if (storeIds == NULL)
+ storeIds = new helper("store_id");
+
+ storeIds->cmdline = Config.Program.store_id;
+
+ storeIds->childs.updateLimits(Config.storeIdChildren);
+
+ storeIds->ipc_type = IPC_STREAM;
+
+ helperOpenServers(storeIds);
+ }
+
+ if (Config.redirector_extras) {
+ redirectorExtrasFmt = new ::Format::Format("url_rewrite_extras");
+ (void)redirectorExtrasFmt->parse(Config.redirector_extras);
+ }
+
+ if (Config.storeId_extras) {
+ storeIdExtrasFmt = new ::Format::Format("store_id_extras");
+ (void)storeIdExtrasFmt->parse(Config.storeId_extras);
+ }
+
+ init = true;
}
void
redirectShutdown(void)
{
- if (!redirectors)
+ /** FIXME: Temporary unified helpers Shutdown
+ * When and if needed for more helpers a separated shutdown
+ * method will be added for each of them.
+ */
+ if (!storeIds && !redirectors)
return;
- helperShutdown(redirectors);
+ if (redirectors)
+ helperShutdown(redirectors);
+
+ if (storeIds)
+ helperShutdown(storeIds);
if (!shutting_down)
return;
delete redirectors;
redirectors = NULL;
+
+ delete storeIds;
+ storeIds = NULL;
+
+ delete redirectorExtrasFmt;
+ redirectorExtrasFmt = NULL;
+
+ delete storeIdExtrasFmt;
+ storeIdExtrasFmt = NULL;
}
projects / thirdparty / squid.git / blobdiff