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     } else {
 686         if (!parsed && error > 0) { // unrecoverable parsing error
 687             debugs(11, 3, "processReplyHeader: Non-HTTP-compliant header: '" <<  readBuf->content() << "'");
 688             flags.headers_parsed = 1;
 689             newrep->sline.version = HttpVersion(1, 0);
 690             newrep->sline.status = error;
 691             HttpReply *vrep = setVirginReply(newrep);
 692             entry->replaceHttpReply(vrep);
 693             ctx_exit(ctx);
 694             return;
 695         }
 696
 697         if (!parsed) { // need more data
 698             assert(!error);
 699             assert(!eof);
 700             delete newrep;
 701             ctx_exit(ctx);
 702             return;
 703         }
 704
 705         debugs(11, 9, "GOT HTTP REPLY HDR:\n---------\n" << readBuf->content() << "\n----------");
 706
 707         header_bytes_read = headersEnd(readBuf->content(), readBuf->contentSize());
 708         readBuf->consume(header_bytes_read);
 709     }
 710
 711     flags.chunked = 0;
 712     if (newrep->header.hasListMember(HDR_TRANSFER_ENCODING, "chunked", ',')) {
 713         flags.chunked = 1;
 714         httpChunkDecoder = new ChunkedCodingParser;
 715     }
 716
 717     if (!peerSupportsConnectionPinning())
 718         orig_request->flags.connection_auth_disabled = 1;
 719
 720     HttpReply *vrep = setVirginReply(newrep);
 721     flags.headers_parsed = 1;
 722
 723     keepaliveAccounting(vrep);
 724
 725     checkDateSkew(vrep);
 726
 727     processSurrogateControl (vrep);
 728
 729     /** \todo IF the reply is a 1.0 reply, AND it has a Connection: Header
 730      * Parse the header and remove all referenced headers
 731      */
 732
 733     ctx_exit(ctx);
 734
 735 }
 736
 737 /**
 738  * returns true if the peer can support connection pinning
 739 */
 740 bool HttpStateData::peerSupportsConnectionPinning() const
 741 {
 742     const HttpReply *rep = entry->mem_obj->getReply();
 743     const HttpHeader *hdr = &rep->header;
 744     bool rc;
 745     String header;
 746
 747     if (!_peer)
 748         return true;
 749
 750     /*If this peer does not support connection pinning (authenticated
 751       connections) return false
 752      */
 753     if (!_peer->connection_auth)
 754         return false;
 755
 756     /*The peer supports connection pinning and the http reply status
 757       is not unauthorized, so the related connection can be pinned
 758      */
 759     if (rep->sline.status != HTTP_UNAUTHORIZED)
 760         return true;
 761
 762     /*The server respond with HTTP_UNAUTHORIZED and the peer configured
 763       with "connection-auth=on" we know that the peer supports pinned
 764       connections
 765     */
 766     if (_peer->connection_auth == 1)
 767         return true;
 768
 769     /*At this point peer has configured with "connection-auth=auto"
 770       parameter so we need some extra checks to decide if we are going
 771       to allow pinned connections or not
 772     */
 773
 774     /*if the peer configured with originserver just allow connection
 775         pinning (squid 2.6 behaviour)
 776      */
 777     if (_peer->options.originserver)
 778         return true;
 779
 780     /*if the connections it is already pinned it is OK*/
 781     if (request->flags.pinned)
 782         return true;
 783
 784     /*Allow pinned connections only if the Proxy-support header exists in
 785       reply and has in its list the "Session-Based-Authentication"
 786       which means that the peer supports connection pinning.
 787      */
 788     if (!hdr->has(HDR_PROXY_SUPPORT))
 789         return false;
 790
 791     header = hdr->getStrOrList(HDR_PROXY_SUPPORT);
 792     /* XXX This ought to be done in a case-insensitive manner */
 793     rc = (strstr(header.buf(), "Session-Based-Authentication") != NULL);
 794
 795     return rc;
 796 }
 797
 798 // Called when we parsed (and possibly adapted) the headers but
 799 // had not starting storing (a.k.a., sending) the body yet.
 800 void
 801 HttpStateData::haveParsedReplyHeaders()
 802 {
 803     ServerStateData::haveParsedReplyHeaders();
 804
 805     Ctx ctx = ctx_enter(entry->mem_obj->url);
 806     HttpReply *rep = finalReply();
 807
 808     if (rep->sline.status == HTTP_PARTIAL_CONTENT &&
 809             rep->content_range)
 810         currentOffset = rep->content_range->spec.offset;
 811
 812     entry->timestampsSet();
 813
 814     /* Check if object is cacheable or not based on reply code */
 815     debugs(11, 3, "haveParsedReplyHeaders: HTTP CODE: " << rep->sline.status);
 816
 817     if (neighbors_do_private_keys)
 818         httpMaybeRemovePublic(entry, rep->sline.status);
 819
 820     if (rep->header.has(HDR_VARY)
 821 #if X_ACCELERATOR_VARY
 822             || rep->header.has(HDR_X_ACCELERATOR_VARY)
 823 #endif
 824        ) {
 825         const char *vary = httpMakeVaryMark(orig_request, rep);
 826
 827         if (!vary) {
 828             entry->makePrivate();
 829             goto no_cache;
 830
 831         }
 832
 833         entry->mem_obj->vary_headers = xstrdup(vary);
 834     }
 835
 836 #if WIP_FWD_LOG
 837     fwdStatus(fwd, s);
 838
 839 #endif
 840     /*
 841      * If its not a reply that we will re-forward, then
 842      * allow the client to get it.
 843      */
 844     if (!fwd->reforwardableStatus(rep->sline.status))
 845         EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
 846
 847     switch (cacheableReply()) {
 848
 849     case 1:
 850         entry->makePublic();
 851         break;
 852
 853     case 0:
 854         entry->makePrivate();
 855         break;
 856
 857     case -1:
 858
 859 #if HTTP_VIOLATIONS
 860         if (Config.negativeTtl > 0)
 861             entry->cacheNegatively();
 862         else
 863 #endif
 864             entry->makePrivate();
 865
 866         break;
 867
 868     default:
 869         assert(0);
 870
 871         break;
 872     }
 873
 874 no_cache:
 875
 876     if (!ignoreCacheControl && rep->cache_control) {
 877         if (EBIT_TEST(rep->cache_control->mask, CC_PROXY_REVALIDATE))
 878             EBIT_SET(entry->flags, ENTRY_REVALIDATE);
 879         else if (EBIT_TEST(rep->cache_control->mask, CC_MUST_REVALIDATE))
 880             EBIT_SET(entry->flags, ENTRY_REVALIDATE);
 881     }
 882
 883 #if HEADERS_LOG
 884     headersLog(1, 0, request->method, rep);
 885
 886 #endif
 887
 888     ctx_exit(ctx);
 889 }
 890
 891 HttpStateData::ConnectionStatus
 892 HttpStateData::statusIfComplete() const
 893 {
 894     const HttpReply *rep = virginReply();
 895     /** \par
 896      * If the reply wants to close the connection, it takes precedence */
 897
 898     if (httpHeaderHasConnDir(&rep->header, "close"))
 899         return COMPLETE_NONPERSISTENT_MSG;
 900
 901     /** \par
 902      * If we didn't send a keep-alive request header, then this
 903      * can not be a persistent connection.
 904      */
 905     if (!flags.keepalive)
 906         return COMPLETE_NONPERSISTENT_MSG;
 907
 908     /** \par
 909      * If we haven't sent the whole request then this can not be a persistent
 910      * connection.
 911      */
 912     if (!flags.request_sent) {
 913         debugs(11, 1, "statusIfComplete: Request not yet fully sent \"" << RequestMethodStr(orig_request->method) << " " << entry->url() << "\"" );
 914         return COMPLETE_NONPERSISTENT_MSG;
 915     }
 916
 917     /** \par
 918      * What does the reply have to say about keep-alive?
 919      */
 920     /**
 921      \bug XXX BUG?
 922      * If the origin server (HTTP/1.0) does not send a keep-alive
 923      * header, but keeps the connection open anyway, what happens?
 924      * We'll return here and http.c waits for an EOF before changing
 925      * store_status to STORE_OK.   Combine this with ENTRY_FWD_HDR_WAIT
 926      * and an error status code, and we might have to wait until
 927      * the server times out the socket.
 928      */
 929     if (!rep->keep_alive)
 930         return COMPLETE_NONPERSISTENT_MSG;
 931
 932     return COMPLETE_PERSISTENT_MSG;
 933 }
 934
 935 HttpStateData::ConnectionStatus
 936 HttpStateData::persistentConnStatus() const
 937 {
 938     debugs(11, 3, "persistentConnStatus: FD " << fd << " eof=" << eof);
 939     const HttpReply *vrep = virginReply();
 940     debugs(11, 5, "persistentConnStatus: content_length=" << vrep->content_length);
 941
 942     /* If we haven't seen the end of reply headers, we are not done */
 943     debugs(11, 5, "persistentConnStatus: flags.headers_parsed=" << flags.headers_parsed);
 944
 945     if (!flags.headers_parsed)
 946         return INCOMPLETE_MSG;
 947
 948     if (eof) // already reached EOF
 949         return COMPLETE_NONPERSISTENT_MSG;
 950
 951     /* In chunked responce we do not know the content length but we are absolutelly
 952      * sure about the end of response, so we are calling the statusIfComplete to
 953      * decide if we can be persistant
 954      */
 955     if (lastChunk && flags.chunked)
 956         return statusIfComplete();
 957
 958     const int64_t clen = vrep->bodySize(request->method);
 959
 960     debugs(11, 5, "persistentConnStatus: clen=" << clen);
 961
 962     /* If the body size is unknown we must wait for EOF */
 963     if (clen < 0)
 964         return INCOMPLETE_MSG;
 965
 966     /* If the body size is known, we must wait until we've gotten all of it. */
 967     if (clen > 0) {
 968         // old technique:
 969         // if (entry->mem_obj->endOffset() < vrep->content_length + vrep->hdr_sz)
 970         const int64_t body_bytes_read = reply_bytes_read - header_bytes_read;
 971         debugs(11,5, "persistentConnStatus: body_bytes_read=" <<
 972                body_bytes_read << " content_length=" << vrep->content_length);
 973
 974         if (body_bytes_read < vrep->content_length)
 975             return INCOMPLETE_MSG;
 976     }
 977
 978     /* If there is no message body or we got it all, we can be persistent */
 979     return statusIfComplete();
 980 }
 981
 982 /*
 983  * This is the callback after some data has been read from the network
 984  */
 985 /*
 986 void
 987 HttpStateData::ReadReplyWrapper(int fd, char *buf, size_t len, comm_err_t flag, int xerrno, void *data)
 988 {
 989     HttpStateData *httpState = static_cast<HttpStateData *>(data);
 990     assert (fd == httpState->fd);
 991     // assert(buf == readBuf->content());
 992     PROF_start(HttpStateData_readReply);
 993     httpState->readReply (len, flag, xerrno);
 994     PROF_stop(HttpStateData_readReply);
 995 }
 996 */
 997
 998 /* XXX this function is too long! */
 999 void
1000 HttpStateData::readReply (const CommIoCbParams &io)
1001 {
1002     int bin;
1003     int clen;
1004     int len = io.size;
1005
1006     assert(fd == io.fd);
1007
1008     flags.do_next_read = 0;
1009
1010     debugs(11, 5, "httpReadReply: FD " << fd << ": len " << len << ".");
1011
1012     // Bail out early on COMM_ERR_CLOSING - close handlers will tidy up for us
1013     if (io.flag == COMM_ERR_CLOSING) {
1014         debugs(11, 3, "http socket closing");
1015         return;
1016     }
1017
1018     if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
1019         maybeReadVirginBody();
1020         return;
1021     }
1022
1023     // handle I/O errors
1024     if (io.flag != COMM_OK || len < 0) {
1025         debugs(11, 2, "httpReadReply: FD " << fd << ": read failure: " << xstrerror() << ".");
1026
1027         if (ignoreErrno(io.xerrno)) {
1028             flags.do_next_read = 1;
1029         } else {
1030             ErrorState *err;
1031             err = errorCon(ERR_READ_ERROR, HTTP_BAD_GATEWAY, fwd->request);
1032             err->xerrno = io.xerrno;
1033             fwd->fail(err);
1034             flags.do_next_read = 0;
1035             comm_close(fd);
1036         }
1037
1038         return;
1039     }
1040
1041     // update I/O stats
1042     if (len > 0) {
1043         readBuf->appended(len);
1044         reply_bytes_read += len;
1045 #if DELAY_POOLS
1046
1047         DelayId delayId = entry->mem_obj->mostBytesAllowed();
1048         delayId.bytesIn(len);
1049 #endif
1050
1051         kb_incr(&statCounter.server.all.kbytes_in, len);
1052         kb_incr(&statCounter.server.http.kbytes_in, len);
1053         IOStats.Http.reads++;
1054
1055         for (clen = len - 1, bin = 0; clen; bin++)
1056             clen >>= 1;
1057
1058         IOStats.Http.read_hist[bin]++;
1059     }
1060
1061     /** \par
1062      * Here the RFC says we should ignore whitespace between replies, but we can't as
1063      * doing so breaks HTTP/0.9 replies beginning with witespace, and in addition
1064      * the response splitting countermeasures is extremely likely to trigger on this,
1065      * not allowing connection reuse in the first place.
1066      */
1067 #if DONT_DO_THIS
1068     if (!flags.headers_parsed && len > 0 && fd_table[fd].uses > 1) {
1069         /* Skip whitespace between replies */
1070
1071         while (len > 0 && xisspace(*buf))
1072             xmemmove(buf, buf + 1, len--);
1073
1074         if (len == 0) {
1075             /* Continue to read... */
1076             /* Timeout NOT increased. This whitespace was from previous reply */
1077             flags.do_next_read = 1;
1078             maybeReadVirginBody();
1079             return;
1080         }
1081     }
1082
1083 #endif
1084
1085     if (len == 0) { // reached EOF?
1086         eof = 1;
1087         flags.do_next_read = 0;
1088     }
1089
1090     if (!flags.headers_parsed) { // have not parsed headers yet?
1091         PROF_start(HttpStateData_processReplyHeader);
1092         processReplyHeader();
1093         PROF_stop(HttpStateData_processReplyHeader);
1094
1095         if (!continueAfterParsingHeader()) // parsing error or need more data
1096             return; // TODO: send errors to ICAP
1097
1098         adaptOrFinalizeReply();
1099     }
1100
1101     // kick more reads if needed and/or process the response body, if any
1102     PROF_start(HttpStateData_processReplyBody);
1103     processReplyBody(); // may call serverComplete()
1104     PROF_stop(HttpStateData_processReplyBody);
1105 }
1106
1107 /**
1108  \retval true    if we can continue with processing the body or doing ICAP.
1109  */
1110 bool
1111 HttpStateData::continueAfterParsingHeader()
1112 {
1113     if (!flags.headers_parsed && !eof) {
1114         debugs(11, 9, HERE << "needs more at " << readBuf->contentSize());
1115         flags.do_next_read = 1;
1116         /** \retval false If we have not finished parsing the headers and may get more data.
1117          *                Schedules more reads to retrieve the missing data.
1118          */
1119         maybeReadVirginBody(); // schedules all kinds of reads; TODO: rename
1120         return false;
1121     }
1122
1123     /** If we are done with parsing, check for errors */
1124
1125     err_type error = ERR_NONE;
1126
1127     if (flags.headers_parsed) { // parsed headers, possibly with errors
1128         // check for header parsing errors
1129         if (HttpReply *vrep = virginReply()) {
1130             const http_status s = vrep->sline.status;
1131             const HttpVersion &v = vrep->sline.version;
1132             if (s == HTTP_INVALID_HEADER && v != HttpVersion(0,9)) {
1133                 error = ERR_INVALID_RESP;
1134             } else
1135                 if (s == HTTP_HEADER_TOO_LARGE) {
1136                     fwd->dontRetry(true);
1137                     error = ERR_TOO_BIG;
1138                 } else {
1139                     return true; // done parsing, got reply, and no error
1140                 }
1141         } else {
1142             // parsed headers but got no reply
1143             error = ERR_INVALID_RESP;
1144         }
1145     } else {
1146         assert(eof);
1147         error = readBuf->hasContent() ?
1148                 ERR_INVALID_RESP : ERR_ZERO_SIZE_OBJECT;
1149     }
1150
1151     assert(error != ERR_NONE);
1152     entry->reset();
1153     fwd->fail(errorCon(error, HTTP_BAD_GATEWAY, fwd->request));
1154     flags.do_next_read = 0;
1155     comm_close(fd);
1156     return false; // quit on error
1157 }
1158
1159 /**
1160  * Call this when there is data from the origin server
1161  * which should be sent to either StoreEntry, or to ICAP...
1162  */
1163 void
1164 HttpStateData::writeReplyBody()
1165 {
1166     const char *data = readBuf->content();
1167     int len = readBuf->contentSize();
1168     addVirginReplyBody(data, len);
1169     readBuf->consume(len);
1170 }
1171
1172 bool
1173 HttpStateData::decodeAndWriteReplyBody()
1174 {
1175     const char *data = NULL;
1176     int len;
1177     bool status = false;
1178     assert(flags.chunked);
1179     assert(httpChunkDecoder);
1180     SQUID_ENTER_THROWING_CODE();
1181     MemBuf decodedData;
1182     decodedData.init();
1183     const bool done = httpChunkDecoder->parse(readBuf,&decodedData);
1184     len = decodedData.contentSize();
1185     data=decodedData.content();
1186     addVirginReplyBody(data, len);
1187     if (done) {
1188         lastChunk = 1;
1189         flags.do_next_read = 0;
1190     }
1191     SQUID_EXIT_THROWING_CODE(status);
1192     return status;
1193 }
1194
1195 /**
1196  * processReplyBody has two purposes:
1197  *  1 - take the reply body data, if any, and put it into either
1198  *      the StoreEntry, or give it over to ICAP.
1199  *  2 - see if we made it to the end of the response (persistent
1200  *      connections and such)
1201  */
1202 void
1203 HttpStateData::processReplyBody()
1204 {
1205     AsyncCall::Pointer call;
1206     IPAddress client_addr;
1207     bool ispinned = false;
1208
1209     if (!flags.headers_parsed) {
1210         flags.do_next_read = 1;
1211         maybeReadVirginBody();
1212         return;
1213     }
1214
1215 #if USE_ADAPTATION
1216     if (adaptationAccessCheckPending)
1217         return;
1218
1219 #endif
1220
1221     /*
1222      * At this point the reply headers have been parsed and consumed.
1223      * That means header content has been removed from readBuf and
1224      * it contains only body data.
1225      */
1226     if (flags.chunked) {
1227         if (!decodeAndWriteReplyBody()) {
1228             flags.do_next_read = 0;
1229             serverComplete();
1230             return;
1231         }
1232     } else
1233         writeReplyBody();
1234
1235     if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
1236         /*
1237          * The above writeReplyBody() call could ABORT this entry,
1238          * in that case, the server FD should already be closed.
1239          * there's nothing for us to do.
1240          */
1241         (void) 0;
1242     } else
1243         switch (persistentConnStatus()) {
1244         case INCOMPLETE_MSG:
1245             debugs(11, 5, "processReplyBody: INCOMPLETE_MSG");
1246             /* Wait for more data or EOF condition */
1247             if (flags.keepalive_broken) {
1248                 call = NULL;
1249                 commSetTimeout(fd, 10, call);
1250             } else {
1251                 call = NULL;
1252                 commSetTimeout(fd, Config.Timeout.read, call);
1253             }
1254
1255             flags.do_next_read = 1;
1256             break;
1257
1258         case COMPLETE_PERSISTENT_MSG:
1259             debugs(11, 5, "processReplyBody: COMPLETE_PERSISTENT_MSG");
1260             /* yes we have to clear all these! */
1261             call = NULL;
1262             commSetTimeout(fd, -1, call);
1263             flags.do_next_read = 0;
1264
1265             comm_remove_close_handler(fd, closeHandler);
1266             closeHandler = NULL;
1267             fwd->unregister(fd);
1268
1269             if (orig_request->flags.spoof_client_ip)
1270                 client_addr = orig_request->client_addr;
1271
1272
1273             if (request->flags.pinned) {
1274                 ispinned = true;
1275             } else if (request->flags.connection_auth && request->flags.auth_sent) {
1276                 ispinned = true;
1277             }
1278
1279             if (orig_request->pinnedConnection() && ispinned) {
1280                 orig_request->pinnedConnection()->pinConnection(fd, orig_request, _peer,
1281                         (request->flags.connection_auth != 0));
1282             } else if (_peer) {
1283                 if (_peer->options.originserver)
1284                     fwd->pconnPush(fd, _peer->name, orig_request->port, orig_request->GetHost(), client_addr);
1285                 else
1286                     fwd->pconnPush(fd, _peer->name, _peer->http_port, NULL, client_addr);
1287             } else {
1288                 fwd->pconnPush(fd, request->GetHost(), request->port, NULL, client_addr);
1289             }
1290
1291             fd = -1;
1292
1293             serverComplete();
1294             return;
1295
1296         case COMPLETE_NONPERSISTENT_MSG:
1297             debugs(11, 5, "processReplyBody: COMPLETE_NONPERSISTENT_MSG");
1298             serverComplete();
1299             return;
1300         }
1301
1302     maybeReadVirginBody();
1303 }
1304
1305 void
1306 HttpStateData::maybeReadVirginBody()
1307 {
1308     int read_sz = replyBodySpace(readBuf->spaceSize());
1309
1310     debugs(11,9, HERE << (flags.do_next_read ? "may" : "wont") <<
1311            " read up to " << read_sz << " bytes from FD " << fd);
1312
1313     /*
1314      * why <2? Because delayAwareRead() won't actually read if
1315      * you ask it to read 1 byte.  The delayed read request
1316      * just gets re-queued until the client side drains, then
1317      * the I/O thread hangs.  Better to not register any read
1318      * handler until we get a notification from someone that
1319      * its okay to read again.
1320      */
1321     if (read_sz < 2) {
1322         if (flags.headers_parsed)
1323             return;
1324         else
1325             read_sz = 1024;
1326     }
1327
1328     if (flags.do_next_read) {
1329         flags.do_next_read = 0;
1330         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1331         entry->delayAwareRead(fd, readBuf->space(read_sz), read_sz,
1332                               asyncCall(11, 5, "HttpStateData::readReply",
1333                                         Dialer(this, &HttpStateData::readReply)));
1334     }
1335 }
1336
1337 /*
1338  * This will be called when request write is complete.
1339  */
1340 void
1341 HttpStateData::sendComplete(const CommIoCbParams &io)
1342 {
1343     debugs(11, 5, "httpSendComplete: FD " << fd << ": size " << io.size << ": errflag " << io.flag << ".");
1344 #if URL_CHECKSUM_DEBUG
1345
1346     entry->mem_obj->checkUrlChecksum();
1347 #endif
1348
1349     if (io.size > 0) {
1350         fd_bytes(fd, io.size, FD_WRITE);
1351         kb_incr(&statCounter.server.all.kbytes_out, io.size);
1352         kb_incr(&statCounter.server.http.kbytes_out, io.size);
1353     }
1354
1355     if (io.flag == COMM_ERR_CLOSING)
1356         return;
1357
1358     if (io.flag) {
1359         ErrorState *err;
1360         err = errorCon(ERR_WRITE_ERROR, HTTP_BAD_GATEWAY, fwd->request);
1361         err->xerrno = io.xerrno;
1362         fwd->fail(err);
1363         comm_close(fd);
1364         return;
1365     }
1366
1367     /*
1368      * Set the read timeout here because it hasn't been set yet.
1369      * We only set the read timeout after the request has been
1370      * fully written to the server-side.  If we start the timeout
1371      * after connection establishment, then we are likely to hit
1372      * the timeout for POST/PUT requests that have very large
1373      * request bodies.
1374      */
1375     typedef CommCbMemFunT<HttpStateData, CommTimeoutCbParams> TimeoutDialer;
1376     AsyncCall::Pointer timeoutCall =  asyncCall(11, 5, "HttpStateData::httpTimeout",
1377                                       TimeoutDialer(this,&HttpStateData::httpTimeout));
1378
1379     commSetTimeout(fd, Config.Timeout.read, timeoutCall);
1380
1381     flags.request_sent = 1;
1382 }
1383
1384 // Close the HTTP server connection. Used by serverComplete().
1385 void
1386 HttpStateData::closeServer()
1387 {
1388     debugs(11,5, HERE << "closing HTTP server FD " << fd << " this " << this);
1389
1390     if (fd >= 0) {
1391         fwd->unregister(fd);
1392         comm_remove_close_handler(fd, closeHandler);
1393         closeHandler = NULL;
1394         comm_close(fd);
1395         fd = -1;
1396     }
1397 }
1398
1399 bool
1400 HttpStateData::doneWithServer() const
1401 {
1402     return fd < 0;
1403 }
1404
1405 /*
1406  * build request headers and append them to a given MemBuf
1407  * used by buildRequestPrefix()
1408  * note: initialised the HttpHeader, the caller is responsible for Clean()-ing
1409  */
1410 void
1411 HttpStateData::httpBuildRequestHeader(HttpRequest * request,
1412                                       HttpRequest * orig_request,
1413                                       StoreEntry * entry,
1414                                       HttpHeader * hdr_out,
1415                                       http_state_flags flags)
1416 {
1417     /* building buffer for complex strings */
1418 #define BBUF_SZ (MAX_URL+32)
1419     LOCAL_ARRAY(char, bbuf, BBUF_SZ);
1420     LOCAL_ARRAY(char, ntoabuf, MAX_IPSTRLEN);
1421     const HttpHeader *hdr_in = &orig_request->header;
1422     const HttpHeaderEntry *e = NULL;
1423     String strFwd;
1424     HttpHeaderPos pos = HttpHeaderInitPos;
1425     assert (hdr_out->owner == hoRequest);
1426     /* append our IMS header */
1427
1428     if (request->lastmod > -1)
1429         hdr_out->putTime(HDR_IF_MODIFIED_SINCE, request->lastmod);
1430
1431     bool we_do_ranges = decideIfWeDoRanges (orig_request);
1432
1433     String strConnection (hdr_in->getList(HDR_CONNECTION));
1434
1435     while ((e = hdr_in->getEntry(&pos)))
1436         copyOneHeaderFromClientsideRequestToUpstreamRequest(e, strConnection, request, orig_request, hdr_out, we_do_ranges, flags);
1437
1438     /* Abstraction break: We should interpret multipart/byterange responses
1439      * into offset-length data, and this works around our inability to do so.
1440      */
1441     if (!we_do_ranges && orig_request->multipartRangeRequest()) {
1442         /* don't cache the result */
1443         orig_request->flags.cachable = 0;
1444         /* pretend it's not a range request */
1445         delete orig_request->range;
1446         orig_request->range = NULL;
1447         orig_request->flags.range = 0;
1448     }
1449
1450     /* append Via */
1451     if (Config.onoff.via) {
1452         String strVia;
1453         strVia = hdr_in->getList(HDR_VIA);
1454         snprintf(bbuf, BBUF_SZ, "%d.%d %s",
1455                  orig_request->http_ver.major,
1456                  orig_request->http_ver.minor, ThisCache);
1457         strListAdd(&strVia, bbuf, ',');
1458         hdr_out->putStr(HDR_VIA, strVia.buf());
1459         strVia.clean();
1460     }
1461
1462 #if USE_SQUID_ESI
1463     {
1464         /* Append Surrogate-Capabilities */
1465         String strSurrogate (hdr_in->getList(HDR_SURROGATE_CAPABILITY));
1466         snprintf(bbuf, BBUF_SZ, "%s=\"Surrogate/1.0 ESI/1.0\"",
1467                  Config.Accel.surrogate_id);
1468         strListAdd(&strSurrogate, bbuf, ',');
1469         hdr_out->putStr(HDR_SURROGATE_CAPABILITY, strSurrogate.buf());
1470     }
1471 #endif
1472
1473     strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1474
1475     /** \pre Handle X-Forwarded-For */
1476     if (strcmp(opt_forwarded_for, "delete") != 0) {
1477         if (strcmp(opt_forwarded_for, "on") == 0) {
1478             /** If set to ON - append client IP or 'unknown'. */
1479             strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1480             if ( orig_request->client_addr.IsNoAddr() )
1481                 strListAdd(&strFwd, "unknown", ',');
1482             else
1483                 strListAdd(&strFwd, orig_request->client_addr.NtoA(ntoabuf, MAX_IPSTRLEN), ',');
1484         } else if (strcmp(opt_forwarded_for, "off") == 0) {
1485             /** If set to OFF - append 'unknown'. */
1486             strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1487             strListAdd(&strFwd, "unknown", ',');
1488         } else if (strcmp(opt_forwarded_for, "transparent") == 0) {
1489             /** If set to TRANSPARENT - pass through unchanged. */
1490             strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
1491         } else if (strcmp(opt_forwarded_for, "truncate") == 0) {
1492             /** If set to TRUNCATE - drop existing list and replace with client IP or 'unknown'. */
1493             if ( orig_request->client_addr.IsNoAddr() )
1494                 strFwd = "unknown";
1495             else
1496                 strFwd = orig_request->client_addr.NtoA(ntoabuf, MAX_IPSTRLEN);
1497         }
1498         if (strFwd.size() > 0)
1499             hdr_out->putStr(HDR_X_FORWARDED_FOR, strFwd.buf());
1500     }
1501     /** If set to DELETE - do not copy through. */
1502     strFwd.clean();
1503
1504     /* append Host if not there already */
1505     if (!hdr_out->has(HDR_HOST)) {
1506         if (orig_request->peer_domain) {
1507             hdr_out->putStr(HDR_HOST, orig_request->peer_domain);
1508         } else if (orig_request->port == urlDefaultPort(orig_request->protocol)) {
1509             /* use port# only if not default */
1510             hdr_out->putStr(HDR_HOST, orig_request->GetHost());
1511         } else {
1512             httpHeaderPutStrf(hdr_out, HDR_HOST, "%s:%d",
1513                               orig_request->GetHost(),
1514                               (int) orig_request->port);
1515         }
1516     }
1517
1518     /* append Authorization if known in URL, not in header and going direct */
1519     if (!hdr_out->has(HDR_AUTHORIZATION)) {
1520         if (!request->flags.proxying && *request->login) {
1521             httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1522                               base64_encode(request->login));
1523         }
1524     }
1525
1526     /* append Proxy-Authorization if configured for peer, and proxying */
1527     if (request->flags.proxying && orig_request->peer_login &&
1528             !hdr_out->has(HDR_PROXY_AUTHORIZATION)) {
1529         if (*orig_request->peer_login == '*') {
1530             /* Special mode, to pass the username to the upstream cache */
1531             char loginbuf[256];
1532             const char *username = "-";
1533
1534             if (orig_request->extacl_user.size())
1535                 username = orig_request->extacl_user.buf();
1536             else if (orig_request->auth_user_request)
1537                 username = orig_request->auth_user_request->username();
1538
1539             snprintf(loginbuf, sizeof(loginbuf), "%s%s", username, orig_request->peer_login + 1);
1540
1541             httpHeaderPutStrf(hdr_out, HDR_PROXY_AUTHORIZATION, "Basic %s",
1542                               base64_encode(loginbuf));
1543         } else if (strcmp(orig_request->peer_login, "PASS") == 0) {
1544             if (orig_request->extacl_user.size() && orig_request->extacl_passwd.size()) {
1545                 char loginbuf[256];
1546                 snprintf(loginbuf, sizeof(loginbuf), "%s:%s", orig_request->extacl_user.buf(), orig_request->extacl_passwd.buf());
1547                 httpHeaderPutStrf(hdr_out, HDR_PROXY_AUTHORIZATION, "Basic %s",
1548                                   base64_encode(loginbuf));
1549             }
1550         } else if (strcmp(orig_request->peer_login, "PROXYPASS") == 0) {
1551             /* Nothing to do */
1552         } else {
1553             httpHeaderPutStrf(hdr_out, HDR_PROXY_AUTHORIZATION, "Basic %s",
1554                               base64_encode(orig_request->peer_login));
1555         }
1556     }
1557
1558     /* append WWW-Authorization if configured for peer */
1559     if (flags.originpeer && orig_request->peer_login &&
1560             !hdr_out->has(HDR_AUTHORIZATION)) {
1561         if (strcmp(orig_request->peer_login, "PASS") == 0) {
1562             /* No credentials to forward.. (should have been done above if available) */
1563         } else if (strcmp(orig_request->peer_login, "PROXYPASS") == 0) {
1564             /* Special mode, convert proxy authentication to WWW authentication
1565             * (also applies to authentication provided by external acl)
1566              */
1567             const char *auth = hdr_in->getStr(HDR_PROXY_AUTHORIZATION);
1568
1569             if (auth && strncasecmp(auth, "basic ", 6) == 0) {
1570                 hdr_out->putStr(HDR_AUTHORIZATION, auth);
1571             } else if (orig_request->extacl_user.size() && orig_request->extacl_passwd.size()) {
1572                 char loginbuf[256];
1573                 snprintf(loginbuf, sizeof(loginbuf), "%s:%s", orig_request->extacl_user.buf(), orig_request->extacl_passwd.buf());
1574                 httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1575                                   base64_encode(loginbuf));
1576             }
1577         } else if (*orig_request->peer_login == '*') {
1578             /* Special mode, to pass the username to the upstream cache */
1579             char loginbuf[256];
1580             const char *username = "-";
1581
1582             if (orig_request->auth_user_request)
1583                 username = orig_request->auth_user_request->username();
1584             else if (orig_request->extacl_user.size())
1585                 username = orig_request->extacl_user.buf();
1586
1587             snprintf(loginbuf, sizeof(loginbuf), "%s%s", username, orig_request->peer_login + 1);
1588
1589             httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1590                               base64_encode(loginbuf));
1591         } else {
1592             /* Fixed login string */
1593             httpHeaderPutStrf(hdr_out, HDR_AUTHORIZATION, "Basic %s",
1594                               base64_encode(orig_request->peer_login));
1595         }
1596     }
1597
1598     /* append Cache-Control, add max-age if not there already */ {
1599         HttpHdrCc *cc = hdr_in->getCc();
1600
1601         if (!cc)
1602             cc = httpHdrCcCreate();
1603
1604         if (!EBIT_TEST(cc->mask, CC_MAX_AGE)) {
1605             const char *url =
1606                 entry ? entry->url() : urlCanonical(orig_request);
1607             httpHdrCcSetMaxAge(cc, getMaxAge(url));
1608
1609             if (request->urlpath.size())
1610                 assert(strstr(url, request->urlpath.buf()));
1611         }
1612
1613         /* Set no-cache if determined needed but not found */
1614         if (orig_request->flags.nocache && !hdr_in->has(HDR_PRAGMA))
1615             EBIT_SET(cc->mask, CC_NO_CACHE);
1616
1617         /* Enforce sibling relations */
1618         if (flags.only_if_cached)
1619             EBIT_SET(cc->mask, CC_ONLY_IF_CACHED);
1620
1621         hdr_out->putCc(cc);
1622
1623         httpHdrCcDestroy(cc);
1624     }
1625
1626     /* maybe append Connection: keep-alive */
1627     if (flags.keepalive) {
1628         if (flags.proxying) {
1629             hdr_out->putStr(HDR_PROXY_CONNECTION, "keep-alive");
1630         } else {
1631             hdr_out->putStr(HDR_CONNECTION, "keep-alive");
1632         }
1633     }
1634
1635     /* append Front-End-Https */
1636     if (flags.front_end_https) {
1637         if (flags.front_end_https == 1 || request->protocol == PROTO_HTTPS)
1638             hdr_out->putStr(HDR_FRONT_END_HTTPS, "On");
1639     }
1640
1641     /* Now mangle the headers. */
1642     if (Config2.onoff.mangle_request_headers)
1643         httpHdrMangleList(hdr_out, request, ROR_REQUEST);
1644
1645     strConnection.clean();
1646 }
1647
1648 void
1649 copyOneHeaderFromClientsideRequestToUpstreamRequest(const HttpHeaderEntry *e, String strConnection, HttpRequest * request, HttpRequest * orig_request, HttpHeader * hdr_out, int we_do_ranges, http_state_flags flags)
1650 {
1651     debugs(11, 5, "httpBuildRequestHeader: " << e->name.buf() << ": " << e->value.buf());
1652
1653     if (!httpRequestHdrAllowed(e, &strConnection)) {
1654         debugs(11, 2, "'" << e->name.buf() << "' header denied by anonymize_headers configuration");
1655         return;
1656     }
1657
1658     switch (e->id) {
1659
1660     case HDR_PROXY_AUTHORIZATION:
1661         /* Only pass on proxy authentication to peers for which
1662          * authentication forwarding is explicitly enabled
1663          */
1664
1665         if (flags.proxying && orig_request->peer_login &&
1666                 (strcmp(orig_request->peer_login, "PASS") == 0 ||
1667                  strcmp(orig_request->peer_login, "PROXYPASS") == 0)) {
1668             hdr_out->addEntry(e->clone());
1669         }
1670
1671         break;
1672
1673     case HDR_AUTHORIZATION:
1674         /* Pass on WWW authentication */
1675
1676         if (!flags.originpeer) {
1677             hdr_out->addEntry(e->clone());
1678         } else {
1679             /* In accelerators, only forward authentication if enabled
1680              * (see also below for proxy->server authentication)
1681              */
1682
1683             if (orig_request->peer_login &&
1684                     (strcmp(orig_request->peer_login, "PASS") == 0 ||
1685                      strcmp(orig_request->peer_login, "PROXYPASS") == 0)) {
1686                 hdr_out->addEntry(e->clone());
1687             }
1688         }
1689
1690         break;
1691
1692     case HDR_HOST:
1693         /*
1694          * Normally Squid rewrites the Host: header.
1695          * However, there is one case when we don't: If the URL
1696          * went through our redirector and the admin configured
1697          * 'redir_rewrites_host' to be off.
1698          */
1699         if (orig_request->peer_domain)
1700             hdr_out->putStr(HDR_HOST, orig_request->peer_domain);
1701         else if (request->flags.redirected && !Config.onoff.redir_rewrites_host)
1702             hdr_out->addEntry(e->clone());
1703         else {
1704             /* use port# only if not default */
1705
1706             if (orig_request->port == urlDefaultPort(orig_request->protocol)) {
1707                 hdr_out->putStr(HDR_HOST, orig_request->GetHost());
1708             } else {
1709                 httpHeaderPutStrf(hdr_out, HDR_HOST, "%s:%d",
1710                                   orig_request->GetHost(),
1711                                   (int) orig_request->port);
1712             }
1713         }
1714
1715         break;
1716
1717     case HDR_IF_MODIFIED_SINCE:
1718         /* append unless we added our own;
1719          * note: at most one client's ims header can pass through */
1720
1721         if (!hdr_out->has(HDR_IF_MODIFIED_SINCE))
1722             hdr_out->addEntry(e->clone());
1723
1724         break;
1725
1726     case HDR_MAX_FORWARDS:
1727         if (orig_request->method == METHOD_TRACE) {
1728             const int hops = e->getInt();
1729
1730             if (hops > 0)
1731                 hdr_out->putInt(HDR_MAX_FORWARDS, hops - 1);
1732         }
1733
1734         break;
1735
1736     case HDR_VIA:
1737         /* If Via is disabled then forward any received header as-is */
1738
1739         if (!Config.onoff.via)
1740             hdr_out->addEntry(e->clone());
1741
1742         break;
1743
1744     case HDR_RANGE:
1745
1746     case HDR_IF_RANGE:
1747
1748     case HDR_REQUEST_RANGE:
1749         if (!we_do_ranges)
1750             hdr_out->addEntry(e->clone());
1751
1752         break;
1753
1754     case HDR_PROXY_CONNECTION:
1755
1756     case HDR_CONNECTION:
1757
1758     case HDR_X_FORWARDED_FOR:
1759
1760     case HDR_CACHE_CONTROL:
1761         /* append these after the loop if needed */
1762         break;
1763
1764     case HDR_FRONT_END_HTTPS:
1765         if (!flags.front_end_https)
1766             hdr_out->addEntry(e->clone());
1767
1768         break;
1769
1770     default:
1771         /* pass on all other header fields */
1772         hdr_out->addEntry(e->clone());
1773     }
1774 }
1775
1776 bool
1777 HttpStateData::decideIfWeDoRanges (HttpRequest * orig_request)
1778 {
1779     bool result = true;
1780     /* decide if we want to do Ranges ourselves
1781      * and fetch the whole object now)
1782      * We want to handle Ranges ourselves iff
1783      *    - we can actually parse client Range specs
1784      *    - the specs are expected to be simple enough (e.g. no out-of-order ranges)
1785      *    - reply will be cachable
1786      * (If the reply will be uncachable we have to throw it away after
1787      *  serving this request, so it is better to forward ranges to
1788      *  the server and fetch only the requested content)
1789      */
1790
1791     if (NULL == orig_request->range || !orig_request->flags.cachable
1792             || orig_request->range->offsetLimitExceeded() || orig_request->flags.connection_auth)
1793         result = false;
1794
1795     debugs(11, 8, "decideIfWeDoRanges: range specs: " <<
1796            orig_request->range << ", cachable: " <<
1797            orig_request->flags.cachable << "; we_do_ranges: " << result);
1798
1799     return result;
1800 }
1801
1802 /* build request prefix and append it to a given MemBuf;
1803  * return the length of the prefix */
1804 mb_size_t
1805 HttpStateData::buildRequestPrefix(HttpRequest * request,
1806                                   HttpRequest * orig_request,
1807                                   StoreEntry * entry,
1808                                   MemBuf * mb,
1809                                   http_state_flags flags)
1810 {
1811     const int offset = mb->size;
1812     HttpVersion httpver(1, 0);
1813     mb->Printf("%s %s HTTP/%d.%d\r\n",
1814                RequestMethodStr(request->method),
1815                request->urlpath.size() ? request->urlpath.buf() : "/",
1816                httpver.major,httpver.minor);
1817     /* build and pack headers */
1818     {
1819         HttpHeader hdr(hoRequest);
1820         Packer p;
1821         httpBuildRequestHeader(request, orig_request, entry, &hdr, flags);
1822
1823         if (request->flags.pinned && request->flags.connection_auth)
1824             request->flags.auth_sent = 1;
1825         else if (hdr.has(HDR_AUTHORIZATION))
1826             request->flags.auth_sent = 1;
1827
1828         packerToMemInit(&p, mb);
1829         hdr.packInto(&p);
1830         hdr.clean();
1831         packerClean(&p);
1832     }
1833     /* append header terminator */
1834     mb->append(crlf, 2);
1835     return mb->size - offset;
1836 }
1837
1838 /* This will be called when connect completes. Write request. */
1839 bool
1840 HttpStateData::sendRequest()
1841 {
1842     MemBuf mb;
1843
1844     debugs(11, 5, "httpSendRequest: FD " << fd << ", request " << request << ", this " << this << ".");
1845     typedef CommCbMemFunT<HttpStateData, CommTimeoutCbParams> TimeoutDialer;
1846     AsyncCall::Pointer timeoutCall =  asyncCall(11, 5, "HttpStateData::httpTimeout",
1847                                       TimeoutDialer(this,&HttpStateData::httpTimeout));
1848     commSetTimeout(fd, Config.Timeout.lifetime, timeoutCall);
1849     flags.do_next_read = 1;
1850     maybeReadVirginBody();
1851
1852     if (orig_request->body_pipe != NULL) {
1853         if (!startRequestBodyFlow()) // register to receive body data
1854             return false;
1855         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1856         Dialer dialer(this, &HttpStateData::sentRequestBody);
1857         requestSender = asyncCall(11,5, "HttpStateData::sentRequestBody", dialer);
1858     } else {
1859         assert(!requestBodySource);
1860         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1861         Dialer dialer(this, &HttpStateData::sendComplete);
1862         requestSender = asyncCall(11,5, "HttpStateData::SendComplete", dialer);
1863     }
1864
1865     if (_peer != NULL) {
1866         if (_peer->options.originserver) {
1867             flags.proxying = 0;
1868             flags.originpeer = 1;
1869         } else {
1870             flags.proxying = 1;
1871             flags.originpeer = 0;
1872         }
1873     } else {
1874         flags.proxying = 0;
1875         flags.originpeer = 0;
1876     }
1877
1878     /*
1879      * Is keep-alive okay for all request methods?
1880      */
1881     if (orig_request->flags.must_keepalive)
1882         flags.keepalive = 1;
1883     else if (!Config.onoff.server_pconns)
1884         flags.keepalive = 0;
1885     else if (_peer == NULL)
1886         flags.keepalive = 1;
1887     else if (_peer->stats.n_keepalives_sent < 10)
1888         flags.keepalive = 1;
1889     else if ((double) _peer->stats.n_keepalives_recv /
1890              (double) _peer->stats.n_keepalives_sent > 0.50)
1891         flags.keepalive = 1;
1892
1893     if (_peer) {
1894         if (neighborType(_peer, request) == PEER_SIBLING &&
1895                 !_peer->options.allow_miss)
1896             flags.only_if_cached = 1;
1897
1898         flags.front_end_https = _peer->front_end_https;
1899     }
1900
1901     mb.init();
1902     buildRequestPrefix(request, orig_request, entry, &mb, flags);
1903     debugs(11, 6, "httpSendRequest: FD " << fd << ":\n" << mb.buf);
1904     comm_write_mbuf(fd, &mb, requestSender);
1905
1906     return true;
1907 }
1908
1909 void
1910 httpStart(FwdState *fwd)
1911 {
1912     debugs(11, 3, "httpStart: \"" << RequestMethodStr(fwd->request->method) << " " << fwd->entry->url() << "\"" );
1913     HttpStateData *httpState = new HttpStateData(fwd);
1914
1915     if (!httpState->sendRequest()) {
1916         debugs(11, 3, "httpStart: aborted");
1917         delete httpState;
1918         return;
1919     }
1920
1921     statCounter.server.all.requests++;
1922     statCounter.server.http.requests++;
1923
1924     /*
1925      * We used to set the read timeout here, but not any more.
1926      * Now its set in httpSendComplete() after the full request,
1927      * including request body, has been written to the server.
1928      */
1929 }
1930
1931 void
1932 HttpStateData::doneSendingRequestBody()
1933 {
1934     ACLChecklist ch;
1935     debugs(11,5, HERE << "doneSendingRequestBody: FD " << fd);
1936     ch.request = HTTPMSGLOCK(request);
1937
1938     if (Config.accessList.brokenPosts)
1939         ch.accessList = cbdataReference(Config.accessList.brokenPosts);
1940
1941     /* cbdataReferenceDone() happens in either fastCheck() or ~ACLCheckList */
1942
1943     if (!Config.accessList.brokenPosts) {
1944         debugs(11, 5, "doneSendingRequestBody: No brokenPosts list");
1945         CommIoCbParams io(NULL);
1946         io.fd=fd;
1947         io.flag=COMM_OK;
1948         sendComplete(io);
1949     } else if (!ch.fastCheck()) {
1950         debugs(11, 5, "doneSendingRequestBody: didn't match brokenPosts");
1951         CommIoCbParams io(NULL);
1952         io.fd=fd;
1953         io.flag=COMM_OK;
1954         sendComplete(io);
1955     } else {
1956         debugs(11, 2, "doneSendingRequestBody: matched brokenPosts");
1957         typedef CommCbMemFunT<HttpStateData, CommIoCbParams> Dialer;
1958         Dialer dialer(this, &HttpStateData::sendComplete);
1959         AsyncCall::Pointer call= asyncCall(11,5, "HttpStateData::SendComplete", dialer);
1960         comm_write(fd, "\r\n", 2, call);
1961     }
1962 }
1963
1964 // more origin request body data is available
1965 void
1966 HttpStateData::handleMoreRequestBodyAvailable()
1967 {
1968     if (eof || fd < 0) {
1969         // XXX: we should check this condition in other callbacks then!
1970         // TODO: Check whether this can actually happen: We should unsubscribe
1971         // as a body consumer when the above condition(s) are detected.
1972         debugs(11, 1, HERE << "Transaction aborted while reading HTTP body");
1973         return;
1974     }
1975
1976     assert(requestBodySource != NULL);
1977
1978     if (requestBodySource->buf().hasContent()) {
1979         // XXX: why does not this trigger a debug message on every request?
1980
1981         if (flags.headers_parsed && !flags.abuse_detected) {
1982             flags.abuse_detected = 1;
1983             debugs(11, 1, "http handleMoreRequestBodyAvailable: Likely proxy abuse detected '" << orig_request->client_addr << "' -> '" << entry->url() << "'" );
1984
1985             if (virginReply()->sline.status == HTTP_INVALID_HEADER) {
1986                 comm_close(fd);
1987                 return;
1988             }
1989         }
1990     }
1991
1992     HttpStateData::handleMoreRequestBodyAvailable();
1993 }
1994
1995 // premature end of the request body
1996 void
1997 HttpStateData::handleRequestBodyProducerAborted()
1998 {
1999     ServerStateData::handleRequestBodyProducerAborted();
2000     // XXX: SendComplete(COMM_ERR_CLOSING) does little. Is it enough?
2001     CommIoCbParams io(NULL);
2002     io.fd=fd;
2003     io.flag=COMM_ERR_CLOSING;
2004     sendComplete(io);
2005 }
2006
2007 // called when we wrote request headers(!) or a part of the body
2008 void
2009 HttpStateData::sentRequestBody(const CommIoCbParams &io)
2010 {
2011     if (io.size > 0)
2012         kb_incr(&statCounter.server.http.kbytes_out, io.size);
2013
2014     ServerStateData::sentRequestBody(io);
2015 }
2016
2017 // Quickly abort the transaction
2018 // TODO: destruction should be sufficient as the destructor should cleanup,
2019 // including canceling close handlers
2020 void
2021 HttpStateData::abortTransaction(const char *reason)
2022 {
2023     debugs(11,5, HERE << "aborting transaction for " << reason <<
2024            "; FD " << fd << ", this " << this);
2025
2026     if (fd >= 0) {
2027         comm_close(fd);
2028         return;
2029     }
2030
2031     fwd->handleUnregisteredServerEnd();
2032     deleteThis("HttpStateData::abortTransaction");
2033 }
2034
2035 #if DEAD_CODE
2036 void
2037 httpBuildVersion(HttpVersion * version, unsigned int major, unsigned int minor)
2038 {
2039     version->major = major;
2040     version->minor = minor;
2041 }
2042 #endif
2043
2044 HttpRequest *
2045 HttpStateData::originalRequest()
2046 {
2047     return orig_request;
2048 }