5 * DEBUG: section 85 Client-side Request Routines
6 * AUTHOR: Robert Collins (Originally Duane Wessels in client_side.c)
8 * SQUID Web Proxy Cache http://www.squid-cache.org/
9 * ----------------------------------------------------------
11 * Squid is the result of efforts by numerous individuals from
12 * the Internet community; see the CONTRIBUTORS file for full
13 * details. Many organizations have provided support for Squid's
14 * development; see the SPONSORS file for full details. Squid is
15 * Copyrighted (C) 2001 by the Regents of the University of
16 * California; see the COPYRIGHT file for full details. Squid
17 * incorporates software developed and/or copyrighted by other
18 * sources; see the CREDITS file for full details.
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU General Public License as published by
22 * the Free Software Foundation; either version 2 of the License, or
23 * (at your option) any later version.
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
30 * You should have received a copy of the GNU General Public License
31 * along with this program; if not, write to the Free Software
32 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
38 * General logic of request processing:
40 * We run a series of tests to determine if access will be permitted, and to do
41 * any redirection. Then we call into the result clientStream to retrieve data.
42 * From that point on it's up to reply management.
46 #include "acl/FilledChecklist.h"
47 #include "acl/Gadgets.h"
49 #include "adaptation/AccessCheck.h"
50 #include "adaptation/Iterator.h"
51 #include "adaptation/Service.h"
53 #include "adaptation/icap/History.h"
56 #include "auth/UserRequest.h"
57 #include "clientStream.h"
58 #include "client_side.h"
59 #include "client_side_reply.h"
60 #include "client_side_request.h"
61 #include "ClientRequestContext.h"
62 #include "comm/Connection.h"
63 #include "compat/inet_pton.h"
65 #include "HttpReply.h"
66 #include "HttpRequest.h"
67 #include "ip/QosConfig.h"
68 #include "MemObject.h"
69 #include "ProtoPort.h"
71 #include "SquidTime.h"
76 #define comm_close comm_lingering_close
79 static const char *const crlf
= "\r\n";
81 #if FOLLOW_X_FORWARDED_FOR
83 clientFollowXForwardedForCheck(int answer
, void *data
);
84 #endif /* FOLLOW_X_FORWARDED_FOR */
86 CBDATA_CLASS_INIT(ClientRequestContext
);
89 ClientRequestContext::operator new (size_t size
)
91 assert (size
== sizeof(ClientRequestContext
));
92 CBDATA_INIT_TYPE(ClientRequestContext
);
93 ClientRequestContext
*result
= cbdataAlloc(ClientRequestContext
);
98 ClientRequestContext::operator delete (void *address
)
100 ClientRequestContext
*t
= static_cast<ClientRequestContext
*>(address
);
104 /* Local functions */
106 static void clientAccessCheckDoneWrapper(int, void *);
107 static int clientHierarchical(ClientHttpRequest
* http
);
108 static void clientInterpretRequestHeaders(ClientHttpRequest
* http
);
109 static RH clientRedirectDoneWrapper
;
110 static PF checkNoCacheDoneWrapper
;
111 extern "C" CSR clientGetMoreData
;
112 extern "C" CSS clientReplyStatus
;
113 extern "C" CSD clientReplyDetach
;
114 static void checkFailureRatio(err_type
, hier_code
);
116 ClientRequestContext::~ClientRequestContext()
119 * Release our "lock" on our parent, ClientHttpRequest, if we
124 cbdataReferenceDone(http
);
126 debugs(85,3, HERE
<< this << " ClientRequestContext destructed");
129 ClientRequestContext::ClientRequestContext(ClientHttpRequest
*anHttp
) : http(cbdataReference(anHttp
)), acl_checklist (NULL
), redirect_state (REDIRECT_NONE
)
131 http_access_done
= false;
132 redirect_done
= false;
133 no_cache_done
= false;
134 interpreted_req_hdrs
= false;
135 debugs(85,3, HERE
<< this << " ClientRequestContext constructed");
138 CBDATA_CLASS_INIT(ClientHttpRequest
);
141 ClientHttpRequest::operator new (size_t size
)
143 assert (size
== sizeof (ClientHttpRequest
));
144 CBDATA_INIT_TYPE(ClientHttpRequest
);
145 ClientHttpRequest
*result
= cbdataAlloc(ClientHttpRequest
);
150 ClientHttpRequest::operator delete (void *address
)
152 ClientHttpRequest
*t
= static_cast<ClientHttpRequest
*>(address
);
156 ClientHttpRequest::ClientHttpRequest(ConnStateData
* aConn
) :
158 AsyncJob("ClientHttpRequest"),
162 start_time
= current_time
;
164 clientConnection
= aConn
->clientConn
;
165 dlinkAdd(this, &active
, &ClientActiveRequests
);
167 request_satisfaction_mode
= false;
172 * returns true if client specified that the object must come from the cache
173 * without contacting origin server
176 ClientHttpRequest::onlyIfCached()const
179 return request
->cache_control
&&
180 EBIT_TEST(request
->cache_control
->mask
, CC_ONLY_IF_CACHED
);
184 * This function is designed to serve a fairly specific purpose.
185 * Occasionally our vBNS-connected caches can talk to each other, but not
186 * the rest of the world. Here we try to detect frequent failures which
187 * make the cache unusable (e.g. DNS lookup and connect() failures). If
188 * the failure:success ratio goes above 1.0 then we go into "hit only"
189 * mode where we only return UDP_HIT or UDP_MISS_NOFETCH. Neighbors
190 * will only fetch HITs from us if they are using the ICP protocol. We
191 * stay in this mode for 5 minutes.
193 * Duane W., Sept 16, 1996
196 #define FAILURE_MODE_TIME 300
199 checkFailureRatio(err_type etype
, hier_code hcode
)
201 static double magic_factor
= 100.0;
205 if (hcode
== HIER_NONE
)
208 n_good
= magic_factor
/ (1.0 + request_failure_ratio
);
210 n_bad
= magic_factor
- n_good
;
216 case ERR_CONNECT_FAIL
:
217 case ERR_SECURE_CONNECT_FAIL
:
227 request_failure_ratio
= n_bad
/ n_good
;
229 if (hit_only_mode_until
> squid_curtime
)
232 if (request_failure_ratio
< 1.0)
235 debugs(33, 0, "Failure Ratio at "<< std::setw(4)<<
236 std::setprecision(3) << request_failure_ratio
);
238 debugs(33, 0, "Going into hit-only-mode for " <<
239 FAILURE_MODE_TIME
/ 60 << " minutes...");
241 hit_only_mode_until
= squid_curtime
+ FAILURE_MODE_TIME
;
243 request_failure_ratio
= 0.8; /* reset to something less than 1.0 */
246 ClientHttpRequest::~ClientHttpRequest()
248 debugs(33, 3, "httpRequestFree: " << uri
);
249 PROF_start(httpRequestFree
);
251 // Even though freeResources() below may destroy the request,
252 // we no longer set request->body_pipe to NULL here
253 // because we did not initiate that pipe (ConnStateData did)
255 /* the ICP check here was erroneous
256 * - StoreEntry::releaseRequest was always called if entry was valid
258 assert(logType
< LOG_TYPE_MAX
);
265 checkFailureRatio(request
->errType
, al
.hier
.code
);
270 announceInitiatorAbort(virginHeadSource
);
272 if (adaptedBodySource
!= NULL
)
273 stopConsumingFrom(adaptedBodySource
);
277 delete calloutContext
;
279 clientConnection
= NULL
;
282 cbdataReferenceDone(conn_
);
284 /* moving to the next connection is handled by the context free */
285 dlinkDelete(&active
, &ClientActiveRequests
);
287 PROF_stop(httpRequestFree
);
291 * Create a request and kick it off
296 * TODO: Pass in the buffers to be used in the inital Read request, as they are
297 * determined by the user
300 clientBeginRequest(const HttpRequestMethod
& method
, char const *url
, CSCB
* streamcallback
,
301 CSD
* streamdetach
, ClientStreamData streamdata
, HttpHeader
const *header
,
302 char *tailbuf
, size_t taillen
)
305 ClientHttpRequest
*http
= new ClientHttpRequest(NULL
);
306 HttpRequest
*request
;
307 StoreIOBuffer tempBuffer
;
308 http
->start_time
= current_time
;
309 /* this is only used to adjust the connection offset in client_side.c */
311 tempBuffer
.length
= taillen
;
312 tempBuffer
.data
= tailbuf
;
313 /* client stream setup */
314 clientStreamInit(&http
->client_stream
, clientGetMoreData
, clientReplyDetach
,
315 clientReplyStatus
, new clientReplyContext(http
), streamcallback
,
316 streamdetach
, streamdata
, tempBuffer
);
317 /* make it visible in the 'current acctive requests list' */
319 /* internal requests only makes sense in an
320 * accelerator today. TODO: accept flags ? */
321 http
->flags
.accel
= 1;
322 /* allow size for url rewriting */
323 url_sz
= strlen(url
) + Config
.appendDomainLen
+ 5;
324 http
->uri
= (char *)xcalloc(url_sz
, 1);
325 strcpy(http
->uri
, url
);
327 if ((request
= HttpRequest::CreateFromUrlAndMethod(http
->uri
, method
)) == NULL
) {
328 debugs(85, 5, "Invalid URL: " << http
->uri
);
333 * now update the headers in request with our supplied headers. urlParse
334 * should return a blank header set, but we use Update to be sure of
338 request
->header
.update(header
, NULL
);
340 http
->log_uri
= xstrdup(urlCanonicalClean(request
));
342 /* http struct now ready */
345 * build new header list *? TODO
347 request
->flags
.accelerated
= http
->flags
.accel
;
349 request
->flags
.internalclient
= 1;
351 /* this is an internally created
352 * request, not subject to acceleration
353 * target overrides */
355 * FIXME? Do we want to detect and handle internal requests of internal
359 /* Internally created requests cannot have bodies today */
360 request
->content_length
= 0;
362 request
->client_addr
.SetNoAddr();
364 #if FOLLOW_X_FORWARDED_FOR
365 request
->indirect_client_addr
.SetNoAddr();
366 #endif /* FOLLOW_X_FORWARDED_FOR */
368 request
->my_addr
.SetNoAddr(); /* undefined for internal requests */
370 request
->my_addr
.SetPort(0);
372 /* Our version is HTTP/1.1 */
373 HttpVersion
http_ver(1,1);
374 request
->http_ver
= http_ver
;
376 http
->request
= HTTPMSGLOCK(request
);
378 /* optional - skip the access check ? */
379 http
->calloutContext
= new ClientRequestContext(http
);
381 http
->calloutContext
->http_access_done
= false;
383 http
->calloutContext
->redirect_done
= true;
385 http
->calloutContext
->no_cache_done
= true;
393 ClientRequestContext::httpStateIsValid()
395 ClientHttpRequest
*http_
= http
;
397 if (cbdataReferenceValid(http_
))
402 cbdataReferenceDone(http_
);
407 #if FOLLOW_X_FORWARDED_FOR
409 * clientFollowXForwardedForCheck() checks the content of X-Forwarded-For:
410 * against the followXFF ACL, or cleans up and passes control to
411 * clientAccessCheck().
413 * The trust model here is a little ambiguous. So to clarify the logic:
414 * - we may always use the direct client address as the client IP.
415 * - these trust tests merey tell whether we trust given IP enough to believe the
416 * IP string which it appended to the X-Forwarded-For: header.
417 * - if at any point we don't trust what an IP adds we stop looking.
418 * - at that point the current contents of indirect_client_addr are the value set
419 * by the last previously trusted IP.
420 * ++ indirect_client_addr contains the remote direct client from the trusted peers viewpoint.
423 clientFollowXForwardedForCheck(int answer
, void *data
)
425 ClientRequestContext
*calloutContext
= (ClientRequestContext
*) data
;
427 if (!calloutContext
->httpStateIsValid())
430 ClientHttpRequest
*http
= calloutContext
->http
;
431 HttpRequest
*request
= http
->request
;
434 * answer should be be ACCESS_ALLOWED or ACCESS_DENIED if we are
435 * called as a result of ACL checks, or -1 if we are called when
436 * there's nothing left to do.
438 if (answer
== ACCESS_ALLOWED
&&
439 request
->x_forwarded_for_iterator
.size () != 0) {
442 * Remove the last comma-delimited element from the
443 * x_forwarded_for_iterator and use it to repeat the cycle.
446 const char *asciiaddr
;
449 p
= request
->x_forwarded_for_iterator
.termedBuf();
450 l
= request
->x_forwarded_for_iterator
.size();
453 * XXX x_forwarded_for_iterator should really be a list of
454 * IP addresses, but it's a String instead. We have to
455 * walk backwards through the String, biting off the last
456 * comma-delimited part each time. As long as the data is in
457 * a String, we should probably implement and use a variant of
458 * strListGetItem() that walks backwards instead of forwards
459 * through a comma-separated list. But we don't even do that;
460 * we just do the work in-line here.
462 /* skip trailing space and commas */
463 while (l
> 0 && (p
[l
-1] == ',' || xisspace(p
[l
-1])))
465 request
->x_forwarded_for_iterator
.cut(l
);
466 /* look for start of last item in list */
467 while (l
> 0 && ! (p
[l
-1] == ',' || xisspace(p
[l
-1])))
470 if ((addr
= asciiaddr
)) {
471 request
->indirect_client_addr
= addr
;
472 request
->x_forwarded_for_iterator
.cut(l
);
473 calloutContext
->acl_checklist
= clientAclChecklistCreate(Config
.accessList
.followXFF
, http
);
474 if (!Config
.onoff
.acl_uses_indirect_client
) {
475 /* override the default src_addr tested if we have to go deeper than one level into XFF */
476 Filled(calloutContext
->acl_checklist
)->src_addr
= request
->indirect_client_addr
;
478 calloutContext
->acl_checklist
->nonBlockingCheck(clientFollowXForwardedForCheck
, data
);
481 } /*if (answer == ACCESS_ALLOWED &&
482 request->x_forwarded_for_iterator.size () != 0)*/
484 /* clean up, and pass control to clientAccessCheck */
485 if (Config
.onoff
.log_uses_indirect_client
) {
487 * Ensure that the access log shows the indirect client
488 * instead of the direct client.
490 ConnStateData
*conn
= http
->getConn();
491 conn
->log_addr
= request
->indirect_client_addr
;
493 request
->x_forwarded_for_iterator
.clean();
494 request
->flags
.done_follow_x_forwarded_for
= 1;
496 if (answer
!= ACCESS_ALLOWED
&& answer
!= ACCESS_DENIED
) {
497 debugs(28, DBG_CRITICAL
, "ERROR: Processing X-Forwarded-For. Stopping at IP address: " << request
->indirect_client_addr
);
500 /* process actual access ACL as normal. */
501 calloutContext
->clientAccessCheck();
503 #endif /* FOLLOW_X_FORWARDED_FOR */
505 /* This is the entry point for external users of the client_side routines */
507 ClientRequestContext::clientAccessCheck()
509 #if FOLLOW_X_FORWARDED_FOR
510 if (!http
->request
->flags
.done_follow_x_forwarded_for
&&
511 Config
.accessList
.followXFF
&&
512 http
->request
->header
.has(HDR_X_FORWARDED_FOR
)) {
514 /* we always trust the direct client address for actual use */
515 http
->request
->indirect_client_addr
= http
->request
->client_addr
;
516 http
->request
->indirect_client_addr
.SetPort(0);
518 /* setup the XFF iterator for processing */
519 http
->request
->x_forwarded_for_iterator
= http
->request
->header
.getList(HDR_X_FORWARDED_FOR
);
521 /* begin by checking to see if we trust direct client enough to walk XFF */
522 acl_checklist
= clientAclChecklistCreate(Config
.accessList
.followXFF
, http
);
523 acl_checklist
->nonBlockingCheck(clientFollowXForwardedForCheck
, this);
526 #endif /* FOLLOW_X_FORWARDED_FOR */
528 if (Config
.accessList
.http
) {
529 acl_checklist
= clientAclChecklistCreate(Config
.accessList
.http
, http
);
530 acl_checklist
->nonBlockingCheck(clientAccessCheckDoneWrapper
, this);
532 debugs(0, DBG_CRITICAL
, "No http_access configuration found. This will block ALL traffic");
533 clientAccessCheckDone(ACCESS_DENIED
);
538 * Identical in operation to clientAccessCheck() but performed later using different configured ACL list.
539 * The default here is to allow all. Since the earlier http_access should do a default deny all.
540 * This check is just for a last-minute denial based on adapted request headers.
543 ClientRequestContext::clientAccessCheck2()
545 if (Config
.accessList
.adapted_http
) {
546 acl_checklist
= clientAclChecklistCreate(Config
.accessList
.adapted_http
, http
);
547 acl_checklist
->nonBlockingCheck(clientAccessCheckDoneWrapper
, this);
549 debugs(85, 2, HERE
<< "No adapted_http_access configuration. default: ALLOW");
550 clientAccessCheckDone(ACCESS_ALLOWED
);
555 clientAccessCheckDoneWrapper(int answer
, void *data
)
557 ClientRequestContext
*calloutContext
= (ClientRequestContext
*) data
;
559 if (!calloutContext
->httpStateIsValid())
562 calloutContext
->clientAccessCheckDone(answer
);
566 ClientRequestContext::clientAccessCheckDone(int answer
)
568 acl_checklist
= NULL
;
571 debugs(85, 2, "The request " <<
572 RequestMethodStr(http
->request
->method
) << " " <<
573 http
->uri
<< " is " <<
574 (answer
== ACCESS_ALLOWED
? "ALLOWED" : "DENIED") <<
575 ", because it matched '" <<
576 (AclMatchedName
? AclMatchedName
: "NO ACL's") << "'" );
577 char const *proxy_auth_msg
= "<null>";
579 if (http
->getConn() != NULL
&& http
->getConn()->auth_user_request
!= NULL
)
580 proxy_auth_msg
= http
->getConn()->auth_user_request
->denyMessage("<null>");
581 else if (http
->request
->auth_user_request
!= NULL
)
582 proxy_auth_msg
= http
->request
->auth_user_request
->denyMessage("<null>");
584 if (answer
!= ACCESS_ALLOWED
) {
586 int require_auth
= (answer
== ACCESS_REQ_PROXY_AUTH
|| aclIsProxyAuth(AclMatchedName
));
587 debugs(85, 5, "Access Denied: " << http
->uri
);
588 debugs(85, 5, "AclMatchedName = " << (AclMatchedName
? AclMatchedName
: "<null>"));
591 debugs(33, 5, "Proxy Auth Message = " << (proxy_auth_msg
? proxy_auth_msg
: "<null>"));
594 * NOTE: get page_id here, based on AclMatchedName because if
595 * USE_DELAY_POOLS is enabled, then AclMatchedName gets clobbered in
596 * the clientCreateStoreEntry() call just below. Pedro Ribeiro
599 page_id
= aclGetDenyInfoPage(&Config
.denyInfoList
, AclMatchedName
, answer
!= ACCESS_REQ_PROXY_AUTH
);
601 http
->logType
= LOG_TCP_DENIED
;
604 if (!http
->flags
.accel
) {
605 /* Proxy authorisation needed */
606 status
= HTTP_PROXY_AUTHENTICATION_REQUIRED
;
608 /* WWW authorisation needed */
609 status
= HTTP_UNAUTHORIZED
;
612 if (page_id
== ERR_NONE
)
613 page_id
= ERR_CACHE_ACCESS_DENIED
;
615 status
= HTTP_FORBIDDEN
;
617 if (page_id
== ERR_NONE
)
618 page_id
= ERR_ACCESS_DENIED
;
621 clientStreamNode
*node
= (clientStreamNode
*)http
->client_stream
.tail
->prev
->data
;
622 clientReplyContext
*repContext
= dynamic_cast<clientReplyContext
*>(node
->data
.getRaw());
624 Ip::Address tmpnoaddr
;
625 tmpnoaddr
.SetNoAddr();
626 repContext
->setReplyToError(page_id
, status
,
627 http
->request
->method
, NULL
,
628 http
->getConn() != NULL
? http
->getConn()->clientConn
->remote
: tmpnoaddr
,
631 http
->getConn() != NULL
&& http
->getConn()->auth_user_request
!= NULL
?
632 http
->getConn()->auth_user_request
: http
->request
->auth_user_request
);
634 node
= (clientStreamNode
*)http
->client_stream
.tail
->data
;
635 clientStreamRead(node
, http
, node
->readBuffer
);
639 /* ACCESS_ALLOWED continues here ... */
640 safe_free(http
->uri
);
642 http
->uri
= xstrdup(urlCanonical(http
->request
));
649 adaptationAclCheckDoneWrapper(Adaptation::ServiceGroupPointer g
, void *data
)
651 ClientRequestContext
*calloutContext
= (ClientRequestContext
*)data
;
653 if (!calloutContext
->httpStateIsValid())
656 calloutContext
->adaptationAclCheckDone(g
);
660 ClientRequestContext::adaptationAclCheckDone(Adaptation::ServiceGroupPointer g
)
662 debugs(93,3,HERE
<< this << " adaptationAclCheckDone called");
666 Adaptation::Icap::History::Pointer ih
= http
->request
->icapHistory();
668 if (http
->getConn() != NULL
) {
669 ih
->rfc931
= http
->getConn()->rfc931
;
671 assert(http
->getConn()->clientConn
!= NULL
);
672 ih
->ssluser
= sslGetUserEmail(fd_table
[http
->getConn()->clientConn
->fd
].ssl
);
675 ih
->log_uri
= http
->log_uri
;
676 ih
->req_sz
= http
->req_sz
;
681 debugs(85,3, HERE
<< "no adaptation needed");
686 http
->startAdaptation(g
);
692 clientRedirectAccessCheckDone(int answer
, void *data
)
694 ClientRequestContext
*context
= (ClientRequestContext
*)data
;
695 ClientHttpRequest
*http
= context
->http
;
696 context
->acl_checklist
= NULL
;
698 if (answer
== ACCESS_ALLOWED
)
699 redirectStart(http
, clientRedirectDoneWrapper
, context
);
701 context
->clientRedirectDone(NULL
);
705 ClientRequestContext::clientRedirectStart()
707 debugs(33, 5, "clientRedirectStart: '" << http
->uri
<< "'");
709 if (Config
.accessList
.redirector
) {
710 acl_checklist
= clientAclChecklistCreate(Config
.accessList
.redirector
, http
);
711 acl_checklist
->nonBlockingCheck(clientRedirectAccessCheckDone
, this);
713 redirectStart(http
, clientRedirectDoneWrapper
, this);
717 clientHierarchical(ClientHttpRequest
* http
)
719 const char *url
= http
->uri
;
720 HttpRequest
*request
= http
->request
;
721 HttpRequestMethod method
= request
->method
;
722 const wordlist
*p
= NULL
;
725 * IMS needs a private key, so we can use the hierarchy for IMS only if our
726 * neighbors support private keys
729 if (request
->flags
.ims
&& !neighbors_do_private_keys
)
733 * This is incorrect: authenticating requests can be sent via a hierarchy
734 * (they can even be cached if the correct headers are set on the reply)
736 if (request
->flags
.auth
)
739 if (method
== METHOD_TRACE
)
742 if (method
!= METHOD_GET
)
745 /* scan hierarchy_stoplist */
746 for (p
= Config
.hierarchy_stoplist
; p
; p
= p
->next
)
747 if (strstr(url
, p
->key
))
750 if (request
->flags
.loopdetect
)
753 if (request
->protocol
== PROTO_HTTP
)
754 return httpCachable(method
);
756 if (request
->protocol
== PROTO_GOPHER
)
757 return gopherCachable(request
);
759 if (request
->protocol
== PROTO_CACHEOBJ
)
767 clientCheckPinning(ClientHttpRequest
* http
)
769 HttpRequest
*request
= http
->request
;
770 HttpHeader
*req_hdr
= &request
->header
;
771 ConnStateData
*http_conn
= http
->getConn();
773 /* Internal requests such as those from ESI includes may be without
774 * a client connection
779 request
->flags
.connection_auth_disabled
= http_conn
->port
->connection_auth_disabled
;
780 if (!request
->flags
.connection_auth_disabled
) {
781 if (http_conn
->pinning
.fd
!= -1) {
782 if (http_conn
->pinning
.auth
) {
783 request
->flags
.connection_auth
= 1;
784 request
->flags
.auth
= 1;
786 request
->flags
.connection_proxy_auth
= 1;
788 request
->setPinnedConnection(http_conn
);
792 /* check if connection auth is used, and flag as candidate for pinning
794 * Note: we may need to set flags.connection_auth even if the connection
795 * is already pinned if it was pinned earlier due to proxy auth
797 if (!request
->flags
.connection_auth
) {
798 if (req_hdr
->has(HDR_AUTHORIZATION
) || req_hdr
->has(HDR_PROXY_AUTHORIZATION
)) {
799 HttpHeaderPos pos
= HttpHeaderInitPos
;
802 while ((e
= req_hdr
->getEntry(&pos
))) {
803 if (e
->id
== HDR_AUTHORIZATION
|| e
->id
== HDR_PROXY_AUTHORIZATION
) {
804 const char *value
= e
->value
.rawBuf();
805 if (strncasecmp(value
, "NTLM ", 5) == 0
807 strncasecmp(value
, "Negotiate ", 10) == 0
809 strncasecmp(value
, "Kerberos ", 9) == 0) {
810 if (e
->id
== HDR_AUTHORIZATION
) {
811 request
->flags
.connection_auth
= 1;
814 request
->flags
.connection_proxy_auth
= 1;
820 if (may_pin
&& !request
->pinnedConnection()) {
821 request
->setPinnedConnection(http
->getConn());
828 clientInterpretRequestHeaders(ClientHttpRequest
* http
)
830 HttpRequest
*request
= http
->request
;
831 HttpHeader
*req_hdr
= &request
->header
;
835 request
->imslen
= -1;
836 request
->ims
= req_hdr
->getTime(HDR_IF_MODIFIED_SINCE
);
838 if (request
->ims
> 0)
839 request
->flags
.ims
= 1;
841 if (!request
->flags
.ignore_cc
) {
842 if (req_hdr
->has(HDR_PRAGMA
)) {
843 String s
= req_hdr
->getList(HDR_PRAGMA
);
845 if (strListIsMember(&s
, "no-cache", ','))
851 if (request
->cache_control
)
852 if (EBIT_TEST(request
->cache_control
->mask
, CC_NO_CACHE
))
856 * Work around for supporting the Reload button in IE browsers when Squid
857 * is used as an accelerator or transparent proxy, by turning accelerated
858 * IMS request to no-cache requests. Now knows about IE 5.5 fix (is
859 * actually only fixed in SP1, but we can't tell whether we are talking to
860 * SP1 or not so all 5.5 versions are treated 'normally').
862 if (Config
.onoff
.ie_refresh
) {
863 if (http
->flags
.accel
&& request
->flags
.ims
) {
864 if ((str
= req_hdr
->getStr(HDR_USER_AGENT
))) {
865 if (strstr(str
, "MSIE 5.01") != NULL
)
867 else if (strstr(str
, "MSIE 5.0") != NULL
)
869 else if (strstr(str
, "MSIE 4.") != NULL
)
871 else if (strstr(str
, "MSIE 3.") != NULL
)
878 if (request
->method
== METHOD_OTHER
) {
883 #if USE_HTTP_VIOLATIONS
885 if (Config
.onoff
.reload_into_ims
)
886 request
->flags
.nocache_hack
= 1;
887 else if (refresh_nocache_hack
)
888 request
->flags
.nocache_hack
= 1;
892 request
->flags
.nocache
= 1;
895 /* ignore range header in non-GETs or non-HEADs */
896 if (request
->method
== METHOD_GET
|| request
->method
== METHOD_HEAD
) {
897 // XXX: initialize if we got here without HttpRequest::parseHeader()
899 request
->range
= req_hdr
->getRange();
901 if (request
->range
) {
902 request
->flags
.range
= 1;
903 clientStreamNode
*node
= (clientStreamNode
*)http
->client_stream
.tail
->data
;
904 /* XXX: This is suboptimal. We should give the stream the range set,
905 * and thereby let the top of the stream set the offset when the
906 * size becomes known. As it is, we will end up requesting from 0
907 * for evey -X range specification.
908 * RBC - this may be somewhat wrong. We should probably set the range
909 * iter up at this point.
911 node
->readBuffer
.offset
= request
->range
->lowestOffset(0);
912 http
->range_iter
.pos
= request
->range
->begin();
913 http
->range_iter
.valid
= true;
917 /* Only HEAD and GET requests permit a Range or Request-Range header.
918 * If these headers appear on any other type of request, delete them now.
921 req_hdr
->delById(HDR_RANGE
);
922 req_hdr
->delById(HDR_REQUEST_RANGE
);
923 delete request
->range
;
924 request
->range
= NULL
;
927 if (req_hdr
->has(HDR_AUTHORIZATION
))
928 request
->flags
.auth
= 1;
930 clientCheckPinning(http
);
932 if (request
->login
[0] != '\0')
933 request
->flags
.auth
= 1;
935 if (req_hdr
->has(HDR_VIA
)) {
936 String s
= req_hdr
->getList(HDR_VIA
);
938 * ThisCache cannot be a member of Via header, "1.0 ThisCache" can.
939 * Note ThisCache2 has a space prepended to the hostname so we don't
940 * accidentally match super-domains.
943 if (strListIsSubstr(&s
, ThisCache2
, ',')) {
944 debugObj(33, 1, "WARNING: Forwarding loop detected for:\n",
945 request
, (ObjPackMethod
) & httpRequestPack
);
946 request
->flags
.loopdetect
= 1;
950 fvdbCountVia(s
.termedBuf());
958 \todo --enable-useragent-log and --enable-referer-log. We should
959 probably drop those two as the custom log formats accomplish pretty much the same thing..
961 #if USE_USERAGENT_LOG
962 if ((str
= req_hdr
->getStr(HDR_USER_AGENT
)))
963 logUserAgent(fqdnFromAddr(http
->getConn()->log_addr
), str
);
968 if ((str
= req_hdr
->getStr(HDR_REFERER
)))
969 logReferer(fqdnFromAddr(http
->getConn()->log_addr
), str
, http
->log_uri
);
974 if (req_hdr
->has(HDR_X_FORWARDED_FOR
)) {
975 String s
= req_hdr
->getList(HDR_X_FORWARDED_FOR
);
976 fvdbCountForw(s
.termedBuf());
982 request
->flags
.cachable
= http
->request
->cacheable();
984 if (clientHierarchical(http
))
985 request
->flags
.hierarchical
= 1;
987 debugs(85, 5, "clientInterpretRequestHeaders: REQ_NOCACHE = " <<
988 (request
->flags
.nocache
? "SET" : "NOT SET"));
989 debugs(85, 5, "clientInterpretRequestHeaders: REQ_CACHABLE = " <<
990 (request
->flags
.cachable
? "SET" : "NOT SET"));
991 debugs(85, 5, "clientInterpretRequestHeaders: REQ_HIERARCHICAL = " <<
992 (request
->flags
.hierarchical
? "SET" : "NOT SET"));
997 clientRedirectDoneWrapper(void *data
, char *result
)
999 ClientRequestContext
*calloutContext
= (ClientRequestContext
*)data
;
1001 if (!calloutContext
->httpStateIsValid())
1004 calloutContext
->clientRedirectDone(result
);
1008 ClientRequestContext::clientRedirectDone(char *result
)
1010 HttpRequest
*new_request
= NULL
;
1011 HttpRequest
*old_request
= http
->request
;
1012 debugs(85, 5, "clientRedirectDone: '" << http
->uri
<< "' result=" << (result
? result
: "NULL"));
1013 assert(redirect_state
== REDIRECT_PENDING
);
1014 redirect_state
= REDIRECT_DONE
;
1017 http_status status
= (http_status
) atoi(result
);
1019 if (status
== HTTP_MOVED_PERMANENTLY
1020 || status
== HTTP_MOVED_TEMPORARILY
1021 || status
== HTTP_SEE_OTHER
1022 || status
== HTTP_TEMPORARY_REDIRECT
) {
1025 if ((t
= strchr(result
, ':')) != NULL
) {
1026 http
->redirect
.status
= status
;
1027 http
->redirect
.location
= xstrdup(t
+ 1);
1028 // TODO: validate the URL produced here is RFC 2616 compliant absolute URI
1030 if (old_request
->http_ver
< HttpVersion(1,1))
1031 debugs(85, DBG_CRITICAL
, "ERROR: URL-rewrite produces invalid 302 redirect Location: " << result
);
1033 debugs(85, DBG_CRITICAL
, "ERROR: URL-rewrite produces invalid 303 redirect Location: " << result
);
1035 } else if (strcmp(result
, http
->uri
)) {
1036 if (!(new_request
= HttpRequest::CreateFromUrlAndMethod(result
, old_request
->method
)))
1037 debugs(85, DBG_CRITICAL
, "ERROR: URL-rewrite produces invalid request: " <<
1038 old_request
->method
<< " " << result
<< " HTTP/1.1");
1043 safe_free(http
->uri
);
1044 http
->uri
= xstrdup(urlCanonical(new_request
));
1045 new_request
->http_ver
= old_request
->http_ver
;
1046 new_request
->header
.append(&old_request
->header
);
1047 new_request
->client_addr
= old_request
->client_addr
;
1048 #if FOLLOW_X_FORWARDED_FOR
1049 new_request
->indirect_client_addr
= old_request
->indirect_client_addr
;
1050 #endif /* FOLLOW_X_FORWARDED_FOR */
1051 new_request
->my_addr
= old_request
->my_addr
;
1052 new_request
->flags
= old_request
->flags
;
1053 new_request
->flags
.redirected
= 1;
1054 new_request
->auth_user_request
= old_request
->auth_user_request
;
1056 if (old_request
->body_pipe
!= NULL
) {
1057 new_request
->body_pipe
= old_request
->body_pipe
;
1058 old_request
->body_pipe
= NULL
;
1059 debugs(0,0,HERE
<< "redirecting body_pipe " << new_request
->body_pipe
<< " from request " << old_request
<< " to " << new_request
);
1062 new_request
->content_length
= old_request
->content_length
;
1063 new_request
->extacl_user
= old_request
->extacl_user
;
1064 new_request
->extacl_passwd
= old_request
->extacl_passwd
;
1065 new_request
->flags
.proxy_keepalive
= old_request
->flags
.proxy_keepalive
;
1066 HTTPMSGUNLOCK(old_request
);
1067 http
->request
= HTTPMSGLOCK(new_request
);
1070 /* FIXME PIPELINE: This is innacurate during pipelining */
1072 if (http
->getConn() != NULL
&& Comm::IsConnOpen(http
->getConn()->clientConn
))
1073 fd_note(http
->getConn()->clientConn
->fd
, http
->uri
);
1080 /** Test cache allow/deny configuration
1081 * Sets flags.cachable=1 if caching is not denied.
1084 ClientRequestContext::checkNoCache()
1086 if (Config
.accessList
.noCache
) {
1087 acl_checklist
= clientAclChecklistCreate(Config
.accessList
.noCache
, http
);
1088 acl_checklist
->nonBlockingCheck(checkNoCacheDoneWrapper
, this);
1090 /* unless otherwise specified, we try to cache. */
1091 checkNoCacheDone(1);
1096 checkNoCacheDoneWrapper(int answer
, void *data
)
1098 ClientRequestContext
*calloutContext
= (ClientRequestContext
*) data
;
1100 if (!calloutContext
->httpStateIsValid())
1103 calloutContext
->checkNoCacheDone(answer
);
1107 ClientRequestContext::checkNoCacheDone(int answer
)
1109 acl_checklist
= NULL
;
1110 http
->request
->flags
.cachable
= answer
;
1115 * Identify requests that do not go through the store and client side stream
1116 * and forward them to the appropriate location. All other requests, request
1120 ClientHttpRequest::processRequest()
1122 debugs(85, 4, "clientProcessRequest: " << RequestMethodStr(request
->method
) << " '" << uri
<< "'");
1125 if (request
->method
== METHOD_CONNECT
&& sslBumpNeeded()) {
1131 if (request
->method
== METHOD_CONNECT
&& !redirect
.status
) {
1132 logType
= LOG_TCP_MISS
;
1133 getConn()->stopReading(); // tunnels read for themselves
1134 tunnelStart(this, &out
.size
, &al
.http
.code
);
1142 ClientHttpRequest::httpStart()
1144 PROF_start(httpStart
);
1145 logType
= LOG_TAG_NONE
;
1146 debugs(85, 4, "ClientHttpRequest::httpStart: " << log_tags
[logType
] << " for '" << uri
<< "'");
1148 /* no one should have touched this */
1149 assert(out
.offset
== 0);
1150 /* Use the Stream Luke */
1151 clientStreamNode
*node
= (clientStreamNode
*)client_stream
.tail
->data
;
1152 clientStreamRead(node
, this, node
->readBuffer
);
1153 PROF_stop(httpStart
);
1158 // determines whether we should bump the CONNECT request
1160 ClientHttpRequest::sslBumpNeeded() const
1162 if (!getConn()->port
->sslBump
|| !Config
.accessList
.ssl_bump
)
1165 debugs(85, 5, HERE
<< "SslBump possible, checking ACL");
1167 ACLFilledChecklist
check(Config
.accessList
.ssl_bump
, request
, NULL
);
1168 check
.src_addr
= request
->client_addr
;
1169 check
.my_addr
= request
->my_addr
;
1170 return check
.fastCheck() == 1;
1173 // called when comm_write has completed
1175 SslBumpEstablish(const Comm::ConnectionPointer
&, char *, size_t, comm_err_t errflag
, int, void *data
)
1177 ClientHttpRequest
*r
= static_cast<ClientHttpRequest
*>(data
);
1178 debugs(85, 5, HERE
<< "responded to CONNECT: " << r
<< " ? " << errflag
);
1180 assert(r
&& cbdataReferenceValid(r
));
1181 r
->sslBumpEstablish(errflag
);
1185 ClientHttpRequest::sslBumpEstablish(comm_err_t errflag
)
1187 // Bail out quickly on COMM_ERR_CLOSING - close handlers will tidy up
1188 if (errflag
== COMM_ERR_CLOSING
)
1192 getConn()->startClosing("CONNECT response failure in SslBump");
1196 getConn()->switchToHttps();
1200 ClientHttpRequest::sslBumpStart()
1202 debugs(85, 5, HERE
<< "Confirming CONNECT tunnel on FD " << getConn()->clientConn
);
1203 // send an HTTP 200 response to kick client SSL negotiation
1204 debugs(33, 7, HERE
<< "Confirming CONNECT tunnel on FD " << getConn()->clientConn
);
1206 // TODO: Unify with tunnel.cc and add a Server(?) header
1207 static const char *const conn_established
= "HTTP/1.0 200 Connection established\r\n\r\n";
1208 comm_write(getConn()->clientConn
, conn_established
, strlen(conn_established
), &SslBumpEstablish
, this, NULL
);
1214 ClientHttpRequest::gotEnough() const
1216 /** TODO: should be querying the stream. */
1217 int64_t contentLength
=
1218 memObject()->getReply()->bodySize(request
->method
);
1219 assert(contentLength
>= 0);
1221 if (out
.offset
< contentLength
)
1228 ClientHttpRequest::storeEntry(StoreEntry
*newEntry
)
1234 ClientHttpRequest::loggingEntry(StoreEntry
*newEntry
)
1237 loggingEntry_
->unlock();
1239 loggingEntry_
= newEntry
;
1242 loggingEntry_
->lock();
1246 * doCallouts() - This function controls the order of "callout"
1247 * executions, including non-blocking access control checks, the
1248 * redirector, and ICAP. Previously, these callouts were chained
1249 * together such that "clientAccessCheckDone()" would call
1250 * "clientRedirectStart()" and so on.
1252 * The ClientRequestContext (aka calloutContext) class holds certain
1253 * state data for the callout/callback operations. Previously
1254 * ClientHttpRequest would sort of hand off control to ClientRequestContext
1255 * for a short time. ClientRequestContext would then delete itself
1256 * and pass control back to ClientHttpRequest when all callouts
1259 * This caused some problems for ICAP because we want to make the
1260 * ICAP callout after checking ACLs, but before checking the no_cache
1261 * list. We can't stuff the ICAP state into the ClientRequestContext
1262 * class because we still need the ICAP state after ClientRequestContext
1265 * Note that ClientRequestContext is created before the first call
1268 * If one of the callouts notices that ClientHttpRequest is no
1269 * longer valid, it should call cbdataReferenceDone() so that
1270 * ClientHttpRequest's reference count goes to zero and it will get
1271 * deleted. ClientHttpRequest will then delete ClientRequestContext.
1273 * Note that we set the _done flags here before actually starting
1274 * the callout. This is strictly for convenience.
1277 extern tos_t
aclMapTOS (acl_tos
* head
, ACLChecklist
* ch
);
1278 extern nfmark_t
aclMapNfmark (acl_nfmark
* head
, ACLChecklist
* ch
);
1281 ClientHttpRequest::doCallouts()
1283 assert(calloutContext
);
1285 /*Save the original request for logging purposes*/
1286 if (!calloutContext
->http
->al
.request
)
1287 calloutContext
->http
->al
.request
= HTTPMSGLOCK(request
);
1289 if (!calloutContext
->http_access_done
) {
1290 debugs(83, 3, HERE
<< "Doing calloutContext->clientAccessCheck()");
1291 calloutContext
->http_access_done
= true;
1292 calloutContext
->clientAccessCheck();
1297 if (!calloutContext
->adaptation_acl_check_done
) {
1298 calloutContext
->adaptation_acl_check_done
= true;
1299 if (Adaptation::AccessCheck::Start(
1300 Adaptation::methodReqmod
, Adaptation::pointPreCache
,
1301 request
, NULL
, adaptationAclCheckDoneWrapper
, calloutContext
))
1302 return; // will call callback
1306 if (!calloutContext
->redirect_done
) {
1307 calloutContext
->redirect_done
= true;
1308 assert(calloutContext
->redirect_state
== REDIRECT_NONE
);
1310 if (Config
.Program
.redirect
) {
1311 debugs(83, 3, HERE
<< "Doing calloutContext->clientRedirectStart()");
1312 calloutContext
->redirect_state
= REDIRECT_PENDING
;
1313 calloutContext
->clientRedirectStart();
1318 if (!calloutContext
->adapted_http_access_done
) {
1319 debugs(83, 3, HERE
<< "Doing calloutContext->clientAccessCheck2()");
1320 calloutContext
->adapted_http_access_done
= true;
1321 calloutContext
->clientAccessCheck2();
1325 if (!calloutContext
->interpreted_req_hdrs
) {
1326 debugs(83, 3, HERE
<< "Doing clientInterpretRequestHeaders()");
1327 calloutContext
->interpreted_req_hdrs
= 1;
1328 clientInterpretRequestHeaders(this);
1331 if (!calloutContext
->no_cache_done
) {
1332 calloutContext
->no_cache_done
= true;
1334 if (Config
.accessList
.noCache
&& request
->flags
.cachable
) {
1335 debugs(83, 3, HERE
<< "Doing calloutContext->checkNoCache()");
1336 calloutContext
->checkNoCache();
1341 if (!calloutContext
->tosToClientDone
) {
1342 calloutContext
->tosToClientDone
= true;
1343 if (getConn() != NULL
&& Comm::IsConnOpen(getConn()->clientConn
)) {
1344 ACLFilledChecklist
ch(NULL
, request
, NULL
);
1345 ch
.src_addr
= request
->client_addr
;
1346 ch
.my_addr
= request
->my_addr
;
1347 tos_t tos
= aclMapTOS(Ip::Qos::TheConfig
.tosToClient
, &ch
);
1349 Ip::Qos::setSockTos(getConn()->clientConn
, tos
);
1353 if (!calloutContext
->nfmarkToClientDone
) {
1354 calloutContext
->nfmarkToClientDone
= true;
1355 if (getConn() != NULL
&& Comm::IsConnOpen(getConn()->clientConn
)) {
1356 ACLFilledChecklist
ch(NULL
, request
, NULL
);
1357 ch
.src_addr
= request
->client_addr
;
1358 ch
.my_addr
= request
->my_addr
;
1359 nfmark_t mark
= aclMapNfmark(Ip::Qos::TheConfig
.nfmarkToClient
, &ch
);
1361 Ip::Qos::setSockNfmark(getConn()->clientConn
, mark
);
1365 cbdataReferenceDone(calloutContext
->http
);
1366 delete calloutContext
;
1367 calloutContext
= NULL
;
1370 headersLog(0, 1, request
->method
, request
);
1373 debugs(83, 3, HERE
<< "calling processRequest()");
1377 Adaptation::Icap::History::Pointer ih
= request
->icapHistory();
1379 ih
->logType
= logType
;
1384 #include "client_side_request.cci"
1388 /// Initiate an asynchronous adaptation transaction which will call us back.
1390 ClientHttpRequest::startAdaptation(const Adaptation::ServiceGroupPointer
&g
)
1392 debugs(85, 3, HERE
<< "adaptation needed for " << this);
1393 assert(!virginHeadSource
);
1394 assert(!adaptedBodySource
);
1395 virginHeadSource
= initiateAdaptation(
1396 new Adaptation::Iterator(request
, NULL
, g
));
1398 // we could try to guess whether we can bypass this adaptation
1399 // initiation failure, but it should not really happen
1400 Must(initiated(virginHeadSource
));
1404 ClientHttpRequest::noteAdaptationAnswer(HttpMsg
*msg
)
1406 assert(cbdataReferenceValid(this)); // indicates bug
1409 if (HttpRequest
*new_req
= dynamic_cast<HttpRequest
*>(msg
)) {
1411 * Replace the old request with the new request.
1413 HTTPMSGUNLOCK(request
);
1414 request
= HTTPMSGLOCK(new_req
);
1416 * Store the new URI for logging
1419 uri
= xstrdup(urlCanonical(request
));
1420 setLogUri(this, urlCanonicalClean(request
));
1421 assert(request
->method
.id());
1422 } else if (HttpReply
*new_rep
= dynamic_cast<HttpReply
*>(msg
)) {
1423 debugs(85,3,HERE
<< "REQMOD reply is HTTP reply");
1425 // subscribe to receive reply body
1426 if (new_rep
->body_pipe
!= NULL
) {
1427 adaptedBodySource
= new_rep
->body_pipe
;
1428 int consumer_ok
= adaptedBodySource
->setConsumerIfNotLate(this);
1429 assert(consumer_ok
);
1432 clientStreamNode
*node
= (clientStreamNode
*)client_stream
.tail
->prev
->data
;
1433 clientReplyContext
*repContext
= dynamic_cast<clientReplyContext
*>(node
->data
.getRaw());
1434 repContext
->createStoreEntry(request
->method
, request
->flags
);
1436 EBIT_CLR(storeEntry()->flags
, ENTRY_FWD_HDR_WAIT
);
1437 request_satisfaction_mode
= true;
1438 request_satisfaction_offset
= 0;
1439 storeEntry()->replaceHttpReply(new_rep
);
1440 storeEntry()->timestampsSet();
1442 if (!adaptedBodySource
) // no body
1443 storeEntry()->complete();
1444 clientGetMoreData(node
, this);
1447 // we are done with getting headers (but may be receiving body)
1448 clearAdaptation(virginHeadSource
);
1450 if (!request_satisfaction_mode
)
1455 ClientHttpRequest::noteAdaptationQueryAbort(bool final
)
1457 clearAdaptation(virginHeadSource
);
1458 assert(!adaptedBodySource
);
1459 handleAdaptationFailure(!final
);
1463 ClientHttpRequest::noteMoreBodyDataAvailable(BodyPipe::Pointer
)
1465 assert(request_satisfaction_mode
);
1466 assert(adaptedBodySource
!= NULL
);
1468 if (const size_t contentSize
= adaptedBodySource
->buf().contentSize()) {
1469 BodyPipeCheckout
bpc(*adaptedBodySource
);
1470 const StoreIOBuffer
ioBuf(&bpc
.buf
, request_satisfaction_offset
);
1471 storeEntry()->write(ioBuf
);
1472 // assume can write everything
1473 request_satisfaction_offset
+= contentSize
;
1474 bpc
.buf
.consume(contentSize
);
1478 if (adaptedBodySource
->exhausted())
1479 endRequestSatisfaction();
1480 // else wait for more body data
1484 ClientHttpRequest::noteBodyProductionEnded(BodyPipe::Pointer
)
1486 assert(!virginHeadSource
);
1487 if (adaptedBodySource
!= NULL
) { // did not end request satisfaction yet
1488 // We do not expect more because noteMoreBodyDataAvailable always
1489 // consumes everything. We do not even have a mechanism to consume
1490 // leftovers after noteMoreBodyDataAvailable notifications seize.
1491 assert(adaptedBodySource
->exhausted());
1492 endRequestSatisfaction();
1497 ClientHttpRequest::endRequestSatisfaction()
1499 debugs(85,4, HERE
<< this << " ends request satisfaction");
1500 assert(request_satisfaction_mode
);
1501 stopConsumingFrom(adaptedBodySource
);
1503 // TODO: anything else needed to end store entry formation correctly?
1504 storeEntry()->complete();
1508 ClientHttpRequest::noteBodyProducerAborted(BodyPipe::Pointer
)
1510 assert(!virginHeadSource
);
1511 stopConsumingFrom(adaptedBodySource
);
1512 handleAdaptationFailure();
1516 ClientHttpRequest::handleAdaptationFailure(bool bypassable
)
1518 debugs(85,3, HERE
<< "handleAdaptationFailure(" << bypassable
<< ")");
1520 const bool usedStore
= storeEntry() && !storeEntry()->isEmpty();
1521 const bool usedPipe
= request
->body_pipe
!= NULL
&&
1522 request
->body_pipe
->consumedSize() > 0;
1524 if (bypassable
&& !usedStore
&& !usedPipe
) {
1525 debugs(85,3, HERE
<< "ICAP REQMOD callout failed, bypassing: " << calloutContext
);
1531 debugs(85,3, HERE
<< "ICAP REQMOD callout failed, responding with error");
1533 clientStreamNode
*node
= (clientStreamNode
*)client_stream
.tail
->prev
->data
;
1534 clientReplyContext
*repContext
= dynamic_cast<clientReplyContext
*>(node
->data
.getRaw());
1537 // The original author of the code also wanted to pass an errno to
1538 // setReplyToError, but it seems unlikely that the errno reflects the
1539 // true cause of the error at this point, so I did not pass it.
1542 ConnStateData
* c
= getConn();
1543 repContext
->setReplyToError(ERR_ICAP_FAILURE
, HTTP_INTERNAL_SERVER_ERROR
,
1544 request
->method
, NULL
,
1545 (c
!= NULL
? c
->clientConn
->remote
: noAddr
), request
, NULL
,
1546 (c
!= NULL
&& c
->auth_user_request
!= NULL
?
1547 c
->auth_user_request
: request
->auth_user_request
));
1549 node
= (clientStreamNode
*)client_stream
.tail
->data
;
1550 clientStreamRead(node
, this, node
->readBuffer
);