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