src/http.cc

   1
   2 /*
   3  * $Id: http.cc,v 1.547 2008/02/12 23:55:26 rousskov Exp $
   4  *
   5  * DEBUG: section 11    Hypertext Transfer Protocol (HTTP)
   6  * AUTHOR: Harvest Derived
   7  *
   8  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   9  * ----------------------------------------------------------
  10  *
  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.
  19  *
  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.
  24  *
  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.
  29  *
  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.
  33  *
  34  */
  35
  36 /*
  37  * Anonymizing patch by lutz@as-node.jena.thur.de
  38  * have a look into http-anon.c to get more informations.
  39  */
  40
  41 #include "squid.h"
  42 #include "errorpage.h"
  43 #include "MemBuf.h"
  44 #include "http.h"
  45 #include "AuthUserRequest.h"
  46 #include "Store.h"
  47 #include "HttpReply.h"
  48 #include "HttpRequest.h"
  49 #include "MemObject.h"
  50 #include "HttpHdrContRange.h"
  51 #include "HttpHdrSc.h"
  52 #include "HttpHdrScTarget.h"
  53 #include "ACLChecklist.h"
  54 #include "fde.h"
  55 #if DELAY_POOLS
  56 #include "DelayPools.h"
  57 #endif
  58 #include "SquidTime.h"
  59 #include "TextException.h"
  60
  61 #define SQUID_ENTER_THROWING_CODE() try {
  62 #define SQUID_EXIT_THROWING_CODE(status) \
  63         status = true; \
  64     } \
  65     catch (const std::exception &e) { \
  66         debugs (11, 1, "Exception error:" << e.what()); \
  67         status = false; \
  68     }
  69
  70 CBDATA_CLASS_INIT(HttpStateData);
  71
  72 static const char *const crlf = "\r\n";
  73
  74 static void httpMaybeRemovePublic(StoreEntry *, http_status);
  75 static void copyOneHeaderFromClientsideRequestToUpstreamRequest(const HttpHeaderEntry *e, String strConnection, HttpRequest * request, HttpRequest * orig_request,
  76         HttpHeader * hdr_out, int we_do_ranges, http_state_flags);
  77
  78 HttpStateData::HttpStateData(FwdState *theFwdState) : AsyncJob("HttpStateData"), ServerStateData(theFwdState),
  79         lastChunk(0), header_bytes_read(0), reply_bytes_read(0), httpChunkDecoder(NULL)
  80 {
  81     debugs(11,5,HERE << "HttpStateData " << this << " created");
  82     ignoreCacheControl = false;
  83     surrogateNoStore = false;
  84     fd = fwd->server_fd;
  85     readBuf = new MemBuf;
  86     readBuf->init(4096, SQUID_TCP_SO_RCVBUF);
  87     orig_request = HTTPMSGLOCK(fwd->request);
  88
  89     if (fwd->servers)
  90         _peer = fwd->servers->_peer;         /* might be NULL */
  91
  92     if (_peer) {
  93         const char *url;
  94
  95         if (_peer->options.originserver)
  96             url = orig_request->urlpath.buf();
  97         else
  98             url = entry->url();
  99
 100         HttpRequest * proxy_req = new HttpRequest(orig_request->method,
 101                                   orig_request->protocol, url);
 102
 103         proxy_req->SetHost(_peer->host);
 104
 105         proxy_req->port = _peer->http_port;
 106
 107         proxy_req->flags = orig_request->flags;
 108
 109         proxy_req->lastmod = orig_request->lastmod;
 110
 111         proxy_req->flags.proxying = 1;
 112
 113         HTTPMSGUNLOCK(request);
 114
 115         request = HTTPMSGLOCK(proxy_req);
 116
 117         /*
 118          * This NEIGHBOR_PROXY_ONLY check probably shouldn't be here.
 119          * We might end up getting the object from somewhere else if,
 120          * for example, the request to this neighbor fails.
 121          */
 122         if (_peer->options.proxy_only)
 123             entry->releaseRequest();
 124
 125 #if DELAY_POOLS
 126
 127         entry->setNoDelay(_peer->options.no_delay);
 128
 129 #endif
 130     }
 131
 132     /*
 133      * register the handler to free HTTP state data when the FD closes
 134      */
 135     typedef CommCbMemFunT<HttpStateData, CommCloseCbParams> Dialer;
 136     closeHandler = asyncCall(9, 5, "httpStateData::httpStateConnClosed",
 137                                  Dialer(this,&HttpStateData::httpStateConnClosed));
 138     comm_add_close_handler(fd, closeHandler);
 139 }
 140
 141 HttpStateData::~HttpStateData()
 142 {
 143     /*
 144      * don't forget that ~ServerStateData() gets called automatically
 145      */
 146
 147     if (!readBuf->isNull())
 148         readBuf->clean();
 149
 150     delete readBuf;
 151
 152     if(httpChunkDecoder)
 153         delete httpChunkDecoder;
 154
 155     HTTPMSGUNLOCK(orig_request);
 156
 157     debugs(11,5, HERE << "HttpStateData " << this << " destroyed; FD " << fd);
 158 }
 159
 160 int
 161 HttpStateData::dataDescriptor() const
 162 {
 163     return fd;
 164 }
 165 /*
 166 static void
 167 httpStateFree(int fd, void *data)
 168 {
 169     HttpStateData *httpState = static_cast<HttpStateData *>(data);
 170     debugs(11, 5, "httpStateFree: FD " << fd << ", httpState=" << data);
 171     delete httpState;
 172 }*/
 173
 174 void
 175 HttpStateData::httpStateConnClosed(const CommCloseCbParams &params)
 176 {
 177     debugs(11, 5, "httpStateFree: FD " << params.fd << ", httpState=" << params.data);
 178     deleteThis("HttpStateData::httpStateConnClosed");
 179 }
 180
 181 int
 182 httpCachable(const HttpRequestMethod& method)
 183 {
 184     /* GET and HEAD are cachable. Others are not. */
 185
 186         // TODO: replase to HttpRequestMethod::isCachable() ?
 187     if (method != METHOD_GET && method != METHOD_HEAD)
 188         return 0;
 189
 190     /* else cachable */
 191     return 1;
 192 }
 193
 194 void
 195 HttpStateData::httpTimeout(const CommTimeoutCbParams &params)
 196 {
 197     debugs(11, 4, "httpTimeout: FD " << fd << ": '" << entry->url() << "'" );
 198
 199     if (entry->store_status == STORE_PENDING) {
 200         fwd->fail(errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT, fwd->request));
 201     }
 202
 203     comm_close(fd);
 204 }
 205
 206 static void
 207 httpMaybeRemovePublic(StoreEntry * e, http_status status)
 208 {
 209     int remove = 0;
 210     int forbidden = 0;
 211     StoreEntry *pe;
 212
 213     if (!EBIT_TEST(e->flags, KEY_PRIVATE))
 214         return;
 215
 216     switch (status) {
 217
 218     case HTTP_OK:
 219
 220     case HTTP_NON_AUTHORITATIVE_INFORMATION:
 221
 222     case HTTP_MULTIPLE_CHOICES:
 223
 224     case HTTP_MOVED_PERMANENTLY:
 225
 226     case HTTP_MOVED_TEMPORARILY:
 227
 228     case HTTP_GONE:
 229
 230     case HTTP_NOT_FOUND:
 231         remove = 1;
 232
 233         break;
 234
 235     case HTTP_FORBIDDEN:
 236
 237     case HTTP_METHOD_NOT_ALLOWED:
 238         forbidden = 1;
 239
 240         break;
 241
 242 #if WORK_IN_PROGRESS
 243
 244     case HTTP_UNAUTHORIZED:
 245         forbidden = 1;
 246
 247         break;
 248
 249 #endif
 250
 251     default:
 252 #if QUESTIONABLE
 253         /*
 254          * Any 2xx response should eject previously cached entities...
 255          */
 256
 257         if (status >= 200 && status < 300)
 258             remove = 1;
 259
 260 #endif
 261
 262         break;
 263     }
 264
 265     if (!remove && !forbidden)
 266         return;
 267
 268     assert(e->mem_obj);
 269
 270     if (e->mem_obj->request)
 271         pe = storeGetPublicByRequest(e->mem_obj->request);
 272     else
 273         pe = storeGetPublic(e->mem_obj->url, e->mem_obj->method);
 274
 275     if (pe != NULL) {
 276         assert(e != pe);
 277 #if USE_HTCP
 278         neighborsHtcpClear(e, NULL, e->mem_obj->request, e->mem_obj->method, HTCP_CLR_INVALIDATION);
 279 #endif
 280         pe->release();
 281     }
 282
 283     /** \par
 284      * Also remove any cached HEAD response in case the object has
 285      * changed.
 286      */
 287     if (e->mem_obj->request)
 288         pe = storeGetPublicByRequestMethod(e->mem_obj->request, METHOD_HEAD);
 289     else
 290         pe = storeGetPublic(e->mem_obj->url, METHOD_HEAD);
 291
 292     if (pe != NULL) {
 293         assert(e != pe);
 294 #if USE_HTCP
 295         neighborsHtcpClear(e, NULL, e->mem_obj->request, HttpRequestMethod(METHOD_HEAD), HTCP_CLR_INVALIDATION);
 296 #endif
 297         pe->release();
 298     }
 299 }
 300
 301 void
 302 HttpStateData::processSurrogateControl(HttpReply *reply)
 303 {
 304 #if USE_SQUID_ESI
 305
 306     if (request->flags.accelerated && reply->surrogate_control) {
 307         HttpHdrScTarget *sctusable =
 308             httpHdrScGetMergedTarget(reply->surrogate_control,
 309                                      Config.Accel.surrogate_id);
 310
 311         if (sctusable) {
 312             if (EBIT_TEST(sctusable->mask, SC_NO_STORE) ||
 313                     (Config.onoff.surrogate_is_remote
 314                      && EBIT_TEST(sctusable->mask, SC_NO_STORE_REMOTE))) {
 315                 surrogateNoStore = true;
 316                 entry->makePrivate();
 317             }
 318
 319             /* The HttpHeader logic cannot tell if the header it's parsing is a reply to an
 320              * accelerated request or not...
 321              * Still, this is an abtraction breach. - RC
 322              */
 323             if (sctusable->max_age != -1) {
 324                 if (sctusable->max_age < sctusable->max_stale)
 325                     reply->expires = reply->date + sctusable->max_age;
 326                 else
 327                     reply->expires = reply->date + sctusable->max_stale;
 328
 329                 /* And update the timestamps */
 330                 entry->timestampsSet();
 331             }
 332
 333             /* We ignore cache-control directives as per the Surrogate specification */
 334             ignoreCacheControl = true;
 335
 336             httpHdrScTargetDestroy(sctusable);
 337         }
 338     }
 339
 340 #endif
 341 }
 342
 343 int
 344 HttpStateData::cacheableReply()
 345 {
 346     HttpReply const *rep = finalReply();
 347     HttpHeader const *hdr = &rep->header;
 348     const int cc_mask = (rep->cache_control) ? rep->cache_control->mask : 0;
 349     const char *v;
 350 #if HTTP_VIOLATIONS
 351
 352     const refresh_t *R = NULL;
 353
 354     /* This strange looking define first looks up the refresh pattern
 355      * and then checks if the specified flag is set. The main purpose
 356      * of this is to simplify the refresh pattern lookup and HTTP_VIOLATIONS
 357      * condition
 358      */
 359 #define REFRESH_OVERRIDE(flag) \
 360     ((R = (R ? R : refreshLimits(entry->mem_obj->url))) , \
 361     (R && R->flags.flag))
 362 #else
 363 #define REFRESH_OVERRIDE(flag) 0
 364 #endif
 365
 366     if (surrogateNoStore)
 367         return 0;
 368
 369     if (!ignoreCacheControl) {
 370         if (EBIT_TEST(cc_mask, CC_PRIVATE)) {
 371             if (!REFRESH_OVERRIDE(ignore_private))
 372                 return 0;
 373         }
 374
 375         if (EBIT_TEST(cc_mask, CC_NO_CACHE)) {
 376             if (!REFRESH_OVERRIDE(ignore_no_cache))
 377                 return 0;
 378         }
 379
 380         if (EBIT_TEST(cc_mask, CC_NO_STORE)) {
 381             if (!REFRESH_OVERRIDE(ignore_no_store))
 382                 return 0;
 383         }
 384     }
 385
 386     if (request->flags.auth || request->flags.auth_sent) {
 387         /*
 388          * Responses to requests with authorization may be cached
 389          * only if a Cache-Control: public reply header is present.
 390          * RFC 2068, sec 14.9.4
 391          */
 392
 393         if (!EBIT_TEST(cc_mask, CC_PUBLIC)) {
 394             if (!REFRESH_OVERRIDE(ignore_auth))
 395                 return 0;
 396         }
 397     }
 398
 399     /* Pragma: no-cache in _replies_ is not documented in HTTP,
 400      * but servers like "Active Imaging Webcast/2.0" sure do use it */
 401     if (hdr->has(HDR_PRAGMA)) {
 402         String s = hdr->getList(HDR_PRAGMA);
 403         const int no_cache = strListIsMember(&s, "no-cache", ',');
 404         s.clean();
 405
 406         if (no_cache) {
 407             if (!REFRESH_OVERRIDE(ignore_no_cache))
 408                 return 0;
 409         }
 410     }
 411
 412     /*
 413      * The "multipart/x-mixed-replace" content type is used for
 414      * continuous push replies.  These are generally dynamic and
 415      * probably should not be cachable
 416      */
 417     if ((v = hdr->getStr(HDR_CONTENT_TYPE)))
 418         if (!strncasecmp(v, "multipart/x-mixed-replace", 25))
 419             return 0;
 420
 421     switch (rep->sline.status) {
 422         /* Responses that are cacheable */
 423
 424     case HTTP_OK:
 425
 426     case HTTP_NON_AUTHORITATIVE_INFORMATION:
 427
 428     case HTTP_MULTIPLE_CHOICES:
 429
 430     case HTTP_MOVED_PERMANENTLY:
 431
 432     case HTTP_GONE:
 433         /*
 434          * Don't cache objects that need to be refreshed on next request,
 435          * unless we know how to refresh it.
 436          */
 437
 438         if (!refreshIsCachable(entry)) {
 439             debugs(22, 3, "refreshIsCachable() returned non-cacheable..");
 440             return 0;
 441         }
 442
 443         /* don't cache objects from peers w/o LMT, Date, or Expires */
 444         /* check that is it enough to check headers @?@ */
 445         if (rep->date > -1)
 446             return 1;
 447         else if (rep->last_modified > -1)
 448             return 1;
 449         else if (!_peer)
 450             return 1;
 451
 452         /* @?@ (here and 302): invalid expires header compiles to squid_curtime */
 453         else if (rep->expires > -1)
 454             return 1;
 455         else
 456             return 0;
 457
 458         /* NOTREACHED */
 459         break;
 460
 461         /* Responses that only are cacheable if the server says so */
 462
 463     case HTTP_MOVED_TEMPORARILY:
 464     case HTTP_TEMPORARY_REDIRECT:
 465         if (rep->expires > rep->date && rep->date > 0)
 466             return 1;
 467         else
 468             return 0;
 469
 470         /* NOTREACHED */
 471         break;
 472
 473         /* Errors can be negatively cached */
 474
 475     case HTTP_NO_CONTENT:
 476
 477     case HTTP_USE_PROXY:
 478
 479     case HTTP_BAD_REQUEST:
 480
 481     case HTTP_FORBIDDEN:
 482
 483     case HTTP_NOT_FOUND:
 484
 485     case HTTP_METHOD_NOT_ALLOWED:
 486
 487     case HTTP_REQUEST_URI_TOO_LARGE:
 488
 489     case HTTP_INTERNAL_SERVER_ERROR:
 490
 491     case HTTP_NOT_IMPLEMENTED:
 492
 493     case HTTP_BAD_GATEWAY:
 494
 495     case HTTP_SERVICE_UNAVAILABLE:
 496
 497     case HTTP_GATEWAY_TIMEOUT:
 498         return -1;
 499
 500         /* NOTREACHED */
 501         break;
 502
 503         /* Some responses can never be cached */
 504
 505     case HTTP_PARTIAL_CONTENT:  /* Not yet supported */
 506
 507     case HTTP_SEE_OTHER:
 508
 509     case HTTP_NOT_MODIFIED:
 510
 511     case HTTP_UNAUTHORIZED:
 512
 513     case HTTP_PROXY_AUTHENTICATION_REQUIRED:
 514
 515     case HTTP_INVALID_HEADER:   /* Squid header parsing error */
 516
 517     case HTTP_HEADER_TOO_LARGE:
 518
 519     case HTTP_PAYMENT_REQUIRED:
 520     case HTTP_NOT_ACCEPTABLE:
 521     case HTTP_REQUEST_TIMEOUT:
 522     case HTTP_CONFLICT:
 523     case HTTP_LENGTH_REQUIRED:
 524     case HTTP_PRECONDITION_FAILED:
 525     case HTTP_REQUEST_ENTITY_TOO_LARGE:
 526     case HTTP_UNSUPPORTED_MEDIA_TYPE:
 527     case HTTP_UNPROCESSABLE_ENTITY:
 528     case HTTP_LOCKED:
 529     case HTTP_FAILED_DEPENDENCY:
 530     case HTTP_INSUFFICIENT_STORAGE:
 531     case HTTP_REQUESTED_RANGE_NOT_SATISFIABLE:
 532     case HTTP_EXPECTATION_FAILED:
 533
 534         return 0;
 535
 536     default:                    /* Unknown status code */
 537         debugs (11, 0, HERE << "HttpStateData::cacheableReply: unexpected http status code " << rep->sline.status);
 538
 539         return 0;
 540
 541         /* NOTREACHED */
 542         break;
 543     }
 544
 545     /* NOTREACHED */
 546 }
 547
 548 /*
 549  * For Vary, store the relevant request headers as
 550  * virtual headers in the reply
 551  * Returns false if the variance cannot be stored
 552  */
 553 const char *
 554 httpMakeVaryMark(HttpRequest * request, HttpReply const * reply)
 555 {
 556     String vary, hdr;
 557     const char *pos = NULL;
 558     const char *item;
 559     const char *value;
 560     int ilen;
 561     static String vstr;
 562
 563     vstr.clean();
 564     vary = reply->header.getList(HDR_VARY);
 565
 566     while (strListGetItem(&vary, ',', &item, &ilen, &pos)) {
 567         char *name = (char *)xmalloc(ilen + 1);
 568         xstrncpy(name, item, ilen + 1);
 569         Tolower(name);
 570
 571         if (strcmp(name, "*") == 0) {
 572             /* Can not handle "Vary: *" withtout ETag support */
 573             safe_free(name);
 574             vstr.clean();
 575             break;
 576         }
 577
 578         strListAdd(&vstr, name, ',');
 579         hdr = request->header.getByName(name);
 580         safe_free(name);
 581         value = hdr.buf();
 582
 583         if (value) {
 584             value = rfc1738_escape_part(value);
 585             vstr.append("=\"", 2);
 586             vstr.append(value);
 587             vstr.append("\"", 1);
 588         }
 589
 590         hdr.clean();
 591     }
 592
 593     vary.clean();
 594 #if X_ACCELERATOR_VARY
 595
 596     pos = NULL;
 597     vary = reply->header.getList(HDR_X_ACCELERATOR_VARY);
 598
 599     while (strListGetItem(&vary, ',', &item, &ilen, &pos)) {
 600         char *name = (char *)xmalloc(ilen + 1);
 601         xstrncpy(name, item, ilen + 1);
 602         Tolower(name);
 603         strListAdd(&vstr, name, ',');
 604         hdr = request->header.getByName(name);
 605         safe_free(name);
 606         value = hdr.buf();
 607
 608         if (value) {
 609             value = rfc1738_escape_part(value);
 610             vstr.append("=\"", 2);
 611             vstr.append(value);
 612             vstr.append("\"", 1);
 613         }
 614
 615         hdr.clean();
 616     }
 617
 618     vary.clean();
 619 #endif
 620
 621     debugs(11, 3, "httpMakeVaryMark: " << vstr.buf());
 622     return vstr.buf();
 623 }
 624
 625 void
 626 HttpStateData::keepaliveAccounting(HttpReply *reply)
 627 {
 628     if (flags.keepalive)
 629         if (_peer)
 630             _peer->stats.n_keepalives_sent++;
 631
 632     if (reply->keep_alive) {
 633         if (_peer)
 634             _peer->stats.n_keepalives_recv++;
 635
 636         if (Config.onoff.detect_broken_server_pconns && reply->bodySize(request->method) == -1) {
 637             debugs(11, 1, "keepaliveAccounting: Impossible keep-alive header from '" << entry->url() << "'" );
 638             // debugs(11, 2, "GOT HTTP REPLY HDR:\n---------\n" << readBuf->content() << "\n----------" );
 639             flags.keepalive_broken = 1;
 640         }
 641     }
 642 }
 643
 644 void
 645 HttpStateData::checkDateSkew(HttpReply *reply)
 646 {
 647     if (reply->date > -1 && !_peer) {
 648         int skew = abs((int)(reply->date - squid_curtime));
 649
 650         if (skew > 86400)
 651             debugs(11, 3, "" << request->GetHost() << "'s clock is skewed by " << skew << " seconds!");
 652     }
 653 }
 654
 655 /**
 656  * This creates the error page itself.. its likely
 657  * that the forward ported reply header max size patch
 658  * generates non http conformant error pages - in which
 659  * case the errors where should be 'BAD_GATEWAY' etc
 660  */
 661 void
 662 HttpStateData::processReplyHeader()
 663 {
 664     /** Creates a blank header. If this routine is made incremental, this will not do */
 665     Ctx ctx = ctx_enter(entry->mem_obj->url);
 666     debugs(11, 3, "processReplyHeader: key '" << entry->getMD5Text() << "'");
 667
 668     assert(!flags.headers_parsed);
 669
 670     http_status error = HTTP_STATUS_NONE;
 671
 672     HttpReply *newrep = new HttpReply;
 673     const bool parsed = newrep->parse(readBuf, eof, &error);
 674
 675     if(!parsed && readBuf->contentSize() > 5 && strncmp(readBuf->content(), "HTTP/", 5) != 0){
 676          MemBuf *mb;
 677          HttpReply *tmprep = new HttpReply;
 678          tmprep->sline.version = HttpVersion(1, 0);
 679          tmprep->sline.status = HTTP_OK;
 680          tmprep->header.putTime(HDR_DATE, squid_curtime);
 681          tmprep->header.putExt("X-Transformed-From", "HTTP/0.9");
 682          mb = tmprep->pack();
 683          newrep->parse(mb, eof, &error);
 684          delete tmprep;
 685     }
 686     else{
 687          if (!parsed && error > 0) { // unrecoverable parsing error
 688               debugs(11, 3, "processReplyHeader: Non-HTTP-compliant header: '" <<  readBuf->content() << "'");
 689               flags.headers_parsed = 1;
 690           newrep->sline.version = HttpVersion(1, 0);
 691           newrep->sline.status = error;
 692           HttpReply *vrep = setVirginReply(newrep);
 693           entry->replaceHttpReply(vrep);
 694               ctx_exit(ctx);
 695               return;
 696          }
 697
 698          if (!parsed) { // need more data
 699               assert(!error);
 700               assert(!eof);
 701               delete newrep;
 702               ctx_exit(ctx);
 703               return;
 704          }
 705
 706          debugs(11, 9, "GOT HTTP REPLY HDR:\n---------\n" << readBuf->content() << "\n----------");
 707
 708          header_bytes_read = headersEnd(readBuf->content(), readBuf->contentSize());
 709          readBuf->consume(header_bytes_read);
 710     }
 711
 712     flags.chunked = 0;
 713     if (newrep->header.hasListMember(HDR_TRANSFER_ENCODING, "chunked", ',')) {
 714          flags.chunked = 1;
 715          httpChunkDecoder = new ChunkedCodingParser;
 716     }
 717
 718     if(!peerSupportsConnectionPinning())
 719         orig_request->flags.connection_auth_disabled = 1;
 720
 721     HttpReply *vrep = setVirginReply(newrep);
 722     flags.headers_parsed = 1;
 723
 724     keepaliveAccounting(vrep);
 725
 726     checkDateSkew(vrep);
 727
 728     processSurrogateControl (vrep);
 729
 730     /** \todo IF the reply is a 1.0 reply, AND it has a Connection: Header
 731      * Parse the header and remove all referenced headers
 732      */
 733
 734     ctx_exit(ctx);
 735
 736 }
 737
 738 /**
 739  * returns true if the peer can support connection pinning
 740 */
 741 bool HttpStateData::peerSupportsConnectionPinning() const
 742 {
 743     const HttpReply *rep = entry->mem_obj->getReply();
 744     const HttpHeader *hdr = &rep->header;
 745     bool rc;
 746     String header;
 747
 748     if (!_peer)
 749         return true;
 750
 751     /*If this peer does not support connection pinning (authenticated
 752       connections) return false
 753      */
 754     if (!_peer->connection_auth)
 755         return false;
 756
 757     /*The peer supports connection pinning and the http reply status
 758       is not unauthorized, so the related connection can be pinned
 759      */
 760     if (rep->sline.status != HTTP_UNAUTHORIZED)
 761         return true;
 762
 763     /*The server respond with HTTP_UNAUTHORIZED and the peer configured
 764       with "connection-auth=on" we know that the peer supports pinned
 765       connections
 766     */
 767     if (_peer->connection_auth == 1)
 768         return true;
 769
 770     /*At this point peer has configured with "connection-auth=auto"
 771       parameter so we need some extra checks to decide if we are going
 772       to allow pinned connections or not
 773     */
 774
 775     /*if the peer configured with originserver just allow connection
 776         pinning (squid 2.6 behaviour)
 777      */
 778     if (_peer->options.originserver)
 779         return true;
 780
 781     /*if the connections it is already pinned it is OK*/
 782     if (request->flags.pinned)
 783         return true;
 784
 785     /*Allow pinned connections only if the Proxy-support header exists in
 786       reply and has in its list the "Session-Based-Authentication"
 787       which means that the peer supports connection pinning.
 788      */
 789     if (!hdr->has(HDR_PROXY_SUPPORT))
 790         return false;
 791
 792     header = hdr->getStrOrList(HDR_PROXY_SUPPORT);
 793     /* XXX This ought to be done in a case-insensitive manner */
 794     rc = (strstr(header.buf(), "Session-Based-Authentication") != NULL);
 795
 796     return rc;
 797 }
 798
 799 // Called when we parsed (and possibly adapted) the headers but
 800 // had not starting storing (a.k.a., sending) the body yet.
 801 void
 802 HttpStateData::haveParsedReplyHeaders()
 803 {
 804     ServerStateData::haveParsedReplyHeaders();
 805
 806     Ctx ctx = ctx_enter(entry->mem_obj->url);
 807     HttpReply *rep = finalReply();
 808
 809     if (rep->sline.status == HTTP_PARTIAL_CONTENT &&
 810             rep->content_range)
 811         currentOffset = rep->content_range->spec.offset;
 812
 813     entry->timestampsSet();
 814
 815     /* Check if object is cacheable or not based on reply code */
 816     debugs(11, 3, "haveParsedReplyHeaders: HTTP CODE: " << rep->sline.status);
 817
 818     if (neighbors_do_private_keys)
 819         httpMaybeRemovePublic(entry, rep->sline.status);
 820
 821     if (rep->header.has(HDR_VARY)
 822 #if X_ACCELERATOR_VARY
 823             || rep->header.has(HDR_X_ACCELERATOR_VARY)
 824 #endif
 825        ) {
 826         const char *vary = httpMakeVaryMark(orig_request, rep);
 827
 828         if (!vary) {
 829             entry->makePrivate();
 830             goto no_cache;
 831
 832         }
 833
 834         entry->mem_obj->vary_headers = xstrdup(vary);
 835     }
 836
 837 #if WIP_FWD_LOG
 838     fwdStatus(fwd, s);
 839
 840 #endif
 841     /*
 842      * If its not a reply that we will re-forward, then
 843      * allow the client to get it.
 844      */
 845     if (!fwd->reforwardableStatus(rep->sline.status))
 846         EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
 847
 848     switch (cacheableReply()) {
 849
 850     case 1:
 851         entry->makePublic();
 852         break;
 853
 854     case 0:
 855         entry->makePrivate();
 856         break;
 857
 858     case -1:
 859
 860 #if HTTP_VIOLATIONS
 861         if (Config.negativeTtl > 0)
 862             entry->cacheNegatively();
 863         else
 864 #endif
 865             entry->makePrivate();
 866
 867         break;
 868
 869     default:
 870         assert(0);
 871
 872         break;
 873     }
 874
 875 no_cache:
 876
 877     if (!ignoreCacheControl && rep->cache_control) {
 878         if (EBIT_TEST(rep->cache_control->mask, CC_PROXY_REVALIDATE))
 879             EBIT_SET(entry->flags, ENTRY_REVALIDATE);
 880         else if (EBIT_TEST(rep->cache_control->mask, CC_MUST_REVALIDATE))
 881             EBIT_SET(entry->flags, ENTRY_REVALIDATE);
 882     }
 883
 884 #if HEADERS_LOG
 885     headersLog(1, 0, request->method, rep);
 886
 887 #endif
 888
 889     ctx_exit(ctx);
 890 }
 891
 892 HttpStateData::ConnectionStatus
 893 HttpStateData::statusIfComplete() const
 894 {
 895     const HttpReply *rep = virginReply();
 896     /** \par
 897      * If the reply wants to close the connection, it takes precedence */
 898
 899     if (httpHeaderHasConnDir(&rep->header, "close"))
 900         return COMPLETE_NONPERSISTENT_MSG;
 901
 902     /** \par
 903      * If we didn't send a keep-alive request header, then this
 904      * can not be a persistent connection.
 905      */
 906     if (!flags.keepalive)
 907         return COMPLETE_NONPERSISTENT_MSG;
 908
 909     /** \par
 910      * If we haven't sent the whole request then this can not be a persistent
 911      * connection.
 912      */
 913     if (!flags.request_sent) {
 914         debugs(11, 1, "statusIfComplete: Request not yet fully sent \"" << RequestMethodStr(orig_request->method) << " " << entry->url() << "\"" );
 915         return COMPLETE_NONPERSISTENT_MSG;
 916     }
 917
 918     /** \par
 919      * What does the reply have to say about keep-alive?
 920      */
 921     /**
 922      \bug XXX BUG?
 923      * If the origin server (HTTP/1.0) does not send a keep-alive
 924      * header, but keeps the connection open anyway, what happens?
 925      * We'll return here and http.c waits for an EOF before changing
 926      * store_status to STORE_OK.   Combine this with ENTRY_FWD_HDR_WAIT
 927      * and an error status code, and we might have to wait until
 928      * the server times out the socket.
 929      */
 930     if (!rep->keep_alive)
 931         return COMPLETE_NONPERSISTENT_MSG;
 932
 933     return COMPLETE_PERSISTENT_MSG;
 934 }
 935
 936 HttpStateData::ConnectionStatus
 937 HttpStateData::persistentConnStatus() const
 938 {
 939     debugs(11, 3, "persistentConnStatus: FD " << fd << " eof=" << eof);
 940     const HttpReply *vrep = virginReply();
 941     debugs(11, 5, "persistentConnStatus: content_length=" << vrep->content_length);
 942
 943     /* If we haven't seen the end of reply headers, we are not done */
 944     debugs(11, 5, "persistentConnStatus: flags.headers_parsed=" << flags.headers_parsed);
 945
 946     if (!flags.headers_parsed)
 947         return INCOMPLETE_MSG;
 948
 949     if (eof) // already reached EOF
 950         return COMPLETE_NONPERSISTENT_MSG;
 951
 952     /* In chunked responce we do not know the content length but we are absolutelly
 953      * sure about the end of response, so we are calling the statusIfComplete to
 954      * decide if we can be persistant
 955      */
 956     if (lastChunk && flags.chunked)
 957         return statusIfComplete();
 958
 959     const int64_t clen = vrep->bodySize(request->method);
 960
 961     debugs(11, 5, "persistentConnStatus: clen=" << clen);
 962
 963     /* If the body size is unknown we must wait for EOF */
 964     if (clen < 0)
 965         return INCOMPLETE_MSG;
 966
 967     /* If the body size is known, we must wait until we've gotten all of it. */
 968     if (clen > 0) {
 969         // old technique:
 970         // if (entry->mem_obj->endOffset() < vrep->content_length + vrep->hdr_sz)
 971         const int64_t body_bytes_read = reply_bytes_read - header_bytes_read;
 972         debugs(11,5, "persistentConnStatus: body_bytes_read=" <<
 973                body_bytes_read << " content_length=" << vrep->content_length);
 974
 975         if (body_bytes_read < vrep->content_length)
 976             return INCOMPLETE_MSG;
 977     }
 978
 979     /* If there is no message body or we got it all, we can be persistent */
 980     return statusIfComplete();
 981 }
 982
 983 /*
 984  * This is the callback after some data has been read from the network
 985  */
 986 /*
 987 void
 988 HttpStateData::ReadReplyWrapper(int fd, char *buf, size_t len, comm_err_t flag, int xerrno, void *data)
 989 {
 990     HttpStateData *httpState = static_cast<HttpStateData *>(data);
 991     assert (fd == httpState->fd);
 992     // assert(buf == readBuf->content());
 993     PROF_start(HttpStateData_readReply);
 994     httpState->readReply (len, flag, xerrno);
 995     PROF_stop(HttpStateData_readReply);
 996 }
 997 */
 998
 999 /* XXX this function is too long! */
