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
  37 #include <sys/stat.h>
  38 #include <sys/time.h>
  39 #include <unistd.h>
  40 #include <signal.h>
  41 #include <stdio.h>
  42 #include <errno.h>
  43 #include <string.h>
  44 #include <climits>
  45 #include <iostream>
  46 #include <map>
  47
  48 // Internet stuff
  49 #include <netdb.h>
  50
  51 #include "config.h"
  52 #include "connect.h"
  53 #include "rfc2553emu.h"
  54 #include "http.h"
  55
  56 #include <apti18n.h>
  57                                                                         /*}}}*/
  58 using namespace std;
  59
  60 unsigned long long CircleBuf::BwReadLimit=0;
  61 unsigned long long CircleBuf::BwTickReadData=0;
  62 struct timeval CircleBuf::BwReadTick={0,0};
  63 const unsigned int CircleBuf::BW_HZ=10;
  64
  65 // CircleBuf::CircleBuf - Circular input buffer                         /*{{{*/
  66 // ---------------------------------------------------------------------
  67 /* */
  68 CircleBuf::CircleBuf(unsigned long long Size) : Size(Size), Hash(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    MaxGet = (unsigned long long)-1;
  85    OutQueue = string();
  86    if (Hash != 0)
  87    {
  88       delete Hash;
  89       Hash = new Hashes;
  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       if (Hash != 0)
 223          Hash->Add(Buf + (OutP%Size),Res);
 224
 225       OutP += Res;
 226    }
 227 }
 228                                                                         /*}}}*/
 229 // CircleBuf::WriteTillEl - Write from the buffer to a string           /*{{{*/
 230 // ---------------------------------------------------------------------
 231 /* This copies till the first empty line */
 232 bool CircleBuf::WriteTillEl(string &Data,bool Single)
 233 {
 234    // We cheat and assume it is unneeded to have more than one buffer load
 235    for (unsigned long long I = OutP; I < InP; I++)
 236    {
 237       if (Buf[I%Size] != '\n')
 238          continue;
 239       ++I;
 240
 241       if (Single == false)
 242       {
 243          if (I < InP  && Buf[I%Size] == '\r')
 244             ++I;
 245          if (I >= InP || Buf[I%Size] != '\n')
 246             continue;
 247          ++I;
 248       }
 249
 250       Data = "";
 251       while (OutP < I)
 252       {
 253          unsigned long long Sz = LeftWrite();
 254          if (Sz == 0)
 255             return false;
 256          if (I - OutP < Sz)
 257             Sz = I - OutP;
 258          Data += string((char *)(Buf + (OutP%Size)),Sz);
 259          OutP += Sz;
 260       }
 261       return true;
 262    }
 263    return false;
 264 }
 265                                                                         /*}}}*/
 266 // CircleBuf::Stats - Print out stats information                       /*{{{*/
 267 // ---------------------------------------------------------------------
 268 /* */
 269 void CircleBuf::Stats()
 270 {
 271    if (InP == 0)
 272       return;
 273
 274    struct timeval Stop;
 275    gettimeofday(&Stop,0);
 276 /*   float Diff = Stop.tv_sec - Start.tv_sec +
 277              (float)(Stop.tv_usec - Start.tv_usec)/1000000;
 278    clog << "Got " << InP << " in " << Diff << " at " << InP/Diff << endl;*/
 279 }
 280                                                                         /*}}}*/
 281 CircleBuf::~CircleBuf()
 282 {
 283    delete [] Buf;
 284    delete Hash;
 285 }
 286
 287 // HttpServerState::HttpServerState - Constructor                       /*{{{*/
 288 HttpServerState::HttpServerState(URI Srv,HttpMethod *Owner) : ServerState(Srv, Owner), In(64*1024), Out(4*1024)
 289 {
 290    TimeOut = _config->FindI("Acquire::http::Timeout",TimeOut);
 291    Reset();
 292 }
 293                                                                         /*}}}*/
 294 // HttpServerState::Open - Open a connection to the server              /*{{{*/
 295 // ---------------------------------------------------------------------
 296 /* This opens a connection to the server. */
 297 bool HttpServerState::Open()
 298 {
 299    // Use the already open connection if possible.
 300    if (ServerFd != -1)
 301       return true;
 302
 303    Close();
 304    In.Reset();
 305    Out.Reset();
 306    Persistent = true;
 307
 308    // Determine the proxy setting
 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
 444          In.Limit(Size - StartPos);
 445
 446       // Just transfer the whole block.
 447       do
 448       {
 449          if (In.IsLimit() == false)
 450             continue;
 451
 452          In.Limit(-1);
 453          return !_error->PendingError();
 454       }
 455       while (Go(true, File) == true);
 456    }
 457
 458    return Owner->Flush() && !_error->PendingError();
 459 }
 460                                                                         /*}}}*/
 461 bool HttpServerState::ReadHeaderLines(std::string &Data)                /*{{{*/
 462 {
 463    return In.WriteTillEl(Data);
 464 }
 465                                                                         /*}}}*/
 466 bool HttpServerState::LoadNextResponse(bool const ToFile, FileFd * const File)/*{{{*/
 467 {
 468    return Go(ToFile, File);
 469 }
 470                                                                         /*}}}*/
 471 bool HttpServerState::WriteResponse(const std::string &Data)            /*{{{*/
 472 {
 473    return Out.Read(Data);
 474 }
 475                                                                         /*}}}*/
 476 bool HttpServerState::IsOpen()                                          /*{{{*/
 477 {
 478    return (ServerFd != -1);
 479 }
 480                                                                         /*}}}*/
 481 bool HttpServerState::InitHashes(FileFd &File)                          /*{{{*/
 482 {
 483    delete In.Hash;
 484    In.Hash = new Hashes;
 485
 486    // Set the expected size and read file for the hashes
 487    if (StartPos >= 0)
 488    {
 489       File.Truncate(StartPos);
 490
 491       return In.Hash->AddFD(File, StartPos);
 492    }
 493    return true;
 494 }
 495                                                                         /*}}}*/
 496 Hashes * HttpServerState::GetHashes()                                   /*{{{*/
 497 {
 498    return In.Hash;
 499 }
 500                                                                         /*}}}*/
 501 // HttpServerState::Die - The server has closed the connection.         /*{{{*/
 502 bool HttpServerState::Die(FileFd &File)
 503 {
 504    unsigned int LErrno = errno;
 505
 506    // Dump the buffer to the file
 507    if (State == ServerState::Data)
 508    {
 509       // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
 510       // can't be set
 511       if (File.Name() != "/dev/null")
 512          SetNonBlock(File.Fd(),false);
 513       while (In.WriteSpace() == true)
 514       {
 515          if (In.Write(File.Fd()) == false)
 516             return _error->Errno("write",_("Error writing to the file"));
 517
 518          // Done
 519          if (In.IsLimit() == true)
 520             return true;
 521       }
 522    }
 523
 524    // See if this is because the server finished the data stream
 525    if (In.IsLimit() == false && State != HttpServerState::Header &&
 526        Encoding != HttpServerState::Closes)
 527    {
 528       Close();
 529       if (LErrno == 0)
 530          return _error->Error(_("Error reading from server. Remote end closed connection"));
 531       errno = LErrno;
 532       return _error->Errno("read",_("Error reading from server"));
 533    }
 534    else
 535    {
 536       In.Limit(-1);
 537
 538       // Nothing left in the buffer
 539       if (In.WriteSpace() == false)
 540          return false;
 541
 542       // We may have got multiple responses back in one packet..
 543       Close();
 544       return true;
 545    }
 546
 547    return false;
 548 }
 549                                                                         /*}}}*/
 550 // HttpServerState::Flush - Dump the buffer into the file               /*{{{*/
 551 // ---------------------------------------------------------------------
 552 /* This takes the current input buffer from the Server FD and writes it
 553    into the file */
 554 bool HttpServerState::Flush(FileFd * const File)
 555 {
 556    if (File != NULL)
 557    {
 558       // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
 559       // can't be set
 560       if (File->Name() != "/dev/null")
 561          SetNonBlock(File->Fd(),false);
 562       if (In.WriteSpace() == false)
 563          return true;
 564
 565       while (In.WriteSpace() == true)
 566       {
 567          if (In.Write(File->Fd()) == false)
 568             return _error->Errno("write",_("Error writing to file"));
 569          if (In.IsLimit() == true)
 570             return true;
 571       }
 572
 573       if (In.IsLimit() == true || Encoding == ServerState::Closes)
 574          return true;
 575    }
 576    return false;
 577 }
 578                                                                         /*}}}*/
 579 // HttpServerState::Go - Run a single loop                              /*{{{*/
 580 // ---------------------------------------------------------------------
 581 /* This runs the select loop over the server FDs, Output file FDs and
 582    stdin. */
 583 bool HttpServerState::Go(bool ToFile, FileFd * const File)
 584 {
 585    // Server has closed the connection
 586    if (ServerFd == -1 && (In.WriteSpace() == false ||
 587                                ToFile == false))
 588       return false;
 589
 590    fd_set rfds,wfds;
 591    FD_ZERO(&rfds);
 592    FD_ZERO(&wfds);
 593
 594    /* Add the server. We only send more requests if the connection will
 595       be persisting */
 596    if (Out.WriteSpace() == true && ServerFd != -1
 597        && Persistent == true)
 598       FD_SET(ServerFd,&wfds);
 599    if (In.ReadSpace() == true && ServerFd != -1)
 600       FD_SET(ServerFd,&rfds);
 601
 602    // Add the file
 603    int FileFD = -1;
 604    if (File != NULL)
 605       FileFD = File->Fd();
 606
 607    if (In.WriteSpace() == true && ToFile == true && FileFD != -1)
 608       FD_SET(FileFD,&wfds);
 609
 610    // Add stdin
 611    if (_config->FindB("Acquire::http::DependOnSTDIN", true) == true)
 612       FD_SET(STDIN_FILENO,&rfds);
 613
 614    // Figure out the max fd
 615    int MaxFd = FileFD;
 616    if (MaxFd < ServerFd)
 617       MaxFd = ServerFd;
 618
 619    // Select
 620    struct timeval tv;
 621    tv.tv_sec = TimeOut;
 622    tv.tv_usec = 0;
 623    int Res = 0;
 624    if ((Res = select(MaxFd+1,&rfds,&wfds,0,&tv)) < 0)
 625    {
 626       if (errno == EINTR)
 627          return true;
 628       return _error->Errno("select",_("Select failed"));
 629    }
 630
 631    if (Res == 0)
 632    {
 633       _error->Error(_("Connection timed out"));
 634       return Die(*File);
 635    }
 636
 637    // Handle server IO
 638    if (ServerFd != -1 && FD_ISSET(ServerFd,&rfds))
 639    {
 640       errno = 0;
 641       if (In.Read(ServerFd) == false)
 642          return Die(*File);
 643    }
 644
 645    if (ServerFd != -1 && FD_ISSET(ServerFd,&wfds))
 646    {
 647       errno = 0;
 648       if (Out.Write(ServerFd) == false)
 649          return Die(*File);
 650    }
 651
 652    // Send data to the file
 653    if (FileFD != -1 && FD_ISSET(FileFD,&wfds))
 654    {
 655       if (In.Write(FileFD) == false)
 656          return _error->Errno("write",_("Error writing to output file"));
 657    }
 658
 659    // Handle commands from APT
 660    if (FD_ISSET(STDIN_FILENO,&rfds))
 661    {
 662       if (Owner->Run(true) != -1)
 663          exit(100);
 664    }
 665
 666    return true;
 667 }
 668                                                                         /*}}}*/
 669
 670 // HttpMethod::SendReq - Send the HTTP request                          /*{{{*/
 671 // ---------------------------------------------------------------------
 672 /* This places the http request in the outbound buffer */
 673 void HttpMethod::SendReq(FetchItem *Itm)
 674 {
 675    URI Uri = Itm->Uri;
 676
 677    // The HTTP server expects a hostname with a trailing :port
 678    char Buf[1000];
 679    string ProperHost;
 680
 681    if (Uri.Host.find(':') != string::npos)
 682       ProperHost = '[' + Uri.Host + ']';
 683    else
 684       ProperHost = Uri.Host;
 685    if (Uri.Port != 0)
 686    {
 687       sprintf(Buf,":%u",Uri.Port);
 688       ProperHost += Buf;
 689    }
 690
 691    // Just in case.
 692    if (Itm->Uri.length() >= sizeof(Buf))
 693        abort();
 694
 695    /* RFC 2616 §5.1.2 requires absolute URIs for requests to proxies,
 696       but while its a must for all servers to accept absolute URIs,
 697       it is assumed clients will sent an absolute path for non-proxies */
 698    std::string requesturi;
 699    if (Server->Proxy.empty() == true || Server->Proxy.Host.empty())
 700       requesturi = Uri.Path;
 701    else
 702       requesturi = Itm->Uri;
 703
 704    // The "+" is encoded as a workaround for a amazon S3 bug
 705    // see LP bugs #1003633 and #1086997.
 706    requesturi = QuoteString(requesturi, "+~ ");
 707
 708    /* Build the request. No keep-alive is included as it is the default
 709       in 1.1, can cause problems with proxies, and we are an HTTP/1.1
 710       client anyway.
 711       C.f. https://tools.ietf.org/wg/httpbis/trac/ticket/158 */
 712    sprintf(Buf,"GET %s HTTP/1.1\r\nHost: %s\r\n",
 713            requesturi.c_str(),ProperHost.c_str());
 714
 715    // generate a cache control header (if needed)
 716    if (_config->FindB("Acquire::http::No-Cache",false) == true)
 717    {
 718       strcat(Buf,"Cache-Control: no-cache\r\nPragma: no-cache\r\n");
 719    }
 720    else
 721    {
 722       if (Itm->IndexFile == true)
 723       {
 724          sprintf(Buf+strlen(Buf),"Cache-Control: max-age=%u\r\n",
 725                  _config->FindI("Acquire::http::Max-Age",0));
 726       }
 727       else
 728       {
 729          if (_config->FindB("Acquire::http::No-Store",false) == true)
 730             strcat(Buf,"Cache-Control: no-store\r\n");
 731       }
 732    }
 733
 734    // If we ask for uncompressed files servers might respond with content-
 735    // negotiation which lets us end up with compressed files we do not support,
 736    // see 657029, 657560 and co, so if we have no extension on the request
 737    // ask for text only. As a sidenote: If there is nothing to negotate servers
 738    // seem to be nice and ignore it.
 739    if (_config->FindB("Acquire::http::SendAccept", true) == true)
 740    {
 741       size_t const filepos = Itm->Uri.find_last_of('/');
 742       string const file = Itm->Uri.substr(filepos + 1);
 743       if (flExtension(file) == file)
 744          strcat(Buf,"Accept: text/*\r\n");
 745    }
 746
 747    string Req = Buf;
 748
 749    // Check for a partial file
 750    struct stat SBuf;
 751    if (stat(Itm->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
 752    {
 753       // In this case we send an if-range query with a range header
 754       sprintf(Buf,"Range: bytes=%lli-\r\nIf-Range: %s\r\n",(long long)SBuf.st_size,
 755               TimeRFC1123(SBuf.st_mtime).c_str());
 756       Req += Buf;
 757    }
 758    else
 759    {
 760       if (Itm->LastModified != 0)
 761       {
 762          sprintf(Buf,"If-Modified-Since: %s\r\n",TimeRFC1123(Itm->LastModified).c_str());
 763          Req += Buf;
 764       }
 765    }
 766
 767    if (Server->Proxy.User.empty() == false || Server->Proxy.Password.empty() == false)
 768       Req += string("Proxy-Authorization: Basic ") +
 769           Base64Encode(Server->Proxy.User + ":" + Server->Proxy.Password) + "\r\n";
 770
 771    maybe_add_auth (Uri, _config->FindFile("Dir::Etc::netrc"));
 772    if (Uri.User.empty() == false || Uri.Password.empty() == false)
 773    {
 774       Req += string("Authorization: Basic ") +
 775           Base64Encode(Uri.User + ":" + Uri.Password) + "\r\n";
 776    }
 777    Req += "User-Agent: " + _config->Find("Acquire::http::User-Agent",
 778                 "Debian APT-HTTP/1.3 (" PACKAGE_VERSION ")") + "\r\n\r\n";
 779
 780    if (Debug == true)
 781       cerr << Req << endl;
 782
 783    Server->WriteResponse(Req);
 784 }
 785                                                                         /*}}}*/
 786 // HttpMethod::Configuration - Handle a configuration message           /*{{{*/
 787 // ---------------------------------------------------------------------
 788 /* We stash the desired pipeline depth */
 789 bool HttpMethod::Configuration(string Message)
 790 {
 791    if (ServerMethod::Configuration(Message) == false)
 792       return false;
 793
 794    AllowRedirect = _config->FindB("Acquire::http::AllowRedirect",true);
 795    PipelineDepth = _config->FindI("Acquire::http::Pipeline-Depth",
 796                                   PipelineDepth);
 797    Debug = _config->FindB("Debug::Acquire::http",false);
 798
 799    // Get the proxy to use
 800    AutoDetectProxy();
 801
 802    return true;
 803 }
 804                                                                         /*}}}*/
 805 // HttpMethod::AutoDetectProxy - auto detect proxy                      /*{{{*/
 806 // ---------------------------------------------------------------------
 807 /* */
 808 bool HttpMethod::AutoDetectProxy()
 809 {
 810    // option is "Acquire::http::Proxy-Auto-Detect" but we allow the old
 811    // name without the dash ("-")
 812    AutoDetectProxyCmd = _config->Find("Acquire::http::Proxy-Auto-Detect",
 813                                       _config->Find("Acquire::http::ProxyAutoDetect"));
 814
 815    if (AutoDetectProxyCmd.empty())
 816       return true;
 817
 818    if (Debug)
 819       clog << "Using auto proxy detect command: " << AutoDetectProxyCmd << endl;
 820
 821    int Pipes[2] = {-1,-1};
 822    if (pipe(Pipes) != 0)
 823       return _error->Errno("pipe", "Failed to create Pipe");
 824
 825    pid_t Process = ExecFork();
 826    if (Process == 0)
 827    {
 828       close(Pipes[0]);
 829       dup2(Pipes[1],STDOUT_FILENO);
 830       SetCloseExec(STDOUT_FILENO,false);
 831
 832       const char *Args[2];
 833       Args[0] = AutoDetectProxyCmd.c_str();
 834       Args[1] = 0;
 835       execv(Args[0],(char **)Args);
 836       cerr << "Failed to exec method " << Args[0] << endl;
 837       _exit(100);
 838    }
 839    char buf[512];
 840    int InFd = Pipes[0];
 841    close(Pipes[1]);
 842    int res = read(InFd, buf, sizeof(buf)-1);
 843    ExecWait(Process, "ProxyAutoDetect", true);
 844
 845    if (res < 0)
 846       return _error->Errno("read", "Failed to read");
 847    if (res == 0)
 848       return _error->Warning("ProxyAutoDetect returned no data");
 849
 850    // add trailing \0
 851    buf[res] = 0;
 852
 853    if (Debug)
 854       clog << "auto detect command returned: '" << buf << "'" << endl;
 855
 856    if (strstr(buf, "http://") == buf)
 857       _config->Set("Acquire::http::proxy", _strstrip(buf));
 858
 859    return true;
 860 }
 861                                                                         /*}}}*/
 862 ServerState * HttpMethod::CreateServerState(URI uri)                    /*{{{*/
 863 {
 864    return new HttpServerState(uri, this);
 865 }
 866                                                                         /*}}}*/
 867 void HttpMethod::RotateDNS()                                            /*{{{*/
 868 {
 869    ::RotateDNS();
 870 }
 871                                                                         /*}}}*/