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