1000 void
1001 HttpStateData::readReply (const CommIoCbParams &io)
1002 {
1003     int bin;
1004     int clen;
1005     int len = io.size;
1006
1007     assert(fd == io.fd);
1008
1009     flags.do_next_read = 0;
1010
1011     debugs(11, 5, "httpReadReply: FD " << fd << ": len " << len << ".");
1012
1013     // Bail out early on COMM_ERR_CLOSING - close handlers will tidy up for us
1014     if (io.flag == COMM_ERR_CLOSING) {
1015         debugs(11, 3, "http socket closing");
1016         return;
1017     }
1018
1019     if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
1020         maybeReadVirginBody();
1021         return;
1022     }
1023
1024     // handle I/O errors
1025     if (io.flag != COMM_OK || len < 0) {
1026         debugs(11, 2, "httpReadReply: FD " << fd << ": read failure: " << xstrerror() << ".");
1027
1028         if (ignoreErrno(io.xerrno)) {
1029             flags.do_next_read = 1;
1030         } else {
1031             ErrorState *err;
1032             err = errorCon(ERR_READ_ERROR, HTTP_BAD_GATEWAY, fwd->request);
1033             err->xerrno = io.xerrno;
1034             fwd->fail(err);
1035             flags.do_next_read = 0;
1036             comm_close(fd);
1037         }
1038
1039         return;
1040     }
1041
1042     // update I/O stats
1043     if (len > 0) {
1044         readBuf->appended(len);
1045         reply_bytes_read += len;
1046 #if DELAY_POOLS
1047
1048         DelayId delayId = entry->mem_obj->mostBytesAllowed();
1049         delayId.bytesIn(len);
1050 #endif
1051
1052         kb_incr(&statCounter.server.all.kbytes_in, len);
1053         kb_incr(&statCounter.server.http.kbytes_in, len);
1054         IOStats.Http.reads++;
1055
1056         for (clen = len - 1, bin = 0; clen; bin++)
1057             clen >>= 1;
1058
1059         IOStats.Http.read_hist[bin]++;
1060     }
1061
1062     /** \par
1063      * Here the RFC says we should ignore whitespace between replies, but we can't as
1064      * doing so breaks HTTP/0.9 replies beginning with witespace, and in addition
1065      * the response splitting countermeasures is extremely likely to trigger on this,
1066      * not allowing connection reuse in the first place.
1067      */
1068 #if DONT_DO_THIS
1069     if (!flags.headers_parsed && len > 0 && fd_table[fd].uses > 1) {
1070         /* Skip whitespace between replies */
1071
1072         while (len > 0 && xisspace(*buf))
1073             xmemmove(buf, buf + 1, len--);
1074
1075         if (len == 0) {
1076             /* Continue to read... */
1077             /* Timeout NOT increased. This whitespace was from previous reply */
1078             flags.do_next_read = 1;
1079             maybeReadVirginBody();
1080             return;
1081         }
1082     }
1083
1084 #endif
1085
1086     if (len == 0) { // reached EOF?
1087         eof = 1;
1088         flags.do_next_read = 0;
1089     }
1090
1091     if (!flags.headers_parsed) { // have not parsed headers yet?
1092         PROF_start(HttpStateData_processReplyHeader);
1093         processReplyHeader();
1094         PROF_stop(HttpStateData_processReplyHeader);
1095
1096         if (!continueAfterParsingHeader()) // parsing error or need more data
1097             return; // TODO: send errors to ICAP
1098
1099         adaptOrFinalizeReply();
1100     }
1101
1102     // kick more reads if needed and/or process the response body, if any
1103     PROF_start(HttpStateData_processReplyBody);
1104     processReplyBody(); // may call serverComplete()
1105     PROF_stop(HttpStateData_processReplyBody);
1106 }
1107
1108 /**
1109  \retval true    if we can continue with processing the body or doing ICAP.
1110  */
1111 bool
1112 HttpStateData::continueAfterParsingHeader()
1113 {
1114     if (!flags.headers_parsed && !eof) {
1115         debugs(11, 9, HERE << "needs more at " << readBuf->contentSize());
1116         flags.do_next_read = 1;
1117         /** \retval false If we have not finished parsing the headers and may get more data.
1118          *                Schedules more reads to retrieve the missing data.
1119          */
1120         maybeReadVirginBody(); // schedules all kinds of reads; TODO: rename
1121         return false;
1122     }
1123
1124     /** If we are done with parsing, check for errors */
1125
1126     err_type error = ERR_NONE;
1127
1128     if (flags.headers_parsed) { // parsed headers, possibly with errors
1129         // check for header parsing errors
1130         if (HttpReply *vrep = virginReply()) {
1131             const http_status s = vrep->sline.status;
1132             const HttpVersion &v = vrep->sline.version;
1133             if (s == HTTP_INVALID_HEADER && v != HttpVersion(0,9)) {
1134                 error = ERR_INVALID_RESP;
1135             } else
1136             if (s == HTTP_HEADER_TOO_LARGE) {
1137                 fwd->dontRetry(true);
1138                 error = ERR_TOO_BIG;
1139             } else {
1140                 return true; // done parsing, got reply, and no error
1141             }
1142         } else {
1143             // parsed headers but got no reply
1144             error = ERR_INVALID_RESP;
1145         }
1146     } else {
1147         assert(eof);
1148         error = readBuf->hasContent() ?
1149             ERR_INVALID_RESP : ERR_ZERO_SIZE_OBJECT;
1150     }
1151
1152     assert(error != ERR_NONE);
1153     entry->reset();
1154     fwd->fail(errorCon(error, HTTP_BAD_GATEWAY, fwd->request));
1155     flags.do_next_read = 0;
1156     comm_close(fd);
1157     return false; // quit on error
1158 }
1159
1160 /**
1161  * Call this when there is data from the origin server
1162  * which should be sent to either StoreEntry, or to ICAP...
1163  */
1164 void
1165 HttpStateData::writeReplyBody()
1166 {
1167     const char *data = readBuf->content();
1168     int len = readBuf->contentSize();
1169     addVirginReplyBody(data, len);
1170     readBuf->consume(len);
1171 }
1172
1173 bool
1174 HttpStateData::decodeAndWriteReplyBody()
1175 {
1176     const char *data = NULL;
1177     int len;
1178     bool status = false;
1179     assert(flags.chunked);
1180     assert(httpChunkDecoder);
1181     SQUID_ENTER_THROWING_CODE();
1182     MemBuf decodedData;
1183     decodedData.init();
1184     const bool done = httpChunkDecoder->parse(readBuf,&decodedData);
1185     len = decodedData.contentSize();
1186     data=decodedData.content();
1187     addVirginReplyBody(data, len);
1188     if (done) {
1189         lastChunk = 1;
1190         flags.do_next_read = 0;
1191     }
1192     SQUID_EXIT_THROWING_CODE(status);
1193     return status;
1194 }
1195
1196 /**
1197  * processReplyBody has two purposes:
1198  *  1 - take the reply body data, if any, and put it into either
1199  *      the StoreEntry, or give it over to ICAP.
1200  *  2 - see if we made it to the end of the response (persistent
1201  *      connections and such)
1202  */
1203 void
1204 HttpStateData::processReplyBody()
1205 {
1206     AsyncCall::Pointer call;
1207     IPAddress client_addr;
1208     bool ispinned = false;
1209
1210     if (!flags.headers_parsed) {
1211         flags.do_next_read = 1;
1212         maybeReadVirginBody();
1213         return;
1214     }
1215
1216 #if USE_ADAPTATION
1217     if (adaptationAccessCheckPending)
1218         return;
1219
1220 #endif
1221
1222     /*
1223      * At this point the reply headers have been parsed and consumed.
1224      * That means header content has been removed from readBuf and
1225      * it contains only body data.
1226      */
1227     if(flags.chunked){
1228         if(!decodeAndWriteReplyBody()){
1229             flags.do_next_read = 0;
1230             serverComplete();
1231             return;
1232         }
1233     }
1234     else
1235         writeReplyBody();
1236
1237     if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
1238         /*
1239          * The above writeReplyBody() call could ABORT this entry,
1240          * in that case, the server FD should already be closed.
1241          * there's nothing for us to do.
1242          */
1243         (void) 0;
1244     } else
1245         switch (persistentConnStatus()) {
1246         case INCOMPLETE_MSG:
1247             debugs(11, 5, "processReplyBody: INCOMPLETE_MSG");
1248             /* Wait for more data or EOF condition */
1249             if (flags.keepalive_broken) {
1250                 call = NULL;
1251                 commSetTimeout(fd, 10, call);
1252             } else {
1253                 call = NULL;
1254                 commSetTimeout(fd, Config.Timeout.read, call);
1255             }
1256
1257             flags.do_next_read = 1;
1258             break;
1259
1260         case COMPLETE_PERSISTENT_MSG:
1261             debugs(11, 5, "processReplyBody: COMPLETE_PERSISTENT_MSG");
1262             /* yes we have to clear all these! */
1263             call = NULL;
1264             commSetTimeout(fd, -1, call);
1265             flags.do_next_read = 0;
1266
1267             comm_remove_close_handler(fd, closeHandler);
1268             closeHandler = NULL;
1269             fwd->unregister(fd);
1270
1271             if (orig_request->flags.spoof_client_ip)
1272                 client_addr = orig_request->client_addr;
1273
1274
1275             if (request->flags.pinned) {
1276                 ispinned = true;
1277             } else if (request->flags.connection_auth && request->flags.auth_sent) {
1278                 ispinned = true;
1279             }
1280
1281             if (orig_request->pinnedConnection() && ispinned) {
1282                 orig_request->pinnedConnection()->pinConnection(fd, orig_request, _peer,
1283                                                                 (request->flags.connection_auth != 0));
1284             } else if (_peer) {
1285                 if (_peer->options.originserver)
1286                     fwd->pconnPush(fd, _peer->name, orig_request->port, orig_request->GetHost(), client_addr);
1287                 else
1288                     fwd->pconnPush(fd, _peer->name, _peer->http_port, NULL, client_addr);
1289             } else {
1290                 fwd->pconnPush(fd, request->GetHost(), request->port, NULL, client_addr);
1291             }
1292
1293             fd = -1;
1294
1295             serverComplete();
1296             return;
1297
1298         case COMPLETE_NONPERSISTENT_MSG:
1299             debugs(11, 5, "processReplyBody: COMPLETE_NONPERSISTENT_MSG");
1300             serverComplete();
1301             return;
1302         }
1303
1304     maybeReadVirginBody();
1305 }
1306
1307 void
1308 HttpStateData::maybeReadVirginBody()
1309 {
1310     int read_sz = replyBodySpace(readBuf->spaceSize());
1311
1312     debugs(11,9, HERE << (flags.do_next_read ? "may" : "wont") <<
1313            " read up to " << read_sz << " bytes from FD " << fd);
1314
1315     /*
1316      * why <2? Because delayAwareRead() won't actually read if
1317      * you ask it to read 1 byte.  The delayed read request
1318      * just gets re-queued until the client side drains, then
1319      * the I/O thread hangs.  Better to not register any read
1320      * handler until we get a notification from someone that
1321      * its okay to read again.
1322      */
1323     if (read_sz < 2) {
1324         if (flags.headers_parsed)
1325             return;
1326         else
1327             read_sz = 1024;
1328     }
1329
1330     if (flags.do_next_read) {
1331         flags.do_next_read = 0;
1332         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1333         entry->delayAwareRead(fd, readBuf->space(read_sz), read_sz,
1334             asyncCall(11, 5, "HttpStateData::readReply",
1335             Dialer(this, &HttpStateData::readReply)));
1336     }
1337 }
1338
1339 /*
1340  * This will be called when request write is complete.
1341  */
1342 void
1343 HttpStateData::sendComplete(const CommIoCbParams &io)
1344 {
1345     debugs(11, 5, "httpSendComplete: FD " << fd << ": size " << io.size << ": errflag " << io.flag << ".");
1346 #if URL_CHECKSUM_DEBUG
1347
1348     entry->mem_obj->checkUrlChecksum();
1349 #endif
1350
1351     if (io.size > 0) {
1352         fd_bytes(fd, io.size, FD_WRITE);
1353         kb_incr(&statCounter.server.all.kbytes_out, io.size);
1354         kb_incr(&statCounter.server.http.kbytes_out, io.size);
1355     }
1356
1357     if (io.flag == COMM_ERR_CLOSING)
1358         return;
1359
1360     if (io.flag) {
1361         ErrorState *err;
1362         err = errorCon(ERR_WRITE_ERROR, HTTP_BAD_GATEWAY, fwd->request);
1363         err->xerrno = io.xerrno;
1364         fwd->fail(err);
1365         comm_close(fd);
1366         return;
1367     }
1368
1369     /*
1370      * Set the read timeout here because it hasn't been set yet.
1371      * We only set the read timeout after the request has been
1372      * fully written to the server-side.  If we start the timeout
1373      * after connection establishment, then we are likely to hit
1374      * the timeout for POST/PUT requests that have very large
1375      * request bodies.
1376      */
1377     typedef CommCbMemFunT<HttpStateData, CommTimeoutCbParams> TimeoutDialer;
1378     AsyncCall::Pointer timeoutCall =  asyncCall(11, 5, "HttpStateData::httpTimeout",
1379                         TimeoutDialer(this,&HttpStateData::httpTimeout));
1380
1381     commSetTimeout(fd, Config.Timeout.read, timeoutCall);
1382
1383     flags.request_sent = 1;
1384 }
1385
1386 // Close the HTTP server connection. Used by serverComplete().
1387 void
1388 HttpStateData::closeServer()
1389 {
1390     debugs(11,5, HERE << "closing HTTP server FD " << fd << " this " << this);
1391
1392     if (fd >= 0) {
1393         fwd->unregister(fd);
1394         comm_remove_close_handler(fd, closeHandler);
1395         closeHandler = NULL;
1396         comm_close(fd);
1397         fd = -1;
1398     }
1399 }
1400
1401 bool
1402 HttpStateData::doneWithServer() const
1403 {
1404     return fd < 0;
1405 }
1406
1407 /*
1408  * build request headers and append them to a given MemBuf
1409  * used by buildRequestPrefix()
1410  * note: initialised the HttpHeader, the caller is responsible for Clean()-ing
1411  */
1412 void
1413 HttpStateData::httpBuildRequestHeader(HttpRequest * request,
1414                                       HttpRequest * orig_request,
1415                                       StoreEntry * entry,
1416                                       HttpHeader * hdr_out,
1417                                       http_state_flags flags)
1418 {
1419     /* building buffer for complex strings */
1420 #define BBUF_SZ (MAX_URL+32)
1421     LOCAL_ARRAY(char, bbuf, BBUF_SZ);
1422     LOCAL_ARRAY(char, ntoabuf, MAX_IPSTRLEN);
1423     const HttpHeader *hdr_in = &orig_request->header;
1424     const HttpHeaderEntry *e = NULL;
1425     String strFwd;
1426     HttpHeaderPos pos = HttpHeaderInitPos;
1427     assert (hdr_out->owner == hoRequest);
1428     /* append our IMS header */
1429
1430     if (request->lastmod > -1)
1431         hdr_out->putTime(HDR_IF_MODIFIED_SINCE, request->lastmod);
1432
1433     bool we_do_ranges = decideIfWeDoRanges (orig_request);
1434
1435     String strConnection (hdr_in->getList(HDR_CONNECTION));
1436
1437     while ((e = hdr_in->getEntry(&pos)))
1438         copyOneHeaderFromClientsideRequestToUpstreamRequest(e, strConnection, request, orig_request, hdr_out, we_do_ranges, flags);
1439
1440     /* Abstraction break: We should interpret multipart/byterange responses
1441      * into offset-length data, and this works around our inability to do so.
1442      */
1443     if (!we_do_ranges && orig_request->multipartRangeRequest()) {
1444         /* don't cache the result */
1445         orig_request->flags.cachable = 0;
1446         /* pretend it's not a range request */
1447         delete orig_request->range;
1448         orig_request->range = NULL;
1449         orig_request->flags.range = 0;
1450     }
1451
1452     /* append Via */
1453     if (Config.onoff.via) {
1454         String strVia;
1455         strVia = hdr_in->getList(HDR_VIA);
1456         snprintf(bbuf, BBUF_SZ, "%d.%d %s",
1457                  orig_request->http_ver.major,
1458                  orig_request->http_ver.minor, ThisCache);
1459         strListAdd(&strVia, bbuf, ',');
1460         hdr_out->putStr(HDR_VIA, strVia.buf());
1461         strVia.clean();
1462     }
1463
1464 #if USE_SQUID_ESI
1465     {
1466         /* Append Surrogate-Capabilities */
1467         String strSurrogate (hdr_in->getList(HDR_SURROGATE_CAPABILITY));
1468         snprintf(bbuf, BBUF_SZ, "%s=\"Surrogate/1.0 ESI/1.0\"",
1469                  Config.Accel.surrogate_id);
1470         strListAdd(&strSurrogate, bbuf, ',');
1471         hdr_out->putStr(HDR_SURROGATE_CAPABILITY, strSurrogate.buf());
1472     }
1473 #endif
1474
1475     strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1476
1477     /** \pre Handle X-Forwarded-For */
1478     if(strcmp(opt_forwarded_for, "delete") != 0) {
1479         if(strcmp(opt_forwarded_for, "on") == 0) {
1480             /** If set to ON - append client IP or 'unknown'. */
1481             strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1482             if( orig_request->client_addr.IsNoAddr() )
1483                 strListAdd(&strFwd, "unknown", ',');
1484             else
1485                 strListAdd(&strFwd, orig_request->client_addr.NtoA(ntoabuf, MAX_IPSTRLEN), ',');
1486         } else if(strcmp(opt_forwarded_for, "off") == 0) {
1487             /** If set to OFF - append 'unknown'. */
1488             strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1489             strListAdd(&strFwd, "unknown", ',');
1490         } else if(strcmp(opt_forwarded_for, "transparent") == 0) {
1491             /** If set to TRANSPARENT - pass through unchanged. */
1492             strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1493         } else if(strcmp(opt_forwarded_for, "truncate") == 0) {
1494             /** If set to TRUNCATE - drop existing list and replace with client IP or 'unknown'. */
1495             if( orig_request->client_addr.IsNoAddr() )
1496                 strFwd = "unknown";
1497             else
1498                 strFwd = orig_request->client_addr.NtoA(ntoabuf, MAX_IPSTRLEN);
1499         }
1500         if(strFwd.size() > 0)
1501             hdr_out->putStr(HDR_X_FORWARDED_FOR, strFwd.buf());
1502     }
1503     /** If set to DELETE - do not copy through. */
1504     strFwd.clean();
1505
1506     /* append Host if not there already */
1507     if (!hdr_out->has(HDR_HOST)) {
1508         if (orig_request->peer_domain) {
1509             hdr_out->putStr(HDR_HOST, orig_request->peer_domain);
1510         } else if (orig_request->port == urlDefaultPort(orig_request->protocol)) {
1511             /* use port# only if not default */
1512             hdr_out->putStr(HDR_HOST, orig_request->GetHost());
1513         } else {
1514             httpHeaderPutStrf(hdr_out, HDR_HOST, "%s:%d",
1515                               orig_request->GetHost(),
1516                               (int) orig_request->port);
1517         }
1518     }
1519
1520     /* append Authorization if known in URL, not in header and going direct */
1521     if (!hdr_out->has(HDR_AUTHORIZATION)) {
1522         if (!request->flags.proxying && *request->login) {
1523             httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1524                               base64_encode(request->login));
1525         }
1526     }
1527
1528     /* append Proxy-Authorization if configured for peer, and proxying */
1529     if (request->flags.proxying && orig_request->peer_login &&
1530             !hdr_out->has(HDR_PROXY_AUTHORIZATION)) {
1531         if (*orig_request->peer_login == '*') {
1532             /* Special mode, to pass the username to the upstream cache */
1533             char loginbuf[256];
1534             const char *username = "-";
1535
1536             if (orig_request->extacl_user.size())
1537                 username = orig_request->extacl_user.buf();
1538             else if (orig_request->auth_user_request)
1539                 username = orig_request->auth_user_request->username();
1540
1541             snprintf(loginbuf, sizeof(loginbuf), "%s%s", username, orig_request->peer_login + 1);
1542
1543             httpHeaderPutStrf(hdr_out, HDR_PROXY_AUTHORIZATION, "Basic %s",
1544                               base64_encode(loginbuf));
1545         } else if (strcmp(orig_request->peer_login, "PASS") == 0) {
1546             if (orig_request->extacl_user.size() && orig_request->extacl_passwd.size()) {
1547                 char loginbuf[256];
1548                 snprintf(loginbuf, sizeof(loginbuf), "%s:%s", orig_request->extacl_user.buf(), orig_request->extacl_passwd.buf());
1549                 httpHeaderPutStrf(hdr_out, HDR_PROXY_AUTHORIZATION, "Basic %s",
1550                                   base64_encode(loginbuf));
1551             }
1552         } else if (strcmp(orig_request->peer_login, "PROXYPASS") == 0) {
1553             /* Nothing to do */
1554         } else {
1555             httpHeaderPutStrf(hdr_out, HDR_PROXY_AUTHORIZATION, "Basic %s",
1556                               base64_encode(orig_request->peer_login));
1557         }
1558     }
1559
1560     /* append WWW-Authorization if configured for peer */
1561     if (flags.originpeer && orig_request->peer_login &&
1562             !hdr_out->has(HDR_AUTHORIZATION)) {
1563         if (strcmp(orig_request->peer_login, "PASS") == 0) {
1564             /* No credentials to forward.. (should have been done above if available) */
1565         } else if (strcmp(orig_request->peer_login, "PROXYPASS") == 0) {
1566             /* Special mode, convert proxy authentication to WWW authentication
1567             * (also applies to authentication provided by external acl)
1568              */
1569             const char *auth = hdr_in->getStr(HDR_PROXY_AUTHORIZATION);
1570
1571             if (auth && strncasecmp(auth, "basic ", 6) == 0) {
1572                 hdr_out->putStr(HDR_AUTHORIZATION, auth);
1573             } else if (orig_request->extacl_user.size() && orig_request->extacl_passwd.size()) {
1574                 char loginbuf[256];
1575                 snprintf(loginbuf, sizeof(loginbuf), "%s:%s", orig_request->extacl_user.buf(), orig_request->extacl_passwd.buf());
1576                 httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1577                                   base64_encode(loginbuf));
1578             }
1579         } else if (*orig_request->peer_login == '*') {
1580             /* Special mode, to pass the username to the upstream cache */
1581             char loginbuf[256];
1582             const char *username = "-";
1583
1584             if (orig_request->auth_user_request)
1585                 username = orig_request->auth_user_request->username();
1586             else if (orig_request->extacl_user.size())
1587                 username = orig_request->extacl_user.buf();
1588
1589             snprintf(loginbuf, sizeof(loginbuf), "%s%s", username, orig_request->peer_login + 1);
1590
1591             httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1592                               base64_encode(loginbuf));
1593         } else {
1594             /* Fixed login string */
1595             httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1596                               base64_encode(orig_request->peer_login));
1597         }
1598     }
1599
1600     /* append Cache-Control, add max-age if not there already */ {
1601         HttpHdrCc *cc = hdr_in->getCc();
1602
1603         if (!cc)
1604             cc = httpHdrCcCreate();
1605
1606         if (!EBIT_TEST(cc->mask, CC_MAX_AGE)) {
1607             const char *url =
1608                 entry ? entry->url() : urlCanonical(orig_request);
1609             httpHdrCcSetMaxAge(cc, getMaxAge(url));
1610
1611             if (request->urlpath.size())
1612                 assert(strstr(url, request->urlpath.buf()));
1613         }
1614
1615         /* Set no-cache if determined needed but not found */
1616         if (orig_request->flags.nocache && !hdr_in->has(HDR_PRAGMA))
1617             EBIT_SET(cc->mask, CC_NO_CACHE);
1618
1619         /* Enforce sibling relations */
1620         if (flags.only_if_cached)
1621             EBIT_SET(cc->mask, CC_ONLY_IF_CACHED);
1622
1623         hdr_out->putCc(cc);
1624
1625         httpHdrCcDestroy(cc);
1626     }
1627
1628     /* maybe append Connection: keep-alive */
1629     if (flags.keepalive) {
1630         if (flags.proxying) {
1631             hdr_out->putStr(HDR_PROXY_CONNECTION, "keep-alive");
1632         } else {
1633             hdr_out->putStr(HDR_CONNECTION, "keep-alive");
1634         }
1635     }
1636
1637     /* append Front-End-Https */
1638     if (flags.front_end_https) {
1639         if (flags.front_end_https == 1 || request->protocol == PROTO_HTTPS)
1640             hdr_out->putStr(HDR_FRONT_END_HTTPS, "On");
1641     }
1642
1643     /* Now mangle the headers. */
1644     if (Config2.onoff.mangle_request_headers)
1645         httpHdrMangleList(hdr_out, request, ROR_REQUEST);
1646
1647     strConnection.clean();
1648 }
1649
1650 void
1651 copyOneHeaderFromClientsideRequestToUpstreamRequest(const HttpHeaderEntry *e, String strConnection, HttpRequest * request, HttpRequest * orig_request, HttpHeader * hdr_out, int we_do_ranges, http_state_flags flags)
1652 {
1653     debugs(11, 5, "httpBuildRequestHeader: " << e->name.buf() << ": " << e->value.buf());
1654
1655     if (!httpRequestHdrAllowed(e, &strConnection)) {
1656         debugs(11, 2, "'" << e->name.buf() << "' header denied by anonymize_headers configuration");
1657         return;
1658     }
1659
1660     switch (e->id) {
1661
1662     case HDR_PROXY_AUTHORIZATION:
1663         /* Only pass on proxy authentication to peers for which
1664          * authentication forwarding is explicitly enabled
1665          */
1666
1667         if (flags.proxying && orig_request->peer_login &&
1668                 (strcmp(orig_request->peer_login, "PASS") == 0 ||
1669                  strcmp(orig_request->peer_login, "PROXYPASS") == 0)) {
1670             hdr_out->addEntry(e->clone());
1671         }
1672
1673         break;
1674
1675     case HDR_AUTHORIZATION:
1676         /* Pass on WWW authentication */
1677
1678         if (!flags.originpeer) {
1679             hdr_out->addEntry(e->clone());
1680         } else {
1681             /* In accelerators, only forward authentication if enabled
1682              * (see also below for proxy->server authentication)
1683              */
1684
1685             if (orig_request->peer_login &&
1686                     (strcmp(orig_request->peer_login, "PASS") == 0 ||
1687                      strcmp(orig_request->peer_login, "PROXYPASS") == 0)) {
1688                 hdr_out->addEntry(e->clone());
1689             }
1690         }
1691
1692         break;
1693
1694     case HDR_HOST:
1695         /*
1696          * Normally Squid rewrites the Host: header.
1697          * However, there is one case when we don't: If the URL
1698          * went through our redirector and the admin configured
1699          * 'redir_rewrites_host' to be off.
1700          */
1701
1702         if (request->flags.redirected && !Config.onoff.redir_rewrites_host)
1703             hdr_out->addEntry(e->clone());
1704         else {
1705             /* use port# only if not default */
1706
1707             if (orig_request->port == urlDefaultPort(orig_request->protocol)) {
1708                 hdr_out->putStr(HDR_HOST, orig_request->GetHost());
1709             } else {
1710                 httpHeaderPutStrf(hdr_out, HDR_HOST, "%s:%d",
1711                                   orig_request->GetHost(),
1712                                   (int) orig_request->port);
1713             }
1714         }
1715
1716         break;
1717
1718     case HDR_IF_MODIFIED_SINCE:
1719         /* append unless we added our own;
1720          * note: at most one client's ims header can pass through */
1721
1722         if (!hdr_out->has(HDR_IF_MODIFIED_SINCE))
1723             hdr_out->addEntry(e->clone());
1724
1725         break;
1726
1727     case HDR_MAX_FORWARDS:
1728         if (orig_request->method == METHOD_TRACE) {
1729             const int hops = e->getInt();
1730
1731             if (hops > 0)
1732                 hdr_out->putInt(HDR_MAX_FORWARDS, hops - 1);
1733         }
1734
1735         break;
1736
1737     case HDR_VIA:
1738         /* If Via is disabled then forward any received header as-is */
1739
1740         if (!Config.onoff.via)
1741             hdr_out->addEntry(e->clone());
1742
1743         break;
1744
1745     case HDR_RANGE:
1746
1747     case HDR_IF_RANGE:
1748
1749     case HDR_REQUEST_RANGE:
1750         if (!we_do_ranges)
1751             hdr_out->addEntry(e->clone());
1752
1753         break;
1754
1755     case HDR_PROXY_CONNECTION:
1756
1757     case HDR_CONNECTION:
1758
1759     case HDR_X_FORWARDED_FOR:
1760
1761     case HDR_CACHE_CONTROL:
1762         /* append these after the loop if needed */
1763         break;
1764
1765     case HDR_FRONT_END_HTTPS:
1766         if (!flags.front_end_https)
1767             hdr_out->addEntry(e->clone());
1768
1769         break;
1770
1771     default:
1772         /* pass on all other header fields */
1773         hdr_out->addEntry(e->clone());
1774     }
1775 }
1776
1777 bool
1778 HttpStateData::decideIfWeDoRanges (HttpRequest * orig_request)
1779 {
1780     bool result = true;
1781     /* decide if we want to do Ranges ourselves
1782      * and fetch the whole object now)
1783      * We want to handle Ranges ourselves iff
1784      *    - we can actually parse client Range specs
1785      *    - the specs are expected to be simple enough (e.g. no out-of-order ranges)
1786      *    - reply will be cachable
1787      * (If the reply will be uncachable we have to throw it away after
1788      *  serving this request, so it is better to forward ranges to
1789      *  the server and fetch only the requested content)
1790      */
1791
1792     if (NULL == orig_request->range || !orig_request->flags.cachable
1793             || orig_request->range->offsetLimitExceeded() || orig_request->flags.connection_auth)
1794         result = false;
1795
1796         debugs(11, 8, "decideIfWeDoRanges: range specs: " <<
1797                orig_request->range << ", cachable: " <<
1798                orig_request->flags.cachable << "; we_do_ranges: " << result);
1799
1800     return result;
1801 }
1802
1803 /* build request prefix and append it to a given MemBuf;
1804  * return the length of the prefix */
1805 mb_size_t
1806 HttpStateData::buildRequestPrefix(HttpRequest * request,
1807                                   HttpRequest * orig_request,
1808                                   StoreEntry * entry,
1809                                   MemBuf * mb,
1810                                   http_state_flags flags)
1811 {
1812     const int offset = mb->size;
1813     HttpVersion httpver(1, 0);
1814     mb->Printf("%s %s HTTP/%d.%d\r\n",
1815                RequestMethodStr(request->method),
1816                request->urlpath.size() ? request->urlpath.buf() : "/",
1817                httpver.major,httpver.minor);
1818     /* build and pack headers */
1819     {
1820         HttpHeader hdr(hoRequest);
1821         Packer p;
1822         httpBuildRequestHeader(request, orig_request, entry, &hdr, flags);
1823
1824         if (request->flags.pinned && request->flags.connection_auth)
1825             request->flags.auth_sent = 1;
1826         else if (hdr.has(HDR_AUTHORIZATION))
1827             request->flags.auth_sent = 1;
1828
1829         packerToMemInit(&p, mb);
1830         hdr.packInto(&p);
1831         hdr.clean();
1832         packerClean(&p);
1833     }
1834     /* append header terminator */
1835     mb->append(crlf, 2);
1836     return mb->size - offset;
1837 }
1838
1839 /* This will be called when connect completes. Write request. */
1840 bool
1841 HttpStateData::sendRequest()
1842 {
1843     MemBuf mb;
1844
1845     debugs(11, 5, "httpSendRequest: FD " << fd << ", request " << request << ", this " << this << ".");
1846     typedef CommCbMemFunT<HttpStateData, CommTimeoutCbParams> TimeoutDialer;
1847     AsyncCall::Pointer timeoutCall =  asyncCall(11, 5, "HttpStateData::httpTimeout",
1848                         TimeoutDialer(this,&HttpStateData::httpTimeout));
1849     commSetTimeout(fd, Config.Timeout.lifetime, timeoutCall);
1850     flags.do_next_read = 1;
1851     maybeReadVirginBody();
1852
1853     if (orig_request->body_pipe != NULL) {
1854         if (!startRequestBodyFlow()) // register to receive body data
1855             return false;
1856         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1857         Dialer dialer(this, &HttpStateData::sentRequestBody);
1858         requestSender = asyncCall(11,5, "HttpStateData::sentRequestBody", dialer);
1859     } else {
1860         assert(!requestBodySource);
1861         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1862         Dialer dialer(this, &HttpStateData::sendComplete);
1863         requestSender = asyncCall(11,5, "HttpStateData::SendComplete", dialer);
1864     }
1865
1866     if (_peer != NULL) {
1867         if (_peer->options.originserver) {
1868             flags.proxying = 0;
1869             flags.originpeer = 1;
1870         } else {
1871             flags.proxying = 1;
1872             flags.originpeer = 0;
1873         }
1874     } else {
1875         flags.proxying = 0;
1876         flags.originpeer = 0;
1877     }
1878
1879     /*
1880      * Is keep-alive okay for all request methods?
1881      */
1882     if (orig_request->flags.must_keepalive)
1883         flags.keepalive = 1;
1884     else if (!Config.onoff.server_pconns)
1885         flags.keepalive = 0;
1886     else if (_peer == NULL)
1887         flags.keepalive = 1;
1888     else if (_peer->stats.n_keepalives_sent < 10)
1889         flags.keepalive = 1;
1890     else if ((double) _peer->stats.n_keepalives_recv /
1891              (double) _peer->stats.n_keepalives_sent > 0.50)
1892         flags.keepalive = 1;
1893
1894     if (_peer) {
1895         if (neighborType(_peer, request) == PEER_SIBLING &&
1896                 !_peer->options.allow_miss)
1897             flags.only_if_cached = 1;
1898
1899         flags.front_end_https = _peer->front_end_https;
1900     }
1901
1902     mb.init();
1903     buildRequestPrefix(request, orig_request, entry, &mb, flags);
1904     debugs(11, 6, "httpSendRequest: FD " << fd << ":\n" << mb.buf);
1905     comm_write_mbuf(fd, &mb, requestSender);
1906
1907     return true;
1908 }
1909
1910 void
1911 httpStart(FwdState *fwd)
1912 {
1913     debugs(11, 3, "httpStart: \"" << RequestMethodStr(fwd->request->method) << " " << fwd->entry->url() << "\"" );
1914     HttpStateData *httpState = new HttpStateData(fwd);
1915
1916     if (!httpState->sendRequest()) {
1917         debugs(11, 3, "httpStart: aborted");
1918         delete httpState;
1919         return;
1920     }
1921
1922     statCounter.server.all.requests++;
1923     statCounter.server.http.requests++;
1924
1925     /*
1926      * We used to set the read timeout here, but not any more.
1927      * Now its set in httpSendComplete() after the full request,
1928      * including request body, has been written to the server.
1929      */
1930 }
1931
1932 void
1933 HttpStateData::doneSendingRequestBody()
1934 {
1935     ACLChecklist ch;
1936     debugs(11,5, HERE << "doneSendingRequestBody: FD " << fd);
1937     ch.request = HTTPMSGLOCK(request);
1938
1939     if (Config.accessList.brokenPosts)
1940         ch.accessList = cbdataReference(Config.accessList.brokenPosts);
1941
1942     /* cbdataReferenceDone() happens in either fastCheck() or ~ACLCheckList */
1943
1944     if (!Config.accessList.brokenPosts) {
1945         debugs(11, 5, "doneSendingRequestBody: No brokenPosts list");
1946         CommIoCbParams io(NULL);
1947         io.fd=fd;
1948         io.flag=COMM_OK;
1949         sendComplete(io);
1950     } else if (!ch.fastCheck()) {
1951         debugs(11, 5, "doneSendingRequestBody: didn't match brokenPosts");
1952         CommIoCbParams io(NULL);
1953         io.fd=fd;
1954         io.flag=COMM_OK;
1955         sendComplete(io);
1956     } else {
1957         debugs(11, 2, "doneSendingRequestBody: matched brokenPosts");
1958         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1959         Dialer dialer(this, &HttpStateData::sendComplete);
1960         AsyncCall::Pointer call= asyncCall(11,5, "HttpStateData::SendComplete", dialer);
1961         comm_write(fd, "\r\n", 2, call);
1962     }
1963 }
1964
1965 // more origin request body data is available
1966 void
1967 HttpStateData::handleMoreRequestBodyAvailable()
1968 {
1969     if (eof || fd < 0) {
1970         // XXX: we should check this condition in other callbacks then!
1971         // TODO: Check whether this can actually happen: We should unsubscribe
1972         // as a body consumer when the above condition(s) are detected.
1973         debugs(11, 1, HERE << "Transaction aborted while reading HTTP body");
1974         return;
1975     }
1976
1977     assert(requestBodySource != NULL);
1978
1979     if (requestBodySource->buf().hasContent()) {
1980         // XXX: why does not this trigger a debug message on every request?
1981
1982         if (flags.headers_parsed && !flags.abuse_detected) {
1983             flags.abuse_detected = 1;
1984             debugs(11, 1, "http handleMoreRequestBodyAvailable: Likely proxy abuse detected '" << orig_request->client_addr << "' -> '" << entry->url() << "'" );
1985
1986             if (virginReply()->sline.status == HTTP_INVALID_HEADER) {
1987                 comm_close(fd);
1988                 return;
1989             }
1990         }
1991     }
1992
1993     HttpStateData::handleMoreRequestBodyAvailable();
1994 }
1995
1996 // premature end of the request body
1997 void
1998 HttpStateData::handleRequestBodyProducerAborted()
1999 {
2000     ServerStateData::handleRequestBodyProducerAborted();
2001     // XXX: SendComplete(COMM_ERR_CLOSING) does little. Is it enough?
2002     CommIoCbParams io(NULL);
2003     io.fd=fd;
2004     io.flag=COMM_ERR_CLOSING;
2005     sendComplete(io);
2006 }
2007
2008 // called when we wrote request headers(!) or a part of the body
2009 void
2010 HttpStateData::sentRequestBody(const CommIoCbParams &io)
2011 {
2012     if (io.size > 0)
2013         kb_incr(&statCounter.server.http.kbytes_out, io.size);
2014
2015     ServerStateData::sentRequestBody(io);
2016 }
2017
2018 // Quickly abort the transaction
2019 // TODO: destruction should be sufficient as the destructor should cleanup,
2020 // including canceling close handlers
2021 void
2022 HttpStateData::abortTransaction(const char *reason)
2023 {
2024     debugs(11,5, HERE << "aborting transaction for " << reason <<
2025            "; FD " << fd << ", this " << this);
2026
2027     if (fd >= 0) {
2028         comm_close(fd);
2029         return;
2030     }
2031
2032     fwd->handleUnregisteredServerEnd();
2033     deleteThis("HttpStateData::abortTransaction");
2034 }
2035
2036 #if DEAD_CODE
2037 void
2038 httpBuildVersion(HttpVersion * version, unsigned int major, unsigned int minor)
2039 {
2040     version->major = major;
2041     version->minor = minor;
2042 }
2043 #endif
2044
2045 HttpRequest *
2046 HttpStateData::originalRequest()
2047 {
2048     return orig_request;
2049 }