#include "adaptation/Initiator.h"
#include "auth/UserRequest.h"
#include "base/TextException.h"
+#include "base64.h"
#include "ChunkedCodingParser.h"
#include "comm.h"
#include "comm/Connection.h"
#include "HttpRequest.h"
#include "HttpReply.h"
#include "SquidTime.h"
+#include "err_detail_type.h"
// flow and terminology:
// HTTP| --> receive --> encode --> write --> |network
memset(this, 0, sizeof(*this));
}
-Adaptation::Icap::ModXact::ModXact(Adaptation::Initiator *anInitiator, HttpMsg *virginHeader,
+Adaptation::Icap::ModXact::ModXact(HttpMsg *virginHeader,
HttpRequest *virginCause, Adaptation::Icap::ServiceRep::Pointer &aService):
AsyncJob("Adaptation::Icap::ModXact"),
- Adaptation::Icap::Xaction("Adaptation::Icap::ModXact", anInitiator, aService),
+ Adaptation::Icap::Xaction("Adaptation::Icap::ModXact", aService),
virginConsumed(0),
bodyParser(NULL),
canStartBypass(false), // too early
// nothing to do because we are using temporary buffers
// parsing; TODO: do not set until we parse, see ICAPOptXact
- icapReply = HTTPMSGLOCK(new HttpReply);
+ icapReply = new HttpReply;
icapReply->protoPrefix = "ICAP/"; // TODO: make an IcapReply class?
debugs(93,7, HERE << "initialized." << status());
{
Must(!state.serviceWaiting);
debugs(93, 7, HERE << "will wait for the ICAP service" << status());
- state.serviceWaiting = true;
- AsyncCall::Pointer call = asyncCall(93,5, "Adaptation::Icap::ModXact::noteServiceReady",
- MemFun(this, &Adaptation::Icap::ModXact::noteServiceReady));
+ typedef NullaryMemFunT<ModXact> Dialer;
+ AsyncCall::Pointer call = JobCallback(93,5,
+ Dialer, this, Adaptation::Icap::ModXact::noteServiceReady);
service().callWhenReady(call);
+ state.serviceWaiting = true; // after callWhenReady() which may throw
}
void Adaptation::Icap::ModXact::noteServiceReady()
Must(state.writing == State::writingHeaders);
// determine next step
- if (preview.enabled())
- state.writing = preview.done() ? State::writingPaused : State::writingPreview;
- else if (virginBody.expected())
+ if (preview.enabled()) {
+ if (preview.done())
+ decideWritingAfterPreview("zero-size");
+ else
+ state.writing = State::writingPreview;
+ } else if (virginBody.expected()) {
state.writing = State::writingPrime;
- else {
+ } else {
stopWriting(true);
return;
}
// change state once preview is written
- if (preview.done()) {
- debugs(93, 7, HERE << "wrote entire Preview body" << status());
+ if (preview.done())
+ decideWritingAfterPreview("body");
+}
- if (preview.ieof())
- stopWriting(true);
- else
- state.writing = State::writingPaused;
- }
+/// determine state.writing after we wrote the entire preview
+void Adaptation::Icap::ModXact::decideWritingAfterPreview(const char *kind)
+{
+ if (preview.ieof()) // nothing more to write
+ stopWriting(true);
+ else if (state.parsing == State::psIcapHeader) // did not get a reply yet
+ state.writing = State::writingPaused; // wait for the ICAP server reply
+ else
+ stopWriting(true); // ICAP server reply implies no post-preview writing
+
+ debugs(93, 6, HERE << "decided on writing after " << kind << " preview" <<
+ status());
}
void Adaptation::Icap::ModXact::writePrimeBody()
void Adaptation::Icap::ModXact::callException(const std::exception &e)
{
if (!canStartBypass || isRetriable) {
+ if (!isRetriable) {
+ if (const TextException *te = dynamic_cast<const TextException *>(&e))
+ detailError(ERR_DETAIL_EXCEPTION_START + te->id());
+ else
+ detailError(ERR_DETAIL_EXCEPTION_OTHER);
+ }
Adaptation::Icap::Xaction::callException(e);
return;
}
debugs(93, 3, HERE << "bypassing " << inCall << " exception: " <<
e.what() << ' ' << status());
bypassFailure();
+ } catch (const TextException &bypassTe) {
+ detailError(ERR_DETAIL_EXCEPTION_START + bypassTe.id());
+ Adaptation::Icap::Xaction::callException(bypassTe);
} catch (const std::exception &bypassE) {
+ detailError(ERR_DETAIL_EXCEPTION_OTHER);
Adaptation::Icap::Xaction::callException(bypassE);
}
}
// allocate the adapted message and copy metainfo
Must(!adapted.header);
- HttpMsg *newHead = NULL;
- if (const HttpRequest *oldR = dynamic_cast<const HttpRequest*>(oldHead)) {
- HttpRequest *newR = new HttpRequest;
- newR->canonical = oldR->canonical ?
- xstrdup(oldR->canonical) : NULL; // parse() does not set it
- newHead = newR;
- } else if (dynamic_cast<const HttpReply*>(oldHead)) {
- HttpReply *newRep = new HttpReply;
- newHead = newRep;
- }
- Must(newHead);
- newHead->inheritProperties(oldHead);
+ {
+ HttpMsg::Pointer newHead;
+ if (const HttpRequest *oldR = dynamic_cast<const HttpRequest*>(oldHead)) {
+ HttpRequest::Pointer newR(new HttpRequest);
+ newR->canonical = oldR->canonical ?
+ xstrdup(oldR->canonical) : NULL; // parse() does not set it
+ newHead = newR;
+ } else if (dynamic_cast<const HttpReply*>(oldHead)) {
+ newHead = new HttpReply;
+ }
+ Must(newHead != NULL);
- adapted.setHeader(newHead);
+ newHead->inheritProperties(oldHead);
+
+ adapted.setHeader(newHead);
+ }
// parse the buffer back
http_status error = HTTP_STATUS_NONE;
- Must(newHead->parse(&httpBuf, true, &error));
+ Must(adapted.header->parse(&httpBuf, true, &error));
- Must(newHead->hdr_sz == httpBuf.contentSize()); // no leftovers
+ Must(adapted.header->hdr_sz == httpBuf.contentSize()); // no leftovers
httpBuf.clean();
debugs(93, 7, HERE << "cloned virgin message " << oldHead << " to " <<
- newHead);
+ adapted.header);
// setup adapted body pipe if needed
if (oldHead->body_pipe != NULL) {
// adapted body consumer aborted
void Adaptation::Icap::ModXact::noteBodyConsumerAborted(BodyPipe::Pointer)
{
+ detailError(ERR_DETAIL_ICAP_XACT_BODY_CONSUMER_ABORT);
mustStop("adapted body consumer aborted");
}
+Adaptation::Icap::ModXact::~ModXact()
+{
+ delete bodyParser;
+}
+
// internal cleanup
void Adaptation::Icap::ModXact::swanSong()
{
stopWriting(false);
stopSending(false);
+ if (theInitiator.set()) // we have not sent the answer to the initiator
+ detailError(ERR_DETAIL_ICAP_XACT_OTHER);
+
// update adaptation history if start was called and we reserved a slot
Adaptation::History::Pointer ah = virginRequest().adaptLogHistory();
if (ah != NULL && adaptHistoryId >= 0)
icapBuf.Printf("%s=%d, ", section, (int) httpBuf.contentSize());
// begin cloning
- HttpMsg *headClone = NULL;
+ HttpMsg::Pointer headClone;
if (const HttpRequest* old_request = dynamic_cast<const HttpRequest*>(head)) {
- HttpRequest* new_request = new HttpRequest;
- assert(old_request->canonical);
+ HttpRequest::Pointer new_request(new HttpRequest);
+ Must(old_request->canonical);
urlParse(old_request->method, old_request->canonical, new_request);
new_request->http_ver = old_request->http_ver;
headClone = new_request;
} else if (const HttpReply *old_reply = dynamic_cast<const HttpReply*>(head)) {
- HttpReply* new_reply = new HttpReply;
+ HttpReply::Pointer new_reply(new HttpReply);
new_reply->sline = old_reply->sline;
headClone = new_reply;
}
-
- Must(headClone);
+ Must(headClone != NULL);
headClone->inheritProperties(head);
HttpHeaderPos pos = HttpHeaderInitPos;
// pack polished HTTP header
packHead(httpBuf, headClone);
- delete headClone;
+ // headClone unlocks and, hence, deletes the message we packed
}
void Adaptation::Icap::ModXact::packHead(MemBuf &httpBuf, const HttpMsg *head)
return true;
}
+void Adaptation::Icap::ModXact::detailError(int errDetail)
+{
+ if (HttpRequest *request = virgin.cause ?
+ virgin.cause : dynamic_cast<HttpRequest*>(virgin.header)) {
+ request->detailError(ERR_ICAP_FAILURE, errDetail);
+ }
+}
/* Adaptation::Icap::ModXactLauncher */
-Adaptation::Icap::ModXactLauncher::ModXactLauncher(Adaptation::Initiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, Adaptation::ServicePointer aService):
+Adaptation::Icap::ModXactLauncher::ModXactLauncher(HttpMsg *virginHeader, HttpRequest *virginCause, Adaptation::ServicePointer aService):
AsyncJob("Adaptation::Icap::ModXactLauncher"),
- Adaptation::Icap::Launcher("Adaptation::Icap::ModXactLauncher", anInitiator, aService)
+ Adaptation::Icap::Launcher("Adaptation::Icap::ModXactLauncher", aService)
{
virgin.setHeader(virginHeader);
virgin.setCause(virginCause);
Adaptation::Icap::ServiceRep::Pointer s =
dynamic_cast<Adaptation::Icap::ServiceRep*>(theService.getRaw());
Must(s != NULL);
- return new Adaptation::Icap::ModXact(this, virgin.header, virgin.cause, s);
+ return new Adaptation::Icap::ModXact(virgin.header, virgin.cause, s);
}
void Adaptation::Icap::ModXactLauncher::swanSong()
projects / thirdparty / squid.git / blobdiff