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 aquire 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
  37 #include <sys/stat.h>
  38 #include <sys/time.h>
  39 #include <utime.h>
  40 #include <unistd.h>
  41 #include <signal.h>
  42 #include <stdio.h>
  43 #include <errno.h>
  44 #include <string.h>
  45 #include <climits>
  46 #include <iostream>
  47 #include <map>
  48
  49 // Internet stuff
  50 #include <netdb.h>
  51
  52 #include "config.h"
  53 #include "connect.h"
  54 #include "rfc2553emu.h"
  55 #include "http.h"
  56
  57 #include <apti18n.h>
  58                                                                         /*}}}*/
  59 using namespace std;
  60
  61 unsigned long long CircleBuf::BwReadLimit=0;
  62 unsigned long long CircleBuf::BwTickReadData=0;
  63 struct timeval CircleBuf::BwReadTick={0,0};
  64 const unsigned int CircleBuf::BW_HZ=10;
  65
  66 // CircleBuf::CircleBuf - Circular input buffer                         /*{{{*/
  67 // ---------------------------------------------------------------------
  68 /* */
  69 CircleBuf::CircleBuf(unsigned long long Size) : Size(Size), Hash(0)
  70 {
  71    Buf = new unsigned char[Size];
  72    Reset();
  73
  74    CircleBuf::BwReadLimit = _config->FindI("Acquire::http::Dl-Limit",0)*1024;
  75 }
  76                                                                         /*}}}*/
  77 // CircleBuf::Reset - Reset to the default state                        /*{{{*/
  78 // ---------------------------------------------------------------------
  79 /* */
  80 void CircleBuf::Reset()
  81 {
  82    InP = 0;
  83    OutP = 0;
  84    StrPos = 0;
  85    MaxGet = (unsigned long long)-1;
  86    OutQueue = string();
  87    if (Hash != 0)
  88    {
  89       delete Hash;
  90       Hash = new Hashes;
  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    unsigned long long BwReadMax;
 101
 102    while (1)
 103    {
 104       // Woops, buffer is full
 105       if (InP - OutP == Size)
 106          return true;
 107
 108       // what's left to read in this tick
 109       BwReadMax = CircleBuf::BwReadLimit/BW_HZ;
 110
 111       if(CircleBuf::BwReadLimit) {
 112          struct timeval now;
 113          gettimeofday(&now,0);
 114
 115          unsigned long long d = (now.tv_sec-CircleBuf::BwReadTick.tv_sec)*1000000 +
 116             now.tv_usec-CircleBuf::BwReadTick.tv_usec;
 117          if(d > 1000000/BW_HZ) {
 118             CircleBuf::BwReadTick = now;
 119             CircleBuf::BwTickReadData = 0;
 120          }
 121
 122          if(CircleBuf::BwTickReadData >= BwReadMax) {
 123             usleep(1000000/BW_HZ);
 124             return true;
 125          }
 126       }
 127
 128       // Write the buffer segment
 129       ssize_t Res;
 130       if(CircleBuf::BwReadLimit) {
 131          Res = read(Fd,Buf + (InP%Size),
 132                     BwReadMax > LeftRead() ? LeftRead() : BwReadMax);
 133       } else
 134          Res = read(Fd,Buf + (InP%Size),LeftRead());
 135
 136       if(Res > 0 && BwReadLimit > 0)
 137          CircleBuf::BwTickReadData += Res;
 138
 139       if (Res == 0)
 140          return false;
 141       if (Res < 0)
 142       {
 143          if (errno == EAGAIN)
 144             return true;
 145          return false;
 146       }
 147
 148       if (InP == 0)
 149          gettimeofday(&Start,0);
 150       InP += Res;
 151    }
 152 }
 153                                                                         /*}}}*/
 154 // CircleBuf::Read - Put the string into the buffer                     /*{{{*/
 155 // ---------------------------------------------------------------------
 156 /* This will hold the string in and fill the buffer with it as it empties */
 157 bool CircleBuf::Read(string Data)
 158 {
 159    OutQueue += Data;
 160    FillOut();
 161    return true;
 162 }
 163                                                                         /*}}}*/
 164 // CircleBuf::FillOut - Fill the buffer from the output queue           /*{{{*/
 165 // ---------------------------------------------------------------------
 166 /* */
 167 void CircleBuf::FillOut()
 168 {
 169    if (OutQueue.empty() == true)
 170       return;
 171    while (1)
 172    {
 173       // Woops, buffer is full
 174       if (InP - OutP == Size)
 175          return;
 176
 177       // Write the buffer segment
 178       unsigned long long Sz = LeftRead();
 179       if (OutQueue.length() - StrPos < Sz)
 180          Sz = OutQueue.length() - StrPos;
 181       memcpy(Buf + (InP%Size),OutQueue.c_str() + StrPos,Sz);
 182
 183       // Advance
 184       StrPos += Sz;
 185       InP += Sz;
 186       if (OutQueue.length() == StrPos)
 187       {
 188          StrPos = 0;
 189          OutQueue = "";
 190          return;
 191       }
 192    }
 193 }
 194                                                                         /*}}}*/
 195 // CircleBuf::Write - Write from the buffer into a FD                   /*{{{*/
 196 // ---------------------------------------------------------------------
 197 /* This empties the buffer into the FD. */
 198 bool CircleBuf::Write(int Fd)
 199 {
 200    while (1)
 201    {
 202       FillOut();
 203
 204       // Woops, buffer is empty
 205       if (OutP == InP)
 206          return true;
 207
 208       if (OutP == MaxGet)
 209          return true;
 210
 211       // Write the buffer segment
 212       ssize_t Res;
 213       Res = write(Fd,Buf + (OutP%Size),LeftWrite());
 214
 215       if (Res == 0)
 216          return false;
 217       if (Res < 0)
 218       {
 219          if (errno == EAGAIN)
 220             return true;
 221
 222          return false;
 223       }
 224
 225       if (Hash != 0)
 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    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
 351    {
 352       if (Proxy.Port != 0)
 353          Port = Proxy.Port;
 354       Host = Proxy.Host;
 355    }
 356
 357    // Connect to the remote server
 358    if (Connect(Host,Port,"http",80,ServerFd,TimeOut,Owner) == false)
 359       return false;
 360
 361    return true;
 362 }
 363                                                                         /*}}}*/
 364 // HttpServerState::Close - Close a connection to the server            /*{{{*/
 365 // ---------------------------------------------------------------------
 366 /* */
 367 bool HttpServerState::Close()
 368 {
 369    close(ServerFd);
 370    ServerFd = -1;
 371    return true;
 372 }
 373                                                                         /*}}}*/
 374 // HttpServerState::RunData - Transfer the data from the socket         /*{{{*/
 375 bool HttpServerState::RunData(FileFd * const File)
 376 {
 377    State = Data;
 378
 379    // Chunked transfer encoding is fun..
 380    if (Encoding == Chunked)
 381    {
 382       while (1)
 383       {
 384          // Grab the block size
 385          bool Last = true;
 386          string Data;
 387          In.Limit(-1);
 388          do
 389          {
 390             if (In.WriteTillEl(Data,true) == true)
 391                break;
 392          }
 393          while ((Last = Go(false, File)) == true);
 394
 395          if (Last == false)
 396             return false;
 397
 398          // See if we are done
 399          unsigned long long Len = strtoull(Data.c_str(),0,16);
 400          if (Len == 0)
 401          {
 402             In.Limit(-1);
 403
 404             // We have to remove the entity trailer
 405             Last = true;
 406             do
 407             {
 408                if (In.WriteTillEl(Data,true) == true && Data.length() <= 2)
 409                   break;
 410             }
 411             while ((Last = Go(false, File)) == true);
 412             if (Last == false)
 413                return false;
 414             return !_error->PendingError();
 415          }
 416
 417          // Transfer the block
 418          In.Limit(Len);
 419          while (Go(true, File) == true)
 420             if (In.IsLimit() == true)
 421                break;
 422
 423          // Error
 424          if (In.IsLimit() == false)
 425             return false;
 426
 427          // The server sends an extra new line before the next block specifier..
 428          In.Limit(-1);
 429          Last = true;
 430          do
 431          {
 432             if (In.WriteTillEl(Data,true) == true)
 433                break;
 434          }
 435          while ((Last = Go(false, File)) == true);
 436          if (Last == false)
 437             return false;
 438       }
 439    }
 440    else
 441    {
 442       /* Closes encoding is used when the server did not specify a size, the
 443          loss of the connection means we are done */
 444       if (Encoding == Closes)
 445          In.Limit(-1);
 446       else
 447          In.Limit(Size - StartPos);
 448
 449       // Just transfer the whole block.
 450       do
 451       {
 452          if (In.IsLimit() == false)
 453             continue;
 454
 455          In.Limit(-1);
 456          return !_error->PendingError();
 457       }
 458       while (Go(true, File) == true);
 459    }
 460
 461    return Owner->Flush() && !_error->PendingError();
 462 }
 463                                                                         /*}}}*/
 464 bool HttpServerState::ReadHeaderLines(std::string &Data)                /*{{{*/
 465 {
 466    return In.WriteTillEl(Data);
 467 }
 468                                                                         /*}}}*/
 469 bool HttpServerState::LoadNextResponse(bool const ToFile, FileFd * const File)/*{{{*/
 470 {
 471    return Go(ToFile, File);
 472 }
 473                                                                         /*}}}*/
 474 bool HttpServerState::WriteResponse(const std::string &Data)            /*{{{*/
 475 {
 476    return Out.Read(Data);
 477 }
 478                                                                         /*}}}*/
 479 bool HttpServerState::IsOpen()                                          /*{{{*/
 480 {
 481    return (ServerFd != -1);
 482 }
 483                                                                         /*}}}*/
 484 bool HttpServerState::InitHashes(FileFd &File)                          /*{{{*/
 485 {
 486    delete In.Hash;
 487    In.Hash = new Hashes;
 488
 489    // Set the expected size and read file for the hashes
 490    if (StartPos >= 0)
 491    {
 492       File.Truncate(StartPos);
 493
 494       return In.Hash->AddFD(File, StartPos);
 495    }
 496    return true;
 497 }
 498                                                                         /*}}}*/
 499 Hashes * HttpServerState::GetHashes()                                   /*{{{*/
 500 {
 501    return In.Hash;
 502 }
 503                                                                         /*}}}*/
 504 // HttpServerState::Die - The server has closed the connection.         /*{{{*/
 505 bool HttpServerState::Die(FileFd &File)
 506 {
 507    unsigned int LErrno = errno;
 508
 509    // Dump the buffer to the file
 510    if (State == ServerState::Data)
 511    {
 512       // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
 513       // can't be set
 514       if (File.Name() != "/dev/null")
 515          SetNonBlock(File.Fd(),false);
 516       while (In.WriteSpace() == true)
 517       {
 518          if (In.Write(File.Fd()) == false)
 519             return _error->Errno("write",_("Error writing to the file"));
 520
 521          // Done
 522          if (In.IsLimit() == true)
 523             return true;
 524       }
 525    }
 526
 527    // See if this is because the server finished the data stream
 528    if (In.IsLimit() == false && State != HttpServerState::Header &&
 529        Encoding != HttpServerState::Closes)
 530    {
 531       Close();
 532       if (LErrno == 0)
 533          return _error->Error(_("Error reading from server. Remote end closed connection"));
 534       errno = LErrno;
 535       return _error->Errno("read",_("Error reading from server"));
 536    }
 537    else
 538    {
 539       In.Limit(-1);
 540
 541       // Nothing left in the buffer
 542       if (In.WriteSpace() == false)
 543          return false;
 544
 545       // We may have got multiple responses back in one packet..
 546       Close();
 547       return true;
 548    }
 549
 550    return false;
 551 }
 552                                                                         /*}}}*/
 553 // HttpServerState::Flush - Dump the buffer into the file               /*{{{*/
 554 // ---------------------------------------------------------------------
 555 /* This takes the current input buffer from the Server FD and writes it
 556    into the file */
 557 bool HttpServerState::Flush(FileFd * const File)
 558 {
 559    if (File != NULL)
 560    {
 561       // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
 562       // can't be set
 563       if (File->Name() != "/dev/null")
 564          SetNonBlock(File->Fd(),false);
 565       if (In.WriteSpace() == false)
 566          return true;
 567
 568       while (In.WriteSpace() == true)
 569       {
 570          if (In.Write(File->Fd()) == false)
 571             return _error->Errno("write",_("Error writing to file"));
 572          if (In.IsLimit() == true)
 573             return true;
 574       }
 575
 576       if (In.IsLimit() == true || Encoding == ServerState::Closes)
 577          return true;
 578    }
 579    return false;
 580 }
 581                                                                         /*}}}*/
 582 // HttpServerState::Go - Run a single loop                              /*{{{*/
 583 // ---------------------------------------------------------------------
 584 /* This runs the select loop over the server FDs, Output file FDs and
 585    stdin. */
 586 bool HttpServerState::Go(bool ToFile, FileFd * const File)
 587 {
 588    // Server has closed the connection
 589    if (ServerFd == -1 && (In.WriteSpace() == false ||
 590                                ToFile == false))
 591       return false;
 592
 593    fd_set rfds,wfds;
 594    FD_ZERO(&rfds);
 595    FD_ZERO(&wfds);
 596
 597    /* Add the server. We only send more requests if the connection will
 598       be persisting */
 599    if (Out.WriteSpace() == true && ServerFd != -1
 600        && Persistent == true)
 601       FD_SET(ServerFd,&wfds);
 602    if (In.ReadSpace() == true && ServerFd != -1)
 603       FD_SET(ServerFd,&rfds);
 604
 605    // Add the file
 606    int FileFD = -1;
 607    if (File != NULL)
 608       FileFD = File->Fd();
 609
 610    if (In.WriteSpace() == true && ToFile == true && FileFD != -1)
 611       FD_SET(FileFD,&wfds);
 612
 613    // Add stdin
 614    if (_config->FindB("Acquire::http::DependOnSTDIN", true) == true)
 615       FD_SET(STDIN_FILENO,&rfds);
 616
 617    // Figure out the max fd
 618    int MaxFd = FileFD;
 619    if (MaxFd < ServerFd)
 620       MaxFd = ServerFd;
 621
 622    // Select
 623    struct timeval tv;
 624    tv.tv_sec = TimeOut;
 625    tv.tv_usec = 0;
 626    int Res = 0;
 627    if ((Res = select(MaxFd+1,&rfds,&wfds,0,&tv)) < 0)
 628    {
 629       if (errno == EINTR)
 630          return true;
 631       return _error->Errno("select",_("Select failed"));
 632    }
 633
 634    if (Res == 0)
 635    {
 636       _error->Error(_("Connection timed out"));
 637       return Die(*File);
 638    }
 639
 640    // Handle server IO
 641    if (ServerFd != -1 && FD_ISSET(ServerFd,&rfds))
 642    {
 643       errno = 0;
 644       if (In.Read(ServerFd) == false)
 645          return Die(*File);
 646    }
 647
 648    if (ServerFd != -1 && FD_ISSET(ServerFd,&wfds))
 649    {
 650       errno = 0;
 651       if (Out.Write(ServerFd) == false)
 652          return Die(*File);
 653    }
 654
 655    // Send data to the file
 656    if (FileFD != -1 && FD_ISSET(FileFD,&wfds))
 657    {
 658       if (In.Write(FileFD) == false)
 659          return _error->Errno("write",_("Error writing to output file"));
 660    }
 661
 662    // Handle commands from APT
 663    if (FD_ISSET(STDIN_FILENO,&rfds))
 664    {
 665       if (Owner->Run(true) != -1)
 666          exit(100);
 667    }
 668
 669    return true;
 670 }
 671                                                                         /*}}}*/
 672
 673 // HttpMethod::SendReq - Send the HTTP request                          /*{{{*/
 674 // ---------------------------------------------------------------------
 675 /* This places the http request in the outbound buffer */
 676 void HttpMethod::SendReq(FetchItem *Itm)
 677 {
 678    URI Uri = Itm->Uri;
 679
 680    // The HTTP server expects a hostname with a trailing :port
 681    char Buf[1000];
 682    string ProperHost;
 683
 684    if (Uri.Host.find(':') != string::npos)
 685       ProperHost = '[' + Uri.Host + ']';
 686    else
 687       ProperHost = Uri.Host;
 688    if (Uri.Port != 0)
 689    {
 690       sprintf(Buf,":%u",Uri.Port);
 691       ProperHost += Buf;
 692    }
 693
 694    // Just in case.
 695    if (Itm->Uri.length() >= sizeof(Buf))
 696        abort();
 697
 698    /* RFC 2616 §5.1.2 requires absolute URIs for requests to proxies,
 699       but while its a must for all servers to accept absolute URIs,
 700       it is assumed clients will sent an absolute path for non-proxies */
 701    std::string requesturi;
 702    if (Server->Proxy.empty() == true || Server->Proxy.Host.empty())
 703       requesturi = Uri.Path;
 704    else
 705       requesturi = Itm->Uri;
 706
 707    // The "+" is encoded as a workaround for a amazon S3 bug
 708    // see LP bugs #1003633 and #1086997.
 709    requesturi = QuoteString(requesturi, "+~ ");
 710
 711    /* Build the request. No keep-alive is included as it is the default
 712       in 1.1, can cause problems with proxies, and we are an HTTP/1.1
 713       client anyway.
 714       C.f. https://tools.ietf.org/wg/httpbis/trac/ticket/158 */
 715    sprintf(Buf,"GET %s HTTP/1.1\r\nHost: %s\r\n",
 716            requesturi.c_str(),ProperHost.c_str());
 717
 718    // generate a cache control header (if needed)
 719    if (_config->FindB("Acquire::http::No-Cache",false) == true)
 720    {
 721       strcat(Buf,"Cache-Control: no-cache\r\nPragma: no-cache\r\n");
 722    }
 723    else
 724    {
 725       if (Itm->IndexFile == true)
 726       {
 727          sprintf(Buf+strlen(Buf),"Cache-Control: max-age=%u\r\n",
 728                  _config->FindI("Acquire::http::Max-Age",0));
 729       }
 730       else
 731       {
 732          if (_config->FindB("Acquire::http::No-Store",false) == true)
 733             strcat(Buf,"Cache-Control: no-store\r\n");
 734       }
 735    }
 736
 737    // If we ask for uncompressed files servers might respond with content-
 738    // negotation which lets us end up with compressed files we do not support,
 739    // see 657029, 657560 and co, so if we have no extension on the request
 740    // ask for text only. As a sidenote: If there is nothing to negotate servers
 741    // seem to be nice and ignore it.
 742    if (_config->FindB("Acquire::http::SendAccept", true) == true)
 743    {
 744       size_t const filepos = Itm->Uri.find_last_of('/');
 745       string const file = Itm->Uri.substr(filepos + 1);
 746       if (flExtension(file) == file)
 747          strcat(Buf,"Accept: text/*\r\n");
 748    }
 749
 750    string Req = Buf;
 751
 752    // Check for a partial file
 753    struct stat SBuf;
 754    if (stat(Itm->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
 755    {
 756       // In this case we send an if-range query with a range header
 757       sprintf(Buf,"Range: bytes=%lli-\r\nIf-Range: %s\r\n",(long long)SBuf.st_size,
 758               TimeRFC1123(SBuf.st_mtime).c_str());
 759       Req += Buf;
 760    }
 761    else
 762    {
 763       if (Itm->LastModified != 0)
 764       {
 765          sprintf(Buf,"If-Modified-Since: %s\r\n",TimeRFC1123(Itm->LastModified).c_str());
 766          Req += Buf;
 767       }
 768    }
 769
 770    if (Server->Proxy.User.empty() == false || Server->Proxy.Password.empty() == false)
 771       Req += string("Proxy-Authorization: Basic ") +
 772           Base64Encode(Server->Proxy.User + ":" + Server->Proxy.Password) + "\r\n";
 773
 774    maybe_add_auth (Uri, _config->FindFile("Dir::Etc::netrc"));
 775    if (Uri.User.empty() == false || Uri.Password.empty() == false)
 776    {
 777       Req += string("Authorization: Basic ") +
 778           Base64Encode(Uri.User + ":" + Uri.Password) + "\r\n";
 779    }
 780    Req += "User-Agent: " + _config->Find("Acquire::http::User-Agent",
 781                 "Debian APT-HTTP/1.3 (" PACKAGE_VERSION ")") + "\r\n\r\n";
 782
 783    if (Debug == true)
 784       cerr << Req << endl;
 785
 786    Server->WriteResponse(Req);
 787 }
 788                                                                         /*}}}*/
 789 // HttpMethod::Configuration - Handle a configuration message           /*{{{*/
 790 // ---------------------------------------------------------------------
 791 /* We stash the desired pipeline depth */
 792 bool HttpMethod::Configuration(string Message)
 793 {
 794    if (ServerMethod::Configuration(Message) == false)
 795       return false;
 796
 797    AllowRedirect = _config->FindB("Acquire::http::AllowRedirect",true);
 798    PipelineDepth = _config->FindI("Acquire::http::Pipeline-Depth",
 799                                   PipelineDepth);
 800    Debug = _config->FindB("Debug::Acquire::http",false);
 801    AutoDetectProxyCmd = _config->Find("Acquire::http::ProxyAutoDetect");
 802
 803    // Get the proxy to use
 804    AutoDetectProxy();
 805
 806    return true;
 807 }
 808                                                                         /*}}}*/
 809 // HttpMethod::AutoDetectProxy - auto detect proxy                      /*{{{*/
 810 // ---------------------------------------------------------------------
 811 /* */
 812 bool HttpMethod::AutoDetectProxy()
 813 {
 814    if (AutoDetectProxyCmd.empty())
 815       return true;
 816
 817    if (Debug)
 818       clog << "Using auto proxy detect command: " << AutoDetectProxyCmd << endl;
 819
 820    int Pipes[2] = {-1,-1};
 821    if (pipe(Pipes) != 0)
 822       return _error->Errno("pipe", "Failed to create Pipe");
 823
 824    pid_t Process = ExecFork();
 825    if (Process == 0)
 826    {
 827       close(Pipes[0]);
 828       dup2(Pipes[1],STDOUT_FILENO);
 829       SetCloseExec(STDOUT_FILENO,false);
 830
 831       const char *Args[2];
 832       Args[0] = AutoDetectProxyCmd.c_str();
 833       Args[1] = 0;
 834       execv(Args[0],(char **)Args);
 835       cerr << "Failed to exec method " << Args[0] << endl;
 836       _exit(100);
 837    }
 838    char buf[512];
 839    int InFd = Pipes[0];
 840    close(Pipes[1]);
 841    int res = read(InFd, buf, sizeof(buf)-1);
 842    ExecWait(Process, "ProxyAutoDetect", true);
 843
 844    if (res < 0)
 845       return _error->Errno("read", "Failed to read");
 846    if (res == 0)
 847       return _error->Warning("ProxyAutoDetect returned no data");
 848
 849    // add trailing \0
 850    buf[res] = 0;
 851
 852    if (Debug)
 853       clog << "auto detect command returned: '" << buf << "'" << endl;
 854
 855    if (strstr(buf, "http://") == buf)
 856       _config->Set("Acquire::http::proxy", _strstrip(buf));
 857
 858    return true;
 859 }
 860                                                                         /*}}}*/
 861 ServerState * HttpMethod::CreateServerState(URI uri)                    /*{{{*/
 862 {
 863    return new HttpServerState(uri, this);
 864 }
 865                                                                         /*}}}*/
 866 void HttpMethod::RotateDNS()                                            /*{{{*/
 867 {
 868    ::RotateDNS();
 869 }
 870                                                                         /*}}}*/