methods/http.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: http.cc,v 1.59 2004/05/08 19:42:35 mdz Exp $
   4 /* ######################################################################
   5
   6    HTTP Acquire Method - This is the HTTP acquire method for APT.
   7
   8    It uses HTTP/1.1 and many of the fancy options there-in, such as
   9    pipelining, range, if-range and so on.
  10
  11    It is based on a doubly buffered select loop. A groupe of requests are
  12    fed into a single output buffer that is constantly fed out the
  13    socket. This provides ideal pipelining as in many cases all of the
  14    requests will fit into a single packet. The input socket is buffered
  15    the same way and fed into the fd for the file (may be a pipe in future).
  16
  17    This double buffering provides fairly substantial transfer rates,
  18    compared to wget the http method is about 4% faster. Most importantly,
  19    when HTTP is compared with FTP as a protocol the speed difference is
  20    huge. In tests over the internet from two sites to llug (via ATM) this
  21    program got 230k/s sustained http transfer rates. FTP on the other
  22    hand topped out at 170k/s. That combined with the time to setup the
  23    FTP connection makes HTTP a vastly superior protocol.
  24
  25    ##################################################################### */
  26                                                                         /*}}}*/
  27 // Include Files                                                        /*{{{*/
  28 #include <config.h>
  29
  30 #include <apt-pkg/fileutl.h>
  31 #include <apt-pkg/configuration.h>
  32 #include <apt-pkg/error.h>
  33 #include <apt-pkg/hashes.h>
  34 #include <apt-pkg/netrc.h>
  35 #include <apt-pkg/strutl.h>
  36 #include <apt-pkg/proxy.h>
  37
  38 #include <stddef.h>
  39 #include <stdlib.h>
  40 #include <sys/select.h>
  41 #include <cstring>
  42 #include <sys/stat.h>
  43 #include <sys/time.h>
  44 #include <unistd.h>
  45 #include <stdio.h>
  46 #include <errno.h>
  47 #include <iostream>
  48 #include <sstream>
  49
  50 #include "config.h"
  51 #include "connect.h"
  52 #include "http.h"
  53
  54 #include <apti18n.h>
  55                                                                         /*}}}*/
  56 using namespace std;
  57
  58 unsigned long long CircleBuf::BwReadLimit=0;
  59 unsigned long long CircleBuf::BwTickReadData=0;
  60 struct timeval CircleBuf::BwReadTick={0,0};
  61 const unsigned int CircleBuf::BW_HZ=10;
  62
  63 // CircleBuf::CircleBuf - Circular input buffer                         /*{{{*/
  64 // ---------------------------------------------------------------------
  65 /* */
  66 CircleBuf::CircleBuf(unsigned long long Size)
  67    : Size(Size), Hash(NULL), TotalWriten(0)
  68 {
  69    Buf = new unsigned char[Size];
  70    Reset();
  71
  72    CircleBuf::BwReadLimit = _config->FindI("Acquire::http::Dl-Limit",0)*1024;
  73 }
  74                                                                         /*}}}*/
  75 // CircleBuf::Reset - Reset to the default state                        /*{{{*/
  76 // ---------------------------------------------------------------------
  77 /* */
  78 void CircleBuf::Reset()
  79 {
  80    InP = 0;
  81    OutP = 0;
  82    StrPos = 0;
  83    TotalWriten = 0;
  84    MaxGet = (unsigned long long)-1;
  85    OutQueue = string();
  86    if (Hash != NULL)
  87    {
  88       delete Hash;
  89       Hash = NULL;
  90    }
  91 }
  92                                                                         /*}}}*/
  93 // CircleBuf::Read - Read from a FD into the circular buffer            /*{{{*/
  94 // ---------------------------------------------------------------------
  95 /* This fills up the buffer with as much data as is in the FD, assuming it
  96    is non-blocking.. */
  97 bool CircleBuf::Read(int Fd)
  98 {
  99    while (1)
 100    {
 101       // Woops, buffer is full
 102       if (InP - OutP == Size)
 103          return true;
 104
 105       // what's left to read in this tick
 106       unsigned long long const BwReadMax = CircleBuf::BwReadLimit/BW_HZ;
 107
 108       if(CircleBuf::BwReadLimit) {
 109          struct timeval now;
 110          gettimeofday(&now,0);
 111
 112          unsigned long long d = (now.tv_sec-CircleBuf::BwReadTick.tv_sec)*1000000 +
 113             now.tv_usec-CircleBuf::BwReadTick.tv_usec;
 114          if(d > 1000000/BW_HZ) {
 115             CircleBuf::BwReadTick = now;
 116             CircleBuf::BwTickReadData = 0;
 117          }
 118
 119          if(CircleBuf::BwTickReadData >= BwReadMax) {
 120             usleep(1000000/BW_HZ);
 121             return true;
 122          }
 123       }
 124
 125       // Write the buffer segment
 126       ssize_t Res;
 127       if(CircleBuf::BwReadLimit) {
 128          Res = read(Fd,Buf + (InP%Size),
 129                     BwReadMax > LeftRead() ? LeftRead() : BwReadMax);
 130       } else
 131          Res = read(Fd,Buf + (InP%Size),LeftRead());
 132
 133       if(Res > 0 && BwReadLimit > 0)
 134          CircleBuf::BwTickReadData += Res;
 135
 136       if (Res == 0)
 137          return false;
 138       if (Res < 0)
 139       {
 140          if (errno == EAGAIN)
 141             return true;
 142          return false;
 143       }
 144
 145       if (InP == 0)
 146          gettimeofday(&Start,0);
 147       InP += Res;
 148    }
 149 }
 150                                                                         /*}}}*/
 151 // CircleBuf::Read - Put the string into the buffer                     /*{{{*/
 152 // ---------------------------------------------------------------------
 153 /* This will hold the string in and fill the buffer with it as it empties */
 154 bool CircleBuf::Read(string Data)
 155 {
 156    OutQueue += Data;
 157    FillOut();
 158    return true;
 159 }
 160                                                                         /*}}}*/
 161 // CircleBuf::FillOut - Fill the buffer from the output queue           /*{{{*/
 162 // ---------------------------------------------------------------------
 163 /* */
 164 void CircleBuf::FillOut()
 165 {
 166    if (OutQueue.empty() == true)
 167       return;
 168    while (1)
 169    {
 170       // Woops, buffer is full
 171       if (InP - OutP == Size)
 172          return;
 173
 174       // Write the buffer segment
 175       unsigned long long Sz = LeftRead();
 176       if (OutQueue.length() - StrPos < Sz)
 177          Sz = OutQueue.length() - StrPos;
 178       memcpy(Buf + (InP%Size),OutQueue.c_str() + StrPos,Sz);
 179
 180       // Advance
 181       StrPos += Sz;
 182       InP += Sz;
 183       if (OutQueue.length() == StrPos)
 184       {
 185          StrPos = 0;
 186          OutQueue = "";
 187          return;
 188       }
 189    }
 190 }
 191                                                                         /*}}}*/
 192 // CircleBuf::Write - Write from the buffer into a FD                   /*{{{*/
 193 // ---------------------------------------------------------------------
 194 /* This empties the buffer into the FD. */
 195 bool CircleBuf::Write(int Fd)
 196 {
 197    while (1)
 198    {
 199       FillOut();
 200
 201       // Woops, buffer is empty
 202       if (OutP == InP)
 203          return true;
 204
 205       if (OutP == MaxGet)
 206          return true;
 207
 208       // Write the buffer segment
 209       ssize_t Res;
 210       Res = write(Fd,Buf + (OutP%Size),LeftWrite());
 211
 212       if (Res == 0)
 213          return false;
 214       if (Res < 0)
 215       {
 216          if (errno == EAGAIN)
 217             return true;
 218
 219          return false;
 220       }
 221
 222       TotalWriten += Res;
 223
 224       if (Hash != NULL)
 225          Hash->Add(Buf + (OutP%Size),Res);
 226
 227       OutP += Res;
 228    }
 229 }
 230                                                                         /*}}}*/
 231 // CircleBuf::WriteTillEl - Write from the buffer to a string           /*{{{*/
 232 // ---------------------------------------------------------------------
 233 /* This copies till the first empty line */
 234 bool CircleBuf::WriteTillEl(string &Data,bool Single)
 235 {
 236    // We cheat and assume it is unneeded to have more than one buffer load
 237    for (unsigned long long I = OutP; I < InP; I++)
 238    {
 239       if (Buf[I%Size] != '\n')
 240          continue;
 241       ++I;
 242
 243       if (Single == false)
 244       {
 245          if (I < InP  && Buf[I%Size] == '\r')
 246             ++I;
 247          if (I >= InP || Buf[I%Size] != '\n')
 248             continue;
 249          ++I;
 250       }
 251
 252       Data = "";
 253       while (OutP < I)
 254       {
 255          unsigned long long Sz = LeftWrite();
 256          if (Sz == 0)
 257             return false;
 258          if (I - OutP < Sz)
 259             Sz = I - OutP;
 260          Data += string((char *)(Buf + (OutP%Size)),Sz);
 261          OutP += Sz;
 262       }
 263       return true;
 264    }
 265    return false;
 266 }
 267                                                                         /*}}}*/
 268 // CircleBuf::Stats - Print out stats information                       /*{{{*/
 269 // ---------------------------------------------------------------------
 270 /* */
 271 void CircleBuf::Stats()
 272 {
 273    if (InP == 0)
 274       return;
 275
 276    struct timeval Stop;
 277    gettimeofday(&Stop,0);
 278 /*   float Diff = Stop.tv_sec - Start.tv_sec +
 279              (float)(Stop.tv_usec - Start.tv_usec)/1000000;
 280    clog << "Got " << InP << " in " << Diff << " at " << InP/Diff << endl;*/
 281 }
 282                                                                         /*}}}*/
 283 CircleBuf::~CircleBuf()
 284 {
 285    delete [] Buf;
 286    delete Hash;
 287 }
 288
 289 // HttpServerState::HttpServerState - Constructor                       /*{{{*/
 290 HttpServerState::HttpServerState(URI Srv,HttpMethod *Owner) : ServerState(Srv, Owner), In(64*1024), Out(4*1024)
 291 {
 292    TimeOut = _config->FindI("Acquire::http::Timeout",TimeOut);
 293    Reset();
 294 }
 295                                                                         /*}}}*/
 296 // HttpServerState::Open - Open a connection to the server              /*{{{*/
 297 // ---------------------------------------------------------------------
 298 /* This opens a connection to the server. */
 299 bool HttpServerState::Open()
 300 {
 301    // Use the already open connection if possible.
 302    if (ServerFd != -1)
 303       return true;
 304
 305    Close();
 306    In.Reset();
 307    Out.Reset();
 308    Persistent = true;
 309
 310    // Determine the proxy setting
 311    AutoDetectProxy(ServerName);
 312    string SpecificProxy = _config->Find("Acquire::http::Proxy::" + ServerName.Host);
 313    if (!SpecificProxy.empty())
 314    {
 315            if (SpecificProxy == "DIRECT")
 316                    Proxy = "";
 317            else
 318                    Proxy = SpecificProxy;
 319    }
 320    else
 321    {
 322            string DefProxy = _config->Find("Acquire::http::Proxy");
 323            if (!DefProxy.empty())
 324            {
 325                    Proxy = DefProxy;
 326            }
 327            else
 328            {
 329                    char* result = getenv("http_proxy");
 330                    Proxy = result ? result : "";
 331            }
 332    }
 333
 334    // Parse no_proxy, a , separated list of domains
 335    if (getenv("no_proxy") != 0)
 336    {
 337       if (CheckDomainList(ServerName.Host,getenv("no_proxy")) == true)
 338          Proxy = "";
 339    }
 340
 341    // Determine what host and port to use based on the proxy settings
 342    int Port = 0;
 343    string Host;
 344    if (Proxy.empty() == true || Proxy.Host.empty() == true)
 345    {
 346       if (ServerName.Port != 0)
 347          Port = ServerName.Port;
 348       Host = ServerName.Host;
 349    }
 350    else if (Proxy.Access != "http")
 351       return _error->Error("Unsupported proxy configured: %s", URI::SiteOnly(Proxy).c_str());
 352    else
 353    {
 354       if (Proxy.Port != 0)
 355          Port = Proxy.Port;
 356       Host = Proxy.Host;
 357    }
 358
 359    // Connect to the remote server
 360    if (Connect(Host,Port,"http",80,ServerFd,TimeOut,Owner) == false)
 361       return false;
 362
 363    return true;
 364 }
 365                                                                         /*}}}*/
 366 // HttpServerState::Close - Close a connection to the server            /*{{{*/
 367 // ---------------------------------------------------------------------
 368 /* */
 369 bool HttpServerState::Close()
 370 {
 371    close(ServerFd);
 372    ServerFd = -1;
 373    return true;
 374 }
 375                                                                         /*}}}*/
 376 // HttpServerState::RunData - Transfer the data from the socket         /*{{{*/
 377 bool HttpServerState::RunData(FileFd * const File)
 378 {
 379    State = Data;
 380
 381    // Chunked transfer encoding is fun..
 382    if (Encoding == Chunked)
 383    {
 384       while (1)
 385       {
 386          // Grab the block size
 387          bool Last = true;
 388          string Data;
 389          In.Limit(-1);
 390          do
 391          {
 392             if (In.WriteTillEl(Data,true) == true)
 393                break;
 394          }
 395          while ((Last = Go(false, File)) == true);
 396
 397          if (Last == false)
 398             return false;
 399
 400          // See if we are done
 401          unsigned long long Len = strtoull(Data.c_str(),0,16);
 402          if (Len == 0)
 403          {
 404             In.Limit(-1);
 405
 406             // We have to remove the entity trailer
 407             Last = true;
 408             do
 409             {
 410                if (In.WriteTillEl(Data,true) == true && Data.length() <= 2)
 411                   break;
 412             }
 413             while ((Last = Go(false, File)) == true);
 414             if (Last == false)
 415                return false;
 416             return !_error->PendingError();
 417          }
 418
 419          // Transfer the block
 420          In.Limit(Len);
 421          while (Go(true, File) == true)
 422             if (In.IsLimit() == true)
 423                break;
 424
 425          // Error
 426          if (In.IsLimit() == false)
 427             return false;
 428
 429          // The server sends an extra new line before the next block specifier..
 430          In.Limit(-1);
 431          Last = true;
 432          do
 433          {
 434             if (In.WriteTillEl(Data,true) == true)
 435                break;
 436          }
 437          while ((Last = Go(false, File)) == true);
 438          if (Last == false)
 439             return false;
 440       }
 441    }
 442    else
 443    {
 444       /* Closes encoding is used when the server did not specify a size, the
 445          loss of the connection means we are done */
 446       if (JunkSize != 0)
 447          In.Limit(JunkSize);
 448       else if (DownloadSize != 0)
 449          In.Limit(DownloadSize);
 450       else if (Persistent == false)
 451          In.Limit(-1);
 452
 453       // Just transfer the whole block.
 454       do
 455       {
 456          if (In.IsLimit() == false)
 457             continue;
 458
 459          In.Limit(-1);
 460          return !_error->PendingError();
 461       }
 462       while (Go(true, File) == true);
 463    }
 464
 465    return Owner->Flush() && !_error->PendingError();
 466 }
 467                                                                         /*}}}*/
 468 bool HttpServerState::RunDataToDevNull()                                /*{{{*/
 469 {
 470    FileFd DevNull("/dev/null", FileFd::WriteOnly);
 471    return RunData(&DevNull);
 472 }
 473                                                                         /*}}}*/
 474 bool HttpServerState::ReadHeaderLines(std::string &Data)                /*{{{*/
 475 {
 476    return In.WriteTillEl(Data);
 477 }
 478                                                                         /*}}}*/
 479 bool HttpServerState::LoadNextResponse(bool const ToFile, FileFd * const File)/*{{{*/
 480 {
 481    return Go(ToFile, File);
 482 }
 483                                                                         /*}}}*/
 484 bool HttpServerState::WriteResponse(const std::string &Data)            /*{{{*/
 485 {
 486    return Out.Read(Data);
 487 }
 488                                                                         /*}}}*/
 489 APT_PURE bool HttpServerState::IsOpen()                                 /*{{{*/
 490 {
 491    return (ServerFd != -1);
 492 }
 493                                                                         /*}}}*/
 494 bool HttpServerState::InitHashes(HashStringList const &ExpectedHashes)  /*{{{*/
 495 {
 496    delete In.Hash;
 497    In.Hash = new Hashes(ExpectedHashes);
 498    return true;
 499 }
 500                                                                         /*}}}*/
 501
 502 APT_PURE Hashes * HttpServerState::GetHashes()                          /*{{{*/
 503 {
 504    return In.Hash;
 505 }
 506                                                                         /*}}}*/
 507 // HttpServerState::Die - The server has closed the connection.         /*{{{*/
 508 bool HttpServerState::Die(FileFd * const File)
 509 {
 510    unsigned int LErrno = errno;
 511
 512    // Dump the buffer to the file
 513    if (State == ServerState::Data)
 514    {
 515       if (File == nullptr)
 516          return true;
 517       // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
 518       // can't be set
 519       if (File->Name() != "/dev/null")
 520          SetNonBlock(File->Fd(),false);
 521       while (In.WriteSpace() == true)
 522       {
 523          if (In.Write(File->Fd()) == false)
 524             return _error->Errno("write",_("Error writing to the file"));
 525
 526          // Done
 527          if (In.IsLimit() == true)
 528             return true;
 529       }
 530    }
 531
 532    // See if this is because the server finished the data stream
 533    if (In.IsLimit() == false && State != HttpServerState::Header &&
 534        Persistent == true)
 535    {
 536       Close();
 537       if (LErrno == 0)
 538          return _error->Error(_("Error reading from server. Remote end closed connection"));
 539       errno = LErrno;
 540       return _error->Errno("read",_("Error reading from server"));
 541    }
 542    else
 543    {
 544       In.Limit(-1);
 545
 546       // Nothing left in the buffer
 547       if (In.WriteSpace() == false)
 548          return false;
 549
 550       // We may have got multiple responses back in one packet..
 551       Close();
 552       return true;
 553    }
 554
 555    return false;
 556 }
 557                                                                         /*}}}*/
 558 // HttpServerState::Flush - Dump the buffer into the file               /*{{{*/
 559 // ---------------------------------------------------------------------
 560 /* This takes the current input buffer from the Server FD and writes it
 561    into the file */
 562 bool HttpServerState::Flush(FileFd * const File)
 563 {
 564    if (File != NULL)
 565    {
 566       // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
 567       // can't be set
 568       if (File->Name() != "/dev/null")
 569          SetNonBlock(File->Fd(),false);
 570       if (In.WriteSpace() == false)
 571          return true;
 572
 573       while (In.WriteSpace() == true)
 574       {
 575          if (In.Write(File->Fd()) == false)
 576             return _error->Errno("write",_("Error writing to file"));
 577          if (In.IsLimit() == true)
 578             return true;
 579       }
 580
 581       if (In.IsLimit() == true || Persistent == false)
 582          return true;
 583    }
 584    return false;
 585 }
 586                                                                         /*}}}*/
 587 // HttpServerState::Go - Run a single loop                              /*{{{*/
 588 // ---------------------------------------------------------------------
 589 /* This runs the select loop over the server FDs, Output file FDs and
 590    stdin. */
 591 bool HttpServerState::Go(bool ToFile, FileFd * const File)
 592 {
 593    // Server has closed the connection
 594    if (ServerFd == -1 && (In.WriteSpace() == false ||
 595                                ToFile == false))
 596       return false;
 597
 598    fd_set rfds,wfds;
 599    FD_ZERO(&rfds);
 600    FD_ZERO(&wfds);
 601
 602    /* Add the server. We only send more requests if the connection will
 603       be persisting */
 604    if (Out.WriteSpace() == true && ServerFd != -1
 605        && Persistent == true)
 606       FD_SET(ServerFd,&wfds);
 607    if (In.ReadSpace() == true && ServerFd != -1)
 608       FD_SET(ServerFd,&rfds);
 609
 610    // Add the file
 611    int FileFD = -1;
 612    if (File != NULL)
 613       FileFD = File->Fd();
 614
 615    if (In.WriteSpace() == true && ToFile == true && FileFD != -1)
 616       FD_SET(FileFD,&wfds);
 617
 618    // Add stdin
 619    if (_config->FindB("Acquire::http::DependOnSTDIN", true) == true)
 620       FD_SET(STDIN_FILENO,&rfds);
 621
 622    // Figure out the max fd
 623    int MaxFd = FileFD;
 624    if (MaxFd < ServerFd)
 625       MaxFd = ServerFd;
 626
 627    // Select
 628    struct timeval tv;
 629    tv.tv_sec = TimeOut;
 630    tv.tv_usec = 0;
 631    int Res = 0;
 632    if ((Res = select(MaxFd+1,&rfds,&wfds,0,&tv)) < 0)
 633    {
 634       if (errno == EINTR)
 635          return true;
 636       return _error->Errno("select",_("Select failed"));
 637    }
 638
 639    if (Res == 0)
 640    {
 641       _error->Error(_("Connection timed out"));
 642       return Die(File);
 643    }
 644
 645    // Handle server IO
 646    if (ServerFd != -1 && FD_ISSET(ServerFd,&rfds))
 647    {
 648       errno = 0;
 649       if (In.Read(ServerFd) == false)
 650          return Die(File);
 651    }
 652
 653    if (ServerFd != -1 && FD_ISSET(ServerFd,&wfds))
 654    {
 655       errno = 0;
 656       if (Out.Write(ServerFd) == false)
 657          return Die(File);
 658    }
 659
 660    // Send data to the file
 661    if (FileFD != -1 && FD_ISSET(FileFD,&wfds))
 662    {
 663       if (In.Write(FileFD) == false)
 664          return _error->Errno("write",_("Error writing to output file"));
 665    }
 666
 667    if (MaximumSize > 0 && File && File->Tell() > MaximumSize)
 668    {
 669       Owner->SetFailReason("MaximumSizeExceeded");
 670       return _error->Error("Writing more data than expected (%llu > %llu)",
 671                            File->Tell(), MaximumSize);
 672    }
 673
 674    // Handle commands from APT
 675    if (FD_ISSET(STDIN_FILENO,&rfds))
 676    {
 677       if (Owner->Run(true) != -1)
 678          exit(100);
 679    }
 680
 681    return true;
 682 }
 683                                                                         /*}}}*/
 684
 685 // HttpMethod::SendReq - Send the HTTP request                          /*{{{*/
 686 // ---------------------------------------------------------------------
 687 /* This places the http request in the outbound buffer */
 688 void HttpMethod::SendReq(FetchItem *Itm)
 689 {
 690    URI Uri = Itm->Uri;
 691
 692    // The HTTP server expects a hostname with a trailing :port
 693    std::stringstream Req;
 694    string ProperHost;
 695
 696    if (Uri.Host.find(':') != string::npos)
 697       ProperHost = '[' + Uri.Host + ']';
 698    else
 699       ProperHost = Uri.Host;
 700
 701    /* RFC 2616 §5.1.2 requires absolute URIs for requests to proxies,
 702       but while its a must for all servers to accept absolute URIs,
 703       it is assumed clients will sent an absolute path for non-proxies */
 704    std::string requesturi;
 705    if (Server->Proxy.empty() == true || Server->Proxy.Host.empty())
 706       requesturi = Uri.Path;
 707    else
 708       requesturi = Itm->Uri;
 709
 710    // The "+" is encoded as a workaround for a amazon S3 bug
 711    // see LP bugs #1003633 and #1086997.
 712    requesturi = QuoteString(requesturi, "+~ ");
 713
 714    /* Build the request. No keep-alive is included as it is the default
 715       in 1.1, can cause problems with proxies, and we are an HTTP/1.1
 716       client anyway.
 717       C.f. https://tools.ietf.org/wg/httpbis/trac/ticket/158 */
 718    Req << "GET " << requesturi << " HTTP/1.1\r\n";
 719    if (Uri.Port != 0)
 720       Req << "Host: " << ProperHost << ":" << std::to_string(Uri.Port) << "\r\n";
 721    else
 722       Req << "Host: " << ProperHost << "\r\n";
 723
 724    // generate a cache control header (if needed)
 725    if (_config->FindB("Acquire::http::No-Cache",false) == true)
 726       Req << "Cache-Control: no-cache\r\n"
 727          << "Pragma: no-cache\r\n";
 728    else if (Itm->IndexFile == true)
 729       Req << "Cache-Control: max-age=" << std::to_string(_config->FindI("Acquire::http::Max-Age",0)) << "\r\n";
 730    else if (_config->FindB("Acquire::http::No-Store",false) == true)
 731       Req << "Cache-Control: no-store\r\n";
 732
 733    // If we ask for uncompressed files servers might respond with content-
 734    // negotiation which lets us end up with compressed files we do not support,
 735    // see 657029, 657560 and co, so if we have no extension on the request
 736    // ask for text only. As a sidenote: If there is nothing to negotate servers
 737    // seem to be nice and ignore it.
 738    if (_config->FindB("Acquire::http::SendAccept", true) == true)
 739    {
 740       size_t const filepos = Itm->Uri.find_last_of('/');
 741       string const file = Itm->Uri.substr(filepos + 1);
 742       if (flExtension(file) == file)
 743          Req << "Accept: text/*\r\n";
 744    }
 745
 746    // Check for a partial file and send if-queries accordingly
 747    struct stat SBuf;
 748    if (stat(Itm->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
 749       Req << "Range: bytes=" << std::to_string(SBuf.st_size) << "-\r\n"
 750          << "If-Range: " << TimeRFC1123(SBuf.st_mtime, false) << "\r\n";
 751    else if (Itm->LastModified != 0)
 752       Req << "If-Modified-Since: " << TimeRFC1123(Itm->LastModified, false).c_str() << "\r\n";
 753
 754    if (Server->Proxy.User.empty() == false || Server->Proxy.Password.empty() == false)
 755       Req << "Proxy-Authorization: Basic "
 756          << Base64Encode(Server->Proxy.User + ":" + Server->Proxy.Password) << "\r\n";
 757
 758    maybe_add_auth (Uri, _config->FindFile("Dir::Etc::netrc"));
 759    if (Uri.User.empty() == false || Uri.Password.empty() == false)
 760       Req << "Authorization: Basic "
 761          << Base64Encode(Uri.User + ":" + Uri.Password) << "\r\n";
 762
 763    Req << "User-Agent: " << _config->Find("Acquire::http::User-Agent",
 764                 "Debian APT-HTTP/1.3 (" PACKAGE_VERSION ")") << "\r\n";
 765
 766    Req << "\r\n";
 767
 768    if (Debug == true)
 769       cerr << Req.str() << endl;
 770
 771    Server->WriteResponse(Req.str());
 772 }
 773                                                                         /*}}}*/
 774 // HttpMethod::Configuration - Handle a configuration message           /*{{{*/
 775 // ---------------------------------------------------------------------
 776 /* We stash the desired pipeline depth */
 777 bool HttpMethod::Configuration(string Message)
 778 {
 779    if (ServerMethod::Configuration(Message) == false)
 780       return false;
 781
 782    AllowRedirect = _config->FindB("Acquire::http::AllowRedirect",true);
 783    PipelineDepth = _config->FindI("Acquire::http::Pipeline-Depth",
 784                                   PipelineDepth);
 785    Debug = _config->FindB("Debug::Acquire::http",false);
 786
 787    return true;
 788 }
 789                                                                         /*}}}*/
 790 std::unique_ptr<ServerState> HttpMethod::CreateServerState(URI const &uri)/*{{{*/
 791 {
 792    return std::unique_ptr<ServerState>(new HttpServerState(uri, this));
 793 }
 794                                                                         /*}}}*/
 795 void HttpMethod::RotateDNS()                                            /*{{{*/
 796 {
 797    ::RotateDNS();
 798 }
 799                                                                         /*}}}*/