r239 - in /apt-transport-debtorrent/branches/upstream/current: ./ apti18n.h.in connect.cc connect.h http.cc http.h rfc2553emu.cc rfc2553emu.h

camrdale-guest at users.alioth.debian.org camrdale-guest at users.alioth.debian.org
Tue Aug 14 22:28:31 UTC 2007


Author: camrdale-guest
Date: Tue Aug 14 22:28:31 2007
New Revision: 239

URL: http://svn.debian.org/wsvn/debtorrent/?sc=1&rev=239
Log:
Add the needed methods from apt 0.7.6 as the current upstream.

Added:
    apt-transport-debtorrent/branches/upstream/current/
    apt-transport-debtorrent/branches/upstream/current/apti18n.h.in
    apt-transport-debtorrent/branches/upstream/current/connect.cc
    apt-transport-debtorrent/branches/upstream/current/connect.h
    apt-transport-debtorrent/branches/upstream/current/http.cc
    apt-transport-debtorrent/branches/upstream/current/http.h
    apt-transport-debtorrent/branches/upstream/current/rfc2553emu.cc
    apt-transport-debtorrent/branches/upstream/current/rfc2553emu.h

Added: apt-transport-debtorrent/branches/upstream/current/apti18n.h.in
URL: http://svn.debian.org/wsvn/debtorrent/apt-transport-debtorrent/branches/upstream/current/apti18n.h.in?rev=239&op=file
==============================================================================
--- apt-transport-debtorrent/branches/upstream/current/apti18n.h.in (added)
+++ apt-transport-debtorrent/branches/upstream/current/apti18n.h.in Tue Aug 14 22:28:31 2007
@@ -1,0 +1,23 @@
+// -*- mode: cpp; mode: fold -*-
+// $Id: apti18n.h.in,v 1.6 2003/01/11 07:18:18 jgg Exp $
+/* Internationalization macros for apt. This header should be included last
+   in each C file. */
+
+// Set by autoconf
+#undef USE_NLS
+
+#ifdef USE_NLS
+// apt will use the gettext implementation of the C library
+# include <libintl.h>
+# ifdef APT_DOMAIN
+#   define _(x) dgettext(APT_DOMAIN,x)
+# else
+#   define _(x) gettext(x)
+# endif
+# define N_(x) x
+#else
+// apt will not use any gettext
+# define setlocale(a, b)
+# define _(x) x
+# define N_(x) x
+#endif

Added: apt-transport-debtorrent/branches/upstream/current/connect.cc
URL: http://svn.debian.org/wsvn/debtorrent/apt-transport-debtorrent/branches/upstream/current/connect.cc?rev=239&op=file
==============================================================================
--- apt-transport-debtorrent/branches/upstream/current/connect.cc (added)
+++ apt-transport-debtorrent/branches/upstream/current/connect.cc Tue Aug 14 22:28:31 2007
@@ -1,0 +1,225 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+// $Id: connect.cc,v 1.10.2.1 2004/01/16 18:58:50 mdz Exp $
+/* ######################################################################
+
+   Connect - Replacement connect call
+
+   This was originally authored by Jason Gunthorpe <jgg at debian.org>
+   and is placed in the Public Domain, do with it what you will.
+      
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include "connect.h"
+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+
+// Internet stuff
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include "rfc2553emu.h"
+#include <apti18n.h>
+									/*}}}*/
+
+static string LastHost;
+static int LastPort = 0;
+static struct addrinfo *LastHostAddr = 0;
+static struct addrinfo *LastUsed = 0;
+
+// RotateDNS - Select a new server from a DNS rotation			/*{{{*/
+// ---------------------------------------------------------------------
+/* This is called during certain errors in order to recover by selecting a 
+   new server */
+void RotateDNS()
+{
+   if (LastUsed != 0 && LastUsed->ai_next != 0)
+      LastUsed = LastUsed->ai_next;
+   else
+      LastUsed = LastHostAddr;
+}
+									/*}}}*/
+// DoConnect - Attempt a connect operation				/*{{{*/
+// ---------------------------------------------------------------------
+/* This helper function attempts a connection to a single address. */
+static bool DoConnect(struct addrinfo *Addr,string Host,
+		      unsigned long TimeOut,int &Fd,pkgAcqMethod *Owner)
+{
+   // Show a status indicator
+   char Name[NI_MAXHOST];
+   char Service[NI_MAXSERV];
+   
+   Name[0] = 0;   
+   Service[0] = 0;
+   getnameinfo(Addr->ai_addr,Addr->ai_addrlen,
+	       Name,sizeof(Name),Service,sizeof(Service),
+	       NI_NUMERICHOST|NI_NUMERICSERV);
+   Owner->Status(_("Connecting to %s (%s)"),Host.c_str(),Name);
+
+   /* If this is an IP rotation store the IP we are using.. If something goes
+      wrong this will get tacked onto the end of the error message */
+   if (LastHostAddr->ai_next != 0)
+   {
+      char Name2[NI_MAXHOST + NI_MAXSERV + 10];
+      snprintf(Name2,sizeof(Name2),_("[IP: %s %s]"),Name,Service);
+      Owner->SetFailExtraMsg(string(Name2));
+   }   
+   else
+      Owner->SetFailExtraMsg("");
+      
+   // Get a socket
+   if ((Fd = socket(Addr->ai_family,Addr->ai_socktype,
+		    Addr->ai_protocol)) < 0)
+      return _error->Errno("socket",_("Could not create a socket for %s (f=%u t=%u p=%u)"),
+			   Name,Addr->ai_family,Addr->ai_socktype,Addr->ai_protocol);
+   
+   SetNonBlock(Fd,true);
+   if (connect(Fd,Addr->ai_addr,Addr->ai_addrlen) < 0 &&
+       errno != EINPROGRESS)
+      return _error->Errno("connect",_("Cannot initiate the connection "
+			   "to %s:%s (%s)."),Host.c_str(),Service,Name);
+   
+   /* This implements a timeout for connect by opening the connection
+      nonblocking */
+   if (WaitFd(Fd,true,TimeOut) == false) {
+      Owner->SetFailExtraMsg("\nFailReason: Timeout");
+      return _error->Error(_("Could not connect to %s:%s (%s), "
+			   "connection timed out"),Host.c_str(),Service,Name);
+   }
+
+   // Check the socket for an error condition
+   unsigned int Err;
+   unsigned int Len = sizeof(Err);
+   if (getsockopt(Fd,SOL_SOCKET,SO_ERROR,&Err,&Len) != 0)
+      return _error->Errno("getsockopt",_("Failed"));
+   
+   if (Err != 0)
+   {
+      errno = Err;
+      if(errno == ECONNREFUSED)
+         Owner->SetFailExtraMsg("\nFailReason: ConnectionRefused");
+      return _error->Errno("connect",_("Could not connect to %s:%s (%s)."),Host.c_str(),
+			   Service,Name);
+   }
+   
+   return true;
+}
+									/*}}}*/
+// Connect - Connect to a server					/*{{{*/
+// ---------------------------------------------------------------------
+/* Performs a connection to the server */
+bool Connect(string Host,int Port,const char *Service,int DefPort,int &Fd,
+	     unsigned long TimeOut,pkgAcqMethod *Owner)
+{
+   if (_error->PendingError() == true)
+      return false;
+
+   // Convert the port name/number
+   char ServStr[300];
+   if (Port != 0)
+      snprintf(ServStr,sizeof(ServStr),"%u",Port);
+   else
+      snprintf(ServStr,sizeof(ServStr),"%s",Service);
+   
+   /* We used a cached address record.. Yes this is against the spec but
+      the way we have setup our rotating dns suggests that this is more
+      sensible */
+   if (LastHost != Host || LastPort != Port)
+   {
+      Owner->Status(_("Connecting to %s"),Host.c_str());
+
+      // Free the old address structure
+      if (LastHostAddr != 0)
+      {
+	 freeaddrinfo(LastHostAddr);
+	 LastHostAddr = 0;
+	 LastUsed = 0;
+      }
+      
+      // We only understand SOCK_STREAM sockets.
+      struct addrinfo Hints;
+      memset(&Hints,0,sizeof(Hints));
+      Hints.ai_socktype = SOCK_STREAM;
+      Hints.ai_protocol = 0;
+      
+      // Resolve both the host and service simultaneously
+      while (1)
+      {
+	 int Res;
+	 if ((Res = getaddrinfo(Host.c_str(),ServStr,&Hints,&LastHostAddr)) != 0 ||
+	     LastHostAddr == 0)
+	 {
+	    if (Res == EAI_NONAME || Res == EAI_SERVICE)
+	    {
+	       if (DefPort != 0)
+	       {
+		  snprintf(ServStr,sizeof(ServStr),"%u",DefPort);
+		  DefPort = 0;
+		  continue;
+	       }
+	       return _error->Error(_("Could not resolve '%s'"),Host.c_str());
+	    }
+	    
+	    if (Res == EAI_AGAIN)
+	    {
+	       Owner->SetFailExtraMsg("\nFailReason: TmpResolveFailure");
+	       return _error->Error(_("Temporary failure resolving '%s'"),
+				    Host.c_str());
+	    }
+	    return _error->Error(_("Something wicked happened resolving '%s:%s' (%i)"),
+				 Host.c_str(),ServStr,Res);
+	 }
+	 break;
+      }
+      
+      LastHost = Host;
+      LastPort = Port;
+   }
+
+   // When we have an IP rotation stay with the last IP.
+   struct addrinfo *CurHost = LastHostAddr;
+   if (LastUsed != 0)
+       CurHost = LastUsed;
+   
+   while (CurHost != 0)
+   {
+      if (DoConnect(CurHost,Host,TimeOut,Fd,Owner) == true)
+      {
+	 LastUsed = CurHost;
+	 return true;
+      }      
+      close(Fd);
+      Fd = -1;
+      
+      // Ignore UNIX domain sockets
+      do
+      {
+	 CurHost = CurHost->ai_next;
+      }
+      while (CurHost != 0 && CurHost->ai_family == AF_UNIX);
+
+      /* If we reached the end of the search list then wrap around to the
+         start */
+      if (CurHost == 0 && LastUsed != 0)
+	 CurHost = LastHostAddr;
+      
+      // Reached the end of the search cycle
+      if (CurHost == LastUsed)
+	 break;
+      
+      if (CurHost != 0)
+	 _error->Discard();
+   }   
+
+   if (_error->PendingError() == true)
+      return false;   
+   return _error->Error(_("Unable to connect to %s %s:"),Host.c_str(),ServStr);
+}
+									/*}}}*/

Added: apt-transport-debtorrent/branches/upstream/current/connect.h
URL: http://svn.debian.org/wsvn/debtorrent/apt-transport-debtorrent/branches/upstream/current/connect.h?rev=239&op=file
==============================================================================
--- apt-transport-debtorrent/branches/upstream/current/connect.h (added)
+++ apt-transport-debtorrent/branches/upstream/current/connect.h Tue Aug 14 22:28:31 2007
@@ -1,0 +1,20 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+// $Id: connect.h,v 1.3 2001/02/20 07:03:18 jgg Exp $
+/* ######################################################################
+
+   Connect - Replacement connect call
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef CONNECT_H
+#define CONNECT_H
+
+#include <string>
+#include <apt-pkg/acquire-method.h>
+
+bool Connect(string To,int Port,const char *Service,int DefPort,
+	     int &Fd,unsigned long TimeOut,pkgAcqMethod *Owner);
+void RotateDNS();
+
+#endif

Added: apt-transport-debtorrent/branches/upstream/current/http.cc
URL: http://svn.debian.org/wsvn/debtorrent/apt-transport-debtorrent/branches/upstream/current/http.cc?rev=239&op=file
==============================================================================
--- apt-transport-debtorrent/branches/upstream/current/http.cc (added)
+++ apt-transport-debtorrent/branches/upstream/current/http.cc Tue Aug 14 22:28:31 2007
@@ -1,0 +1,1248 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+// $Id: http.cc,v 1.59 2004/05/08 19:42:35 mdz Exp $
+/* ######################################################################
+
+   HTTP Acquire Method - This is the HTTP aquire method for APT.
+   
+   It uses HTTP/1.1 and many of the fancy options there-in, such as
+   pipelining, range, if-range and so on. 
+
+   It is based on a doubly buffered select loop. A groupe of requests are 
+   fed into a single output buffer that is constantly fed out the 
+   socket. This provides ideal pipelining as in many cases all of the
+   requests will fit into a single packet. The input socket is buffered 
+   the same way and fed into the fd for the file (may be a pipe in future).
+   
+   This double buffering provides fairly substantial transfer rates,
+   compared to wget the http method is about 4% faster. Most importantly,
+   when HTTP is compared with FTP as a protocol the speed difference is
+   huge. In tests over the internet from two sites to llug (via ATM) this
+   program got 230k/s sustained http transfer rates. FTP on the other 
+   hand topped out at 170k/s. That combined with the time to setup the
+   FTP connection makes HTTP a vastly superior protocol.
+      
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/acquire-method.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/hashes.h>
+
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <iostream>
+#include <apti18n.h>
+
+// Internet stuff
+#include <netdb.h>
+
+#include "config.h"
+#include "connect.h"
+#include "rfc2553emu.h"
+#include "http.h"
+
+									/*}}}*/
+using namespace std;
+
+string HttpMethod::FailFile;
+int HttpMethod::FailFd = -1;
+time_t HttpMethod::FailTime = 0;
+unsigned long PipelineDepth = 10;
+unsigned long TimeOut = 120;
+bool Debug = false;
+URI Proxy;
+
+unsigned long CircleBuf::BwReadLimit=0;
+unsigned long CircleBuf::BwTickReadData=0;
+struct timeval CircleBuf::BwReadTick={0,0};
+const unsigned int CircleBuf::BW_HZ=10;
+  
+// CircleBuf::CircleBuf - Circular input buffer				/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+CircleBuf::CircleBuf(unsigned long Size) : Size(Size), Hash(0)
+{
+   Buf = new unsigned char[Size];
+   Reset();
+
+   CircleBuf::BwReadLimit = _config->FindI("Acquire::http::Dl-Limit",0)*1024;
+}
+									/*}}}*/
+// CircleBuf::Reset - Reset to the default state			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void CircleBuf::Reset()
+{
+   InP = 0;
+   OutP = 0;
+   StrPos = 0;
+   MaxGet = (unsigned int)-1;
+   OutQueue = string();
+   if (Hash != 0)
+   {
+      delete Hash;
+      Hash = new Hashes;
+   }   
+};
+									/*}}}*/
+// CircleBuf::Read - Read from a FD into the circular buffer		/*{{{*/
+// ---------------------------------------------------------------------
+/* This fills up the buffer with as much data as is in the FD, assuming it
+   is non-blocking.. */
+bool CircleBuf::Read(int Fd)
+{
+   unsigned long BwReadMax;
+
+   while (1)
+   {
+      // Woops, buffer is full
+      if (InP - OutP == Size)
+	 return true;
+
+      // what's left to read in this tick
+      BwReadMax = CircleBuf::BwReadLimit/BW_HZ;
+
+      if(CircleBuf::BwReadLimit) {
+	 struct timeval now;
+	 gettimeofday(&now,0);
+
+	 unsigned long d = (now.tv_sec-CircleBuf::BwReadTick.tv_sec)*1000000 +
+	    now.tv_usec-CircleBuf::BwReadTick.tv_usec;
+	 if(d > 1000000/BW_HZ) {
+	    CircleBuf::BwReadTick = now;
+	    CircleBuf::BwTickReadData = 0;
+	 } 
+	 
+	 if(CircleBuf::BwTickReadData >= BwReadMax) {
+	    usleep(1000000/BW_HZ);
+	    return true;
+	 }
+      }
+
+      // Write the buffer segment
+      int Res;
+      if(CircleBuf::BwReadLimit) {
+	 Res = read(Fd,Buf + (InP%Size), 
+		    BwReadMax > LeftRead() ? LeftRead() : BwReadMax);
+      } else
+	 Res = read(Fd,Buf + (InP%Size),LeftRead());
+      
+      if(Res > 0 && BwReadLimit > 0) 
+	 CircleBuf::BwTickReadData += Res;
+    
+      if (Res == 0)
+	 return false;
+      if (Res < 0)
+      {
+	 if (errno == EAGAIN)
+	    return true;
+	 return false;
+      }
+
+      if (InP == 0)
+	 gettimeofday(&Start,0);
+      InP += Res;
+   }
+}
+									/*}}}*/
+// CircleBuf::Read - Put the string into the buffer			/*{{{*/
+// ---------------------------------------------------------------------
+/* This will hold the string in and fill the buffer with it as it empties */
+bool CircleBuf::Read(string Data)
+{
+   OutQueue += Data;
+   FillOut();
+   return true;
+}
+									/*}}}*/
+// CircleBuf::FillOut - Fill the buffer from the output queue		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void CircleBuf::FillOut()
+{
+   if (OutQueue.empty() == true)
+      return;
+   while (1)
+   {
+      // Woops, buffer is full
+      if (InP - OutP == Size)
+	 return;
+      
+      // Write the buffer segment
+      unsigned long Sz = LeftRead();
+      if (OutQueue.length() - StrPos < Sz)
+	 Sz = OutQueue.length() - StrPos;
+      memcpy(Buf + (InP%Size),OutQueue.c_str() + StrPos,Sz);
+      
+      // Advance
+      StrPos += Sz;
+      InP += Sz;
+      if (OutQueue.length() == StrPos)
+      {
+	 StrPos = 0;
+	 OutQueue = "";
+	 return;
+      }
+   }
+}
+									/*}}}*/
+// CircleBuf::Write - Write from the buffer into a FD			/*{{{*/
+// ---------------------------------------------------------------------
+/* This empties the buffer into the FD. */
+bool CircleBuf::Write(int Fd)
+{
+   while (1)
+   {
+      FillOut();
+      
+      // Woops, buffer is empty
+      if (OutP == InP)
+	 return true;
+      
+      if (OutP == MaxGet)
+	 return true;
+      
+      // Write the buffer segment
+      int Res;
+      Res = write(Fd,Buf + (OutP%Size),LeftWrite());
+
+      if (Res == 0)
+	 return false;
+      if (Res < 0)
+      {
+	 if (errno == EAGAIN)
+	    return true;
+	 
+	 return false;
+      }
+      
+      if (Hash != 0)
+	 Hash->Add(Buf + (OutP%Size),Res);
+      
+      OutP += Res;
+   }
+}
+									/*}}}*/
+// CircleBuf::WriteTillEl - Write from the buffer to a string		/*{{{*/
+// ---------------------------------------------------------------------
+/* This copies till the first empty line */
+bool CircleBuf::WriteTillEl(string &Data,bool Single)
+{
+   // We cheat and assume it is unneeded to have more than one buffer load
+   for (unsigned long I = OutP; I < InP; I++)
+   {      
+      if (Buf[I%Size] != '\n')
+	 continue;
+      ++I;
+      
+      if (Single == false)
+      {
+         if (I < InP  && Buf[I%Size] == '\r')
+            ++I;
+         if (I >= InP || Buf[I%Size] != '\n')
+            continue;
+         ++I;
+      }
+      
+      Data = "";
+      while (OutP < I)
+      {
+	 unsigned long Sz = LeftWrite();
+	 if (Sz == 0)
+	    return false;
+	 if (I - OutP < Sz)
+	    Sz = I - OutP;
+	 Data += string((char *)(Buf + (OutP%Size)),Sz);
+	 OutP += Sz;
+      }
+      return true;
+   }      
+   return false;
+}
+									/*}}}*/
+// CircleBuf::Stats - Print out stats information			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void CircleBuf::Stats()
+{
+   if (InP == 0)
+      return;
+   
+   struct timeval Stop;
+   gettimeofday(&Stop,0);
+/*   float Diff = Stop.tv_sec - Start.tv_sec + 
+             (float)(Stop.tv_usec - Start.tv_usec)/1000000;
+   clog << "Got " << InP << " in " << Diff << " at " << InP/Diff << endl;*/
+}
+									/*}}}*/
+
+// ServerState::ServerState - Constructor				/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+ServerState::ServerState(URI Srv,HttpMethod *Owner) : Owner(Owner),
+                        In(64*1024), Out(4*1024),
+                        ServerName(Srv)
+{
+   Reset();
+}
+									/*}}}*/
+// ServerState::Open - Open a connection to the server			/*{{{*/
+// ---------------------------------------------------------------------
+/* This opens a connection to the server. */
+bool ServerState::Open()
+{
+   // Use the already open connection if possible.
+   if (ServerFd != -1)
+      return true;
+   
+   Close();
+   In.Reset();
+   Out.Reset();
+   Persistent = true;
+   
+   // Determine the proxy setting
+   if (getenv("http_proxy") == 0)
+   {
+      string DefProxy = _config->Find("Acquire::http::Proxy");
+      string SpecificProxy = _config->Find("Acquire::http::Proxy::" + ServerName.Host);
+      if (SpecificProxy.empty() == false)
+      {
+	 if (SpecificProxy == "DIRECT")
+	    Proxy = "";
+	 else
+	    Proxy = SpecificProxy;
+      }   
+      else
+	 Proxy = DefProxy;
+   }
+   else
+      Proxy = getenv("http_proxy");
+   
+   // Parse no_proxy, a , separated list of domains
+   if (getenv("no_proxy") != 0)
+   {
+      if (CheckDomainList(ServerName.Host,getenv("no_proxy")) == true)
+	 Proxy = "";
+   }
+   
+   // Determine what host and port to use based on the proxy settings
+   int Port = 0;
+   string Host;   
+   if (Proxy.empty() == true || Proxy.Host.empty() == true)
+   {
+      if (ServerName.Port != 0)
+	 Port = ServerName.Port;
+      Host = ServerName.Host;
+   }
+   else
+   {
+      if (Proxy.Port != 0)
+	 Port = Proxy.Port;
+      Host = Proxy.Host;
+   }
+   
+   // Connect to the remote server
+   if (Connect(Host,Port,"http",80,ServerFd,TimeOut,Owner) == false)
+      return false;
+   
+   return true;
+}
+									/*}}}*/
+// ServerState::Close - Close a connection to the server		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool ServerState::Close()
+{
+   close(ServerFd);
+   ServerFd = -1;
+   return true;
+}
+									/*}}}*/
+// ServerState::RunHeaders - Get the headers before the data		/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns 0 if things are OK, 1 if an IO error occursed and 2 if a header
+   parse error occured */
+int ServerState::RunHeaders()
+{
+   State = Header;
+   
+   Owner->Status(_("Waiting for headers"));
+
+   Major = 0; 
+   Minor = 0; 
+   Result = 0; 
+   Size = 0; 
+   StartPos = 0;
+   Encoding = Closes;
+   HaveContent = false;
+   time(&Date);
+
+   do
+   {
+      string Data;
+      if (In.WriteTillEl(Data) == false)
+	 continue;
+
+      if (Debug == true)
+	 clog << Data;
+      
+      for (string::const_iterator I = Data.begin(); I < Data.end(); I++)
+      {
+	 string::const_iterator J = I;
+	 for (; J != Data.end() && *J != '\n' && *J != '\r';J++);
+	 if (HeaderLine(string(I,J)) == false)
+	    return 2;
+	 I = J;
+      }
+
+      // 100 Continue is a Nop...
+      if (Result == 100)
+	 continue;
+      
+      // Tidy up the connection persistance state.
+      if (Encoding == Closes && HaveContent == true)
+	 Persistent = false;
+      
+      return 0;
+   }
+   while (Owner->Go(false,this) == true);
+   
+   return 1;
+}
+									/*}}}*/
+// ServerState::RunData - Transfer the data from the socket		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool ServerState::RunData()
+{
+   State = Data;
+   
+   // Chunked transfer encoding is fun..
+   if (Encoding == Chunked)
+   {
+      while (1)
+      {
+	 // Grab the block size
+	 bool Last = true;
+	 string Data;
+	 In.Limit(-1);
+	 do
+	 {
+	    if (In.WriteTillEl(Data,true) == true)
+	       break;
+	 }
+	 while ((Last = Owner->Go(false,this)) == true);
+
+	 if (Last == false)
+	    return false;
+	 	 
+	 // See if we are done
+	 unsigned long Len = strtol(Data.c_str(),0,16);
+	 if (Len == 0)
+	 {
+	    In.Limit(-1);
+	    
+	    // We have to remove the entity trailer
+	    Last = true;
+	    do
+	    {
+	       if (In.WriteTillEl(Data,true) == true && Data.length() <= 2)
+		  break;
+	    }
+	    while ((Last = Owner->Go(false,this)) == true);
+	    if (Last == false)
+	       return false;
+	    return !_error->PendingError();
+	 }
+	 
+	 // Transfer the block
+	 In.Limit(Len);
+	 while (Owner->Go(true,this) == true)
+	    if (In.IsLimit() == true)
+	       break;
+	 
+	 // Error
+	 if (In.IsLimit() == false)
+	    return false;
+	 
+	 // The server sends an extra new line before the next block specifier..
+	 In.Limit(-1);
+	 Last = true;
+	 do
+	 {
+	    if (In.WriteTillEl(Data,true) == true)
+	       break;
+	 }
+	 while ((Last = Owner->Go(false,this)) == true);
+	 if (Last == false)
+	    return false;
+      }
+   }
+   else
+   {
+      /* Closes encoding is used when the server did not specify a size, the
+         loss of the connection means we are done */
+      if (Encoding == Closes)
+	 In.Limit(-1);
+      else
+	 In.Limit(Size - StartPos);
+      
+      // Just transfer the whole block.
+      do
+      {
+	 if (In.IsLimit() == false)
+	    continue;
+	 
+	 In.Limit(-1);
+	 return !_error->PendingError();
+      }
+      while (Owner->Go(true,this) == true);
+   }
+
+   return Owner->Flush(this) && !_error->PendingError();
+}
+									/*}}}*/
+// ServerState::HeaderLine - Process a header line			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool ServerState::HeaderLine(string Line)
+{
+   if (Line.empty() == true)
+      return true;
+
+   // The http server might be trying to do something evil.
+   if (Line.length() >= MAXLEN)
+      return _error->Error(_("Got a single header line over %u chars"),MAXLEN);
+
+   string::size_type Pos = Line.find(' ');
+   if (Pos == string::npos || Pos+1 > Line.length())
+   {
+      // Blah, some servers use "connection:closes", evil.
+      Pos = Line.find(':');
+      if (Pos == string::npos || Pos + 2 > Line.length())
+	 return _error->Error(_("Bad header line"));
+      Pos++;
+   }
+
+   // Parse off any trailing spaces between the : and the next word.
+   string::size_type Pos2 = Pos;
+   while (Pos2 < Line.length() && isspace(Line[Pos2]) != 0)
+      Pos2++;
+      
+   string Tag = string(Line,0,Pos);
+   string Val = string(Line,Pos2);
+   
+   if (stringcasecmp(Tag.c_str(),Tag.c_str()+4,"HTTP") == 0)
+   {
+      // Evil servers return no version
+      if (Line[4] == '/')
+      {
+	 if (sscanf(Line.c_str(),"HTTP/%u.%u %u %[^\n]",&Major,&Minor,
+		    &Result,Code) != 4)
+	    return _error->Error(_("The HTTP server sent an invalid reply header"));
+      }
+      else
+      {
+	 Major = 0;
+	 Minor = 9;
+	 if (sscanf(Line.c_str(),"HTTP %u %[^\n]",&Result,Code) != 2)
+	    return _error->Error(_("The HTTP server sent an invalid reply header"));
+      }
+
+      /* Check the HTTP response header to get the default persistance
+         state. */
+      if (Major < 1)
+	 Persistent = false;
+      else
+      {
+	 if (Major == 1 && Minor <= 0)
+	    Persistent = false;
+	 else
+	    Persistent = true;
+      }
+
+      return true;
+   }      
+      
+   if (stringcasecmp(Tag,"Content-Length:") == 0)
+   {
+      if (Encoding == Closes)
+	 Encoding = Stream;
+      HaveContent = true;
+      
+      // The length is already set from the Content-Range header
+      if (StartPos != 0)
+	 return true;
+      
+      if (sscanf(Val.c_str(),"%lu",&Size) != 1)
+	 return _error->Error(_("The HTTP server sent an invalid Content-Length header"));
+      return true;
+   }
+
+   if (stringcasecmp(Tag,"Content-Type:") == 0)
+   {
+      HaveContent = true;
+      return true;
+   }
+   
+   if (stringcasecmp(Tag,"Content-Range:") == 0)
+   {
+      HaveContent = true;
+      
+      if (sscanf(Val.c_str(),"bytes %lu-%*u/%lu",&StartPos,&Size) != 2)
+	 return _error->Error(_("The HTTP server sent an invalid Content-Range header"));
+      if ((unsigned)StartPos > Size)
+	 return _error->Error(_("This HTTP server has broken range support"));
+      return true;
+   }
+   
+   if (stringcasecmp(Tag,"Transfer-Encoding:") == 0)
+   {
+      HaveContent = true;
+      if (stringcasecmp(Val,"chunked") == 0)
+	 Encoding = Chunked;      
+      return true;
+   }
+
+   if (stringcasecmp(Tag,"Connection:") == 0)
+   {
+      if (stringcasecmp(Val,"close") == 0)
+	 Persistent = false;
+      if (stringcasecmp(Val,"keep-alive") == 0)
+	 Persistent = true;
+      return true;
+   }
+   
+   if (stringcasecmp(Tag,"Last-Modified:") == 0)
+   {
+      if (StrToTime(Val,Date) == false)
+	 return _error->Error(_("Unknown date format"));
+      return true;
+   }
+
+   return true;
+}
+									/*}}}*/
+
+// HttpMethod::SendReq - Send the HTTP request				/*{{{*/
+// ---------------------------------------------------------------------
+/* This places the http request in the outbound buffer */
+void HttpMethod::SendReq(FetchItem *Itm,CircleBuf &Out)
+{
+   URI Uri = Itm->Uri;
+
+   // The HTTP server expects a hostname with a trailing :port
+   char Buf[1000];
+   string ProperHost = Uri.Host;
+   if (Uri.Port != 0)
+   {
+      sprintf(Buf,":%u",Uri.Port);
+      ProperHost += Buf;
+   }   
+      
+   // Just in case.
+   if (Itm->Uri.length() >= sizeof(Buf))
+       abort();
+       
+   /* Build the request. We include a keep-alive header only for non-proxy
+      requests. This is to tweak old http/1.0 servers that do support keep-alive
+      but not HTTP/1.1 automatic keep-alive. Doing this with a proxy server 
+      will glitch HTTP/1.0 proxies because they do not filter it out and 
+      pass it on, HTTP/1.1 says the connection should default to keep alive
+      and we expect the proxy to do this */
+   if (Proxy.empty() == true || Proxy.Host.empty())
+      sprintf(Buf,"GET %s HTTP/1.1\r\nHost: %s\r\nConnection: keep-alive\r\n",
+	      QuoteString(Uri.Path,"~").c_str(),ProperHost.c_str());
+   else
+   {
+      /* Generate a cache control header if necessary. We place a max
+       	 cache age on index files, optionally set a no-cache directive
+       	 and a no-store directive for archives. */
+      sprintf(Buf,"GET %s HTTP/1.1\r\nHost: %s\r\n",
+	      Itm->Uri.c_str(),ProperHost.c_str());
+      // only generate a cache control header if we actually want to 
+      // use a cache
+      if (_config->FindB("Acquire::http::No-Cache",false) == false)
+      {
+	 if (Itm->IndexFile == true)
+	    sprintf(Buf+strlen(Buf),"Cache-Control: max-age=%u\r\n",
+		    _config->FindI("Acquire::http::Max-Age",0));
+	 else
+	 {
+	    if (_config->FindB("Acquire::http::No-Store",false) == true)
+	       strcat(Buf,"Cache-Control: no-store\r\n");
+	 }	 
+      }
+   }
+   // generate a no-cache header if needed
+   if (_config->FindB("Acquire::http::No-Cache",false) == true)
+      strcat(Buf,"Cache-Control: no-cache\r\nPragma: no-cache\r\n");
+
+   
+   string Req = Buf;
+
+   // Check for a partial file
+   struct stat SBuf;
+   if (stat(Itm->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
+   {
+      // In this case we send an if-range query with a range header
+      sprintf(Buf,"Range: bytes=%li-\r\nIf-Range: %s\r\n",(long)SBuf.st_size - 1,
+	      TimeRFC1123(SBuf.st_mtime).c_str());
+      Req += Buf;
+   }
+   else
+   {
+      if (Itm->LastModified != 0)
+      {
+	 sprintf(Buf,"If-Modified-Since: %s\r\n",TimeRFC1123(Itm->LastModified).c_str());
+	 Req += Buf;
+      }
+   }
+
+   if (Proxy.User.empty() == false || Proxy.Password.empty() == false)
+      Req += string("Proxy-Authorization: Basic ") + 
+          Base64Encode(Proxy.User + ":" + Proxy.Password) + "\r\n";
+
+   if (Uri.User.empty() == false || Uri.Password.empty() == false)
+      Req += string("Authorization: Basic ") + 
+          Base64Encode(Uri.User + ":" + Uri.Password) + "\r\n";
+   
+   Req += "User-Agent: Debian APT-HTTP/1.3 ("VERSION")\r\n\r\n";
+   
+   if (Debug == true)
+      cerr << Req << endl;
+
+   Out.Read(Req);
+}
+									/*}}}*/
+// HttpMethod::Go - Run a single loop					/*{{{*/
+// ---------------------------------------------------------------------
+/* This runs the select loop over the server FDs, Output file FDs and
+   stdin. */
+bool HttpMethod::Go(bool ToFile,ServerState *Srv)
+{
+   // Server has closed the connection
+   if (Srv->ServerFd == -1 && (Srv->In.WriteSpace() == false || 
+			       ToFile == false))
+      return false;
+   
+   fd_set rfds,wfds;
+   FD_ZERO(&rfds);
+   FD_ZERO(&wfds);
+   
+   /* Add the server. We only send more requests if the connection will 
+      be persisting */
+   if (Srv->Out.WriteSpace() == true && Srv->ServerFd != -1 
+       && Srv->Persistent == true)
+      FD_SET(Srv->ServerFd,&wfds);
+   if (Srv->In.ReadSpace() == true && Srv->ServerFd != -1)
+      FD_SET(Srv->ServerFd,&rfds);
+   
+   // Add the file
+   int FileFD = -1;
+   if (File != 0)
+      FileFD = File->Fd();
+   
+   if (Srv->In.WriteSpace() == true && ToFile == true && FileFD != -1)
+      FD_SET(FileFD,&wfds);
+   
+   // Add stdin
+   FD_SET(STDIN_FILENO,&rfds);
+	  
+   // Figure out the max fd
+   int MaxFd = FileFD;
+   if (MaxFd < Srv->ServerFd)
+      MaxFd = Srv->ServerFd;
+
+   // Select
+   struct timeval tv;
+   tv.tv_sec = TimeOut;
+   tv.tv_usec = 0;
+   int Res = 0;
+   if ((Res = select(MaxFd+1,&rfds,&wfds,0,&tv)) < 0)
+   {
+      if (errno == EINTR)
+	 return true;
+      return _error->Errno("select",_("Select failed"));
+   }
+   
+   if (Res == 0)
+   {
+      _error->Error(_("Connection timed out"));
+      return ServerDie(Srv);
+   }
+   
+   // Handle server IO
+   if (Srv->ServerFd != -1 && FD_ISSET(Srv->ServerFd,&rfds))
+   {
+      errno = 0;
+      if (Srv->In.Read(Srv->ServerFd) == false)
+	 return ServerDie(Srv);
+   }
+	 
+   if (Srv->ServerFd != -1 && FD_ISSET(Srv->ServerFd,&wfds))
+   {
+      errno = 0;
+      if (Srv->Out.Write(Srv->ServerFd) == false)
+	 return ServerDie(Srv);
+   }
+
+   // Send data to the file
+   if (FileFD != -1 && FD_ISSET(FileFD,&wfds))
+   {
+      if (Srv->In.Write(FileFD) == false)
+	 return _error->Errno("write",_("Error writing to output file"));
+   }
+
+   // Handle commands from APT
+   if (FD_ISSET(STDIN_FILENO,&rfds))
+   {
+      if (Run(true) != -1)
+	 exit(100);
+   }   
+       
+   return true;
+}
+									/*}}}*/
+// HttpMethod::Flush - Dump the buffer into the file			/*{{{*/
+// ---------------------------------------------------------------------
+/* This takes the current input buffer from the Server FD and writes it
+   into the file */
+bool HttpMethod::Flush(ServerState *Srv)
+{
+   if (File != 0)
+   {
+      // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
+      // can't be set
+      if (File->Name() != "/dev/null")
+	 SetNonBlock(File->Fd(),false);
+      if (Srv->In.WriteSpace() == false)
+	 return true;
+      
+      while (Srv->In.WriteSpace() == true)
+      {
+	 if (Srv->In.Write(File->Fd()) == false)
+	    return _error->Errno("write",_("Error writing to file"));
+	 if (Srv->In.IsLimit() == true)
+	    return true;
+      }
+
+      if (Srv->In.IsLimit() == true || Srv->Encoding == ServerState::Closes)
+	 return true;
+   }
+   return false;
+}
+									/*}}}*/
+// HttpMethod::ServerDie - The server has closed the connection.	/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool HttpMethod::ServerDie(ServerState *Srv)
+{
+   unsigned int LErrno = errno;
+   
+   // Dump the buffer to the file
+   if (Srv->State == ServerState::Data)
+   {
+      // on GNU/kFreeBSD, apt dies on /dev/null because non-blocking
+      // can't be set
+      if (File->Name() != "/dev/null")
+	 SetNonBlock(File->Fd(),false);
+      while (Srv->In.WriteSpace() == true)
+      {
+	 if (Srv->In.Write(File->Fd()) == false)
+	    return _error->Errno("write",_("Error writing to the file"));
+
+	 // Done
+	 if (Srv->In.IsLimit() == true)
+	    return true;
+      }
+   }
+   
+   // See if this is because the server finished the data stream
+   if (Srv->In.IsLimit() == false && Srv->State != ServerState::Header && 
+       Srv->Encoding != ServerState::Closes)
+   {
+      Srv->Close();
+      if (LErrno == 0)
+	 return _error->Error(_("Error reading from server. Remote end closed connection"));
+      errno = LErrno;
+      return _error->Errno("read",_("Error reading from server"));
+   }
+   else
+   {
+      Srv->In.Limit(-1);
+
+      // Nothing left in the buffer
+      if (Srv->In.WriteSpace() == false)
+	 return false;
+      
+      // We may have got multiple responses back in one packet..
+      Srv->Close();
+      return true;
+   }
+   
+   return false;
+}
+									/*}}}*/
+// HttpMethod::DealWithHeaders - Handle the retrieved header data	/*{{{*/
+// ---------------------------------------------------------------------
+/* We look at the header data we got back from the server and decide what
+   to do. Returns 
+     0 - File is open,
+     1 - IMS hit
+     3 - Unrecoverable error 
+     4 - Error with error content page
+     5 - Unrecoverable non-server error (close the connection) */
+int HttpMethod::DealWithHeaders(FetchResult &Res,ServerState *Srv)
+{
+   // Not Modified
+   if (Srv->Result == 304)
+   {
+      unlink(Queue->DestFile.c_str());
+      Res.IMSHit = true;
+      Res.LastModified = Queue->LastModified;
+      return 1;
+   }
+   
+   /* We have a reply we dont handle. This should indicate a perm server
+      failure */
+   if (Srv->Result < 200 || Srv->Result >= 300)
+   {
+      _error->Error("%u %s",Srv->Result,Srv->Code);
+      if (Srv->HaveContent == true)
+	 return 4;
+      return 3;
+   }
+
+   // This is some sort of 2xx 'data follows' reply
+   Res.LastModified = Srv->Date;
+   Res.Size = Srv->Size;
+   
+   // Open the file
+   delete File;
+   File = new FileFd(Queue->DestFile,FileFd::WriteAny);
+   if (_error->PendingError() == true)
+      return 5;
+
+   FailFile = Queue->DestFile;
+   FailFile.c_str();   // Make sure we dont do a malloc in the signal handler
+   FailFd = File->Fd();
+   FailTime = Srv->Date;
+      
+   // Set the expected size
+   if (Srv->StartPos >= 0)
+   {
+      Res.ResumePoint = Srv->StartPos;
+      ftruncate(File->Fd(),Srv->StartPos);
+   }
+      
+   // Set the start point
+   lseek(File->Fd(),0,SEEK_END);
+
+   delete Srv->In.Hash;
+   Srv->In.Hash = new Hashes;
+   
+   // Fill the Hash if the file is non-empty (resume)
+   if (Srv->StartPos > 0)
+   {
+      lseek(File->Fd(),0,SEEK_SET);
+      if (Srv->In.Hash->AddFD(File->Fd(),Srv->StartPos) == false)
+      {
+	 _error->Errno("read",_("Problem hashing file"));
+	 return 5;
+      }
+      lseek(File->Fd(),0,SEEK_END);
+   }
+   
+   SetNonBlock(File->Fd(),true);
+   return 0;
+}
+									/*}}}*/
+// HttpMethod::SigTerm - Handle a fatal signal				/*{{{*/
+// ---------------------------------------------------------------------
+/* This closes and timestamps the open file. This is neccessary to get 
+   resume behavoir on user abort */
+void HttpMethod::SigTerm(int)
+{
+   if (FailFd == -1)
+      _exit(100);
+   close(FailFd);
+   
+   // Timestamp
+   struct utimbuf UBuf;
+   UBuf.actime = FailTime;
+   UBuf.modtime = FailTime;
+   utime(FailFile.c_str(),&UBuf);
+   
+   _exit(100);
+}
+									/*}}}*/
+// HttpMethod::Fetch - Fetch an item					/*{{{*/
+// ---------------------------------------------------------------------
+/* This adds an item to the pipeline. We keep the pipeline at a fixed
+   depth. */
+bool HttpMethod::Fetch(FetchItem *)
+{
+   if (Server == 0)
+      return true;
+
+   // Queue the requests
+   int Depth = -1;
+   for (FetchItem *I = Queue; I != 0 && Depth < (signed)PipelineDepth; 
+	I = I->Next, Depth++)
+   {
+      // If pipelining is disabled, we only queue 1 request
+      if (Server->Pipeline == false && Depth >= 0)
+	 break;
+      
+      // Make sure we stick with the same server
+      if (Server->Comp(I->Uri) == false)
+	 break;
+      if (QueueBack == I)
+      {
+	 QueueBack = I->Next;
+	 SendReq(I,Server->Out);
+	 continue;
+      }
+   }
+   
+   return true;
+};
+									/*}}}*/
+// HttpMethod::Configuration - Handle a configuration message		/*{{{*/
+// ---------------------------------------------------------------------
+/* We stash the desired pipeline depth */
+bool HttpMethod::Configuration(string Message)
+{
+   if (pkgAcqMethod::Configuration(Message) == false)
+      return false;
+   
+   TimeOut = _config->FindI("Acquire::http::Timeout",TimeOut);
+   PipelineDepth = _config->FindI("Acquire::http::Pipeline-Depth",
+				  PipelineDepth);
+   Debug = _config->FindB("Debug::Acquire::http",false);
+   
+   return true;
+}
+									/*}}}*/
+// HttpMethod::Loop - Main loop						/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+int HttpMethod::Loop()
+{
+   signal(SIGTERM,SigTerm);
+   signal(SIGINT,SigTerm);
+   
+   Server = 0;
+   
+   int FailCounter = 0;
+   while (1)
+   {      
+      // We have no commands, wait for some to arrive
+      if (Queue == 0)
+      {
+	 if (WaitFd(STDIN_FILENO) == false)
+	    return 0;
+      }
+      
+      /* Run messages, we can accept 0 (no message) if we didn't
+         do a WaitFd above.. Otherwise the FD is closed. */
+      int Result = Run(true);
+      if (Result != -1 && (Result != 0 || Queue == 0))
+	 return 100;
+
+      if (Queue == 0)
+	 continue;
+      
+      // Connect to the server
+      if (Server == 0 || Server->Comp(Queue->Uri) == false)
+      {
+	 delete Server;
+	 Server = new ServerState(Queue->Uri,this);
+      }
+      /* If the server has explicitly said this is the last connection
+         then we pre-emptively shut down the pipeline and tear down 
+	 the connection. This will speed up HTTP/1.0 servers a tad
+	 since we don't have to wait for the close sequence to
+         complete */
+      if (Server->Persistent == false)
+	 Server->Close();
+      
+      // Reset the pipeline
+      if (Server->ServerFd == -1)
+	 QueueBack = Queue;	 
+	 
+      // Connnect to the host
+      if (Server->Open() == false)
+      {
+	 Fail(true);
+	 delete Server;
+	 Server = 0;
+	 continue;
+      }
+
+      // Fill the pipeline.
+      Fetch(0);
+      
+      // Fetch the next URL header data from the server.
+      switch (Server->RunHeaders())
+      {
+	 case 0:
+	 break;
+	 
+	 // The header data is bad
+	 case 2:
+	 {
+	    _error->Error(_("Bad header data"));
+	    Fail(true);
+	    RotateDNS();
+	    continue;
+	 }
+	 
+	 // The server closed a connection during the header get..
+	 default:
+	 case 1:
+	 {
+	    FailCounter++;
+	    _error->Discard();
+	    Server->Close();
+	    Server->Pipeline = false;
+	    
+	    if (FailCounter >= 2)
+	    {
+	       Fail(_("Connection failed"),true);
+	       FailCounter = 0;
+	    }
+	    
+	    RotateDNS();
+	    continue;
+	 }
+      };
+
+      // Decide what to do.
+      FetchResult Res;
+      Res.Filename = Queue->DestFile;
+      switch (DealWithHeaders(Res,Server))
+      {
+	 // Ok, the file is Open
+	 case 0:
+	 {
+	    URIStart(Res);
+
+	    // Run the data
+	    bool Result =  Server->RunData();
+
+	    /* If the server is sending back sizeless responses then fill in
+	       the size now */
+	    if (Res.Size == 0)
+	       Res.Size = File->Size();
+	    
+	    // Close the file, destroy the FD object and timestamp it
+	    FailFd = -1;
+	    delete File;
+	    File = 0;
+	    
+	    // Timestamp
+	    struct utimbuf UBuf;
+	    time(&UBuf.actime);
+	    UBuf.actime = Server->Date;
+	    UBuf.modtime = Server->Date;
+	    utime(Queue->DestFile.c_str(),&UBuf);
+
+	    // Send status to APT
+	    if (Result == true)
+	    {
+	       Res.TakeHashes(*Server->In.Hash);
+	       URIDone(Res);
+	    }
+	    else
+	    {
+	       if (Server->ServerFd == -1)
+	       {
+		  FailCounter++;
+		  _error->Discard();
+		  Server->Close();
+		  
+		  if (FailCounter >= 2)
+		  {
+		     Fail(_("Connection failed"),true);
+		     FailCounter = 0;
+		  }
+		  
+		  QueueBack = Queue;
+	       }
+	       else
+		  Fail(true);
+	    }
+	    break;
+	 }
+	 
+	 // IMS hit
+	 case 1:
+	 {
+	    URIDone(Res);
+	    break;
+	 }
+	 
+	 // Hard server error, not found or something
+	 case 3:
+	 {
+	    Fail();
+	    break;
+	 }
+	  
+	 // Hard internal error, kill the connection and fail
+	 case 5:
+	 {
+	    delete File;
+	    File = 0;
+
+	    Fail();
+	    RotateDNS();
+	    Server->Close();
+	    break;
+	 }
+
+	 // We need to flush the data, the header is like a 404 w/ error text
+	 case 4:
+	 {
+	    Fail();
+	    
+	    // Send to content to dev/null
+	    File = new FileFd("/dev/null",FileFd::WriteExists);
+	    Server->RunData();
+	    delete File;
+	    File = 0;
+	    break;
+	 }
+	 
+	 default:
+	 Fail(_("Internal error"));
+	 break;
+      }
+      
+      FailCounter = 0;
+   }
+   
+   return 0;
+}
+									/*}}}*/
+
+int main()
+{
+   setlocale(LC_ALL, "");
+
+   HttpMethod Mth;
+   
+   return Mth.Loop();
+}
+
+

Added: apt-transport-debtorrent/branches/upstream/current/http.h
URL: http://svn.debian.org/wsvn/debtorrent/apt-transport-debtorrent/branches/upstream/current/http.h?rev=239&op=file
==============================================================================
--- apt-transport-debtorrent/branches/upstream/current/http.h (added)
+++ apt-transport-debtorrent/branches/upstream/current/http.h Tue Aug 14 22:28:31 2007
@@ -1,0 +1,161 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/// $Id: http.h,v 1.12 2002/04/18 05:09:38 jgg Exp $
+// $Id: http.h,v 1.12 2002/04/18 05:09:38 jgg Exp $
+/* ######################################################################
+
+   HTTP Acquire Method - This is the HTTP aquire method for APT.
+
+   ##################################################################### */
+									/*}}}*/
+
+#ifndef APT_HTTP_H
+#define APT_HTTP_H
+
+#define MAXLEN 360
+
+#include <iostream>
+
+using std::cout;
+using std::endl;
+
+class HttpMethod;
+
+class CircleBuf
+{
+   unsigned char *Buf;
+   unsigned long Size;
+   unsigned long InP;
+   unsigned long OutP;
+   string OutQueue;
+   unsigned long StrPos;
+   unsigned long MaxGet;
+   struct timeval Start;
+   
+   static unsigned long BwReadLimit;
+   static unsigned long BwTickReadData;
+   static struct timeval BwReadTick;
+   static const unsigned int BW_HZ;
+
+   unsigned long LeftRead()
+   {
+      unsigned long Sz = Size - (InP - OutP);
+      if (Sz > Size - (InP%Size))
+	 Sz = Size - (InP%Size);
+      return Sz;
+   }
+   unsigned long LeftWrite()
+   {
+      unsigned long Sz = InP - OutP;
+      if (InP > MaxGet)
+	 Sz = MaxGet - OutP;
+      if (Sz > Size - (OutP%Size))
+	 Sz = Size - (OutP%Size);
+      return Sz;
+   }
+   void FillOut();
+   
+   public:
+   
+   Hashes *Hash;
+   
+   // Read data in
+   bool Read(int Fd);
+   bool Read(string Data);
+   
+   // Write data out
+   bool Write(int Fd);
+   bool WriteTillEl(string &Data,bool Single = false);
+   
+   // Control the write limit
+   void Limit(long Max) {if (Max == -1) MaxGet = 0-1; else MaxGet = OutP + Max;}   
+   bool IsLimit() {return MaxGet == OutP;};
+   void Print() {cout << MaxGet << ',' << OutP << endl;};
+
+   // Test for free space in the buffer
+   bool ReadSpace() {return Size - (InP - OutP) > 0;};
+   bool WriteSpace() {return InP - OutP > 0;};
+
+   // Dump everything
+   void Reset();
+   void Stats();
+
+   CircleBuf(unsigned long Size);
+   ~CircleBuf() {delete [] Buf; delete Hash;};
+};
+
+struct ServerState
+{
+   // This is the last parsed Header Line
+   unsigned int Major;
+   unsigned int Minor;
+   unsigned int Result;
+   char Code[MAXLEN];
+   
+   // These are some statistics from the last parsed header lines
+   unsigned long Size;
+   signed long StartPos;
+   time_t Date;
+   bool HaveContent;
+   enum {Chunked,Stream,Closes} Encoding;
+   enum {Header, Data} State;
+   bool Persistent;
+   
+   // This is a Persistent attribute of the server itself.
+   bool Pipeline;
+   
+   HttpMethod *Owner;
+   
+   // This is the connection itself. Output is data FROM the server
+   CircleBuf In;
+   CircleBuf Out;
+   int ServerFd;
+   URI ServerName;
+  
+   bool HeaderLine(string Line);
+   bool Comp(URI Other) {return Other.Host == ServerName.Host && Other.Port == ServerName.Port;};
+   void Reset() {Major = 0; Minor = 0; Result = 0; Size = 0; StartPos = 0;
+                 Encoding = Closes; time(&Date); ServerFd = -1; 
+                 Pipeline = true;};
+   int RunHeaders();
+   bool RunData();
+   
+   bool Open();
+   bool Close();
+   
+   ServerState(URI Srv,HttpMethod *Owner);
+   ~ServerState() {Close();};
+};
+
+class HttpMethod : public pkgAcqMethod
+{
+   void SendReq(FetchItem *Itm,CircleBuf &Out);
+   bool Go(bool ToFile,ServerState *Srv);
+   bool Flush(ServerState *Srv);
+   bool ServerDie(ServerState *Srv);
+   int DealWithHeaders(FetchResult &Res,ServerState *Srv);
+
+   virtual bool Fetch(FetchItem *);
+   virtual bool Configuration(string Message);
+   
+   // In the event of a fatal signal this file will be closed and timestamped.
+   static string FailFile;
+   static int FailFd;
+   static time_t FailTime;
+   static void SigTerm(int);
+   
+   public:
+   friend class ServerState;
+
+   FileFd *File;
+   ServerState *Server;
+   
+   int Loop();
+   
+   HttpMethod() : pkgAcqMethod("1.2",Pipeline | SendConfig) 
+   {
+      File = 0;
+      Server = 0;
+   };
+};
+
+#endif

Added: apt-transport-debtorrent/branches/upstream/current/rfc2553emu.cc
URL: http://svn.debian.org/wsvn/debtorrent/apt-transport-debtorrent/branches/upstream/current/rfc2553emu.cc?rev=239&op=file
==============================================================================
--- apt-transport-debtorrent/branches/upstream/current/rfc2553emu.cc (added)
+++ apt-transport-debtorrent/branches/upstream/current/rfc2553emu.cc Tue Aug 14 22:28:31 2007
@@ -1,0 +1,245 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+// $Id: rfc2553emu.cc,v 1.8 2001/02/20 07:03:18 jgg Exp $
+/* ######################################################################
+
+   RFC 2553 Emulation - Provides emulation for RFC 2553 getaddrinfo,
+                        freeaddrinfo and getnameinfo
+
+   This is really C code, it just has a .cc extensions to play nicer with
+   the rest of APT.
+   
+   Originally written by Jason Gunthorpe <jgg at debian.org> and placed into
+   the Public Domain, do with it what you will.
+
+   ##################################################################### */
+									/*}}}*/
+#include "rfc2553emu.h"
+#include <stdlib.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifndef HAVE_GETADDRINFO
+// getaddrinfo - Resolve a hostname					/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+int getaddrinfo(const char *nodename, const char *servname,
+		const struct addrinfo *hints,
+		struct addrinfo **res)
+{
+   struct addrinfo **Result = res;
+   hostent *Addr;
+   unsigned int Port;
+   int Proto;
+   const char *End;
+   char **CurAddr;
+   
+   // Try to convert the service as a number
+   Port = htons(strtol(servname,(char **)&End,0));
+   Proto = SOCK_STREAM;
+   
+   if (hints != 0 && hints->ai_socktype != 0)
+      Proto = hints->ai_socktype;
+   
+   // Not a number, must be a name.
+   if (End != servname + strlen(servname))
+   {
+      struct servent *Srv = 0;
+      
+      // Do a lookup in the service database
+      if (hints == 0 || hints->ai_socktype == SOCK_STREAM)
+	 Srv = getservbyname(servname,"tcp");
+      if (hints != 0 && hints->ai_socktype == SOCK_DGRAM)
+	 Srv = getservbyname(servname,"udp");
+      if (Srv == 0)
+	 return EAI_NONAME;  
+      
+      // Get the right protocol
+      Port = Srv->s_port;
+      if (strcmp(Srv->s_proto,"tcp") == 0)
+	 Proto = SOCK_STREAM;
+      else
+      {
+	 if (strcmp(Srv->s_proto,"udp") == 0)
+	    Proto = SOCK_DGRAM;
+         else
+	    return EAI_NONAME;
+      }      
+      
+      if (hints != 0 && hints->ai_socktype != Proto && 
+	  hints->ai_socktype != 0)
+	 return EAI_SERVICE;
+   }
+      
+   // Hostname lookup, only if this is not a listening socket
+   if (hints != 0 && (hints->ai_flags & AI_PASSIVE) != AI_PASSIVE)
+   {
+      Addr = gethostbyname(nodename);
+      if (Addr == 0)
+      {
+	 if (h_errno == TRY_AGAIN)
+	    return EAI_AGAIN;
+	 if (h_errno == NO_RECOVERY)
+	    return EAI_FAIL;
+	 return EAI_NONAME;
+      }
+   
+      // No A records 
+      if (Addr->h_addr_list[0] == 0)
+	 return EAI_NONAME;
+      
+      CurAddr = Addr->h_addr_list;
+   }
+   else
+      CurAddr = (char **)&End;    // Fake!
+   
+   // Start constructing the linked list
+   *res = 0;
+   for (; *CurAddr != 0; CurAddr++)
+   {
+      // New result structure
+      *Result = (struct addrinfo *)calloc(sizeof(**Result),1);
+      if (*Result == 0)
+      {
+	 freeaddrinfo(*res);
+	 return EAI_MEMORY;
+      }
+      if (*res == 0)
+	 *res = *Result;
+      
+      (*Result)->ai_family = AF_INET;
+      (*Result)->ai_socktype = Proto;
+
+      // If we have the IPPROTO defines we can set the protocol field
+      #ifdef IPPROTO_TCP
+      if (Proto == SOCK_STREAM)
+	 (*Result)->ai_protocol = IPPROTO_TCP;
+      if (Proto == SOCK_DGRAM)
+	 (*Result)->ai_protocol = IPPROTO_UDP;
+      #endif
+
+      // Allocate space for the address
+      (*Result)->ai_addrlen = sizeof(struct sockaddr_in);
+      (*Result)->ai_addr = (struct sockaddr *)calloc(sizeof(sockaddr_in),1);
+      if ((*Result)->ai_addr == 0)
+      {
+	 freeaddrinfo(*res);
+	 return EAI_MEMORY;
+      }
+      
+      // Set the address
+      ((struct sockaddr_in *)(*Result)->ai_addr)->sin_family = AF_INET;
+      ((struct sockaddr_in *)(*Result)->ai_addr)->sin_port = Port;
+      
+      if (hints != 0 && (hints->ai_flags & AI_PASSIVE) != AI_PASSIVE)
+	 ((struct sockaddr_in *)(*Result)->ai_addr)->sin_addr = *(in_addr *)(*CurAddr);
+      else
+      {
+         // Already zerod by calloc.
+	 break;
+      }
+      
+      Result = &(*Result)->ai_next;
+   }
+   
+   return 0;
+}
+									/*}}}*/
+// freeaddrinfo - Free the result of getaddrinfo			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void freeaddrinfo(struct addrinfo *ai)
+{
+   struct addrinfo *Tmp;
+   while (ai != 0)
+   {
+      free(ai->ai_addr);
+      Tmp = ai;
+      ai = ai->ai_next;
+      free(ai);
+   }
+}
+									/*}}}*/
+#endif // HAVE_GETADDRINFO
+
+#ifndef HAVE_GETNAMEINFO
+// getnameinfo - Convert a sockaddr to a string 			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+int getnameinfo(const struct sockaddr *sa, socklen_t salen,
+		char *host, size_t hostlen,
+		char *serv, size_t servlen,
+		int flags)
+{
+   struct sockaddr_in *sin = (struct sockaddr_in *)sa;
+   
+   // This routine only supports internet addresses
+   if (sa->sa_family != AF_INET)
+      return EAI_ADDRFAMILY;
+   
+   if (host != 0)
+   {
+      // Try to resolve the hostname
+      if ((flags & NI_NUMERICHOST) != NI_NUMERICHOST)
+      {
+	 struct hostent *Ent = gethostbyaddr((char *)&sin->sin_addr,sizeof(sin->sin_addr),
+					     AF_INET);
+	 if (Ent != 0)
+	    strncpy(host,Ent->h_name,hostlen);
+	 else
+	 {
+	    if ((flags & NI_NAMEREQD) == NI_NAMEREQD)
+	    {
+	       if (h_errno == TRY_AGAIN)
+		  return EAI_AGAIN;
+	       if (h_errno == NO_RECOVERY)
+		  return EAI_FAIL;
+	       return EAI_NONAME;
+	    }
+
+	    flags |= NI_NUMERICHOST;
+	 }
+      }
+      
+      // Resolve as a plain numberic
+      if ((flags & NI_NUMERICHOST) == NI_NUMERICHOST)
+      {
+	 strncpy(host,inet_ntoa(sin->sin_addr),hostlen);
+      }
+   }
+   
+   if (serv != 0)
+   {
+      // Try to resolve the hostname
+      if ((flags & NI_NUMERICSERV) != NI_NUMERICSERV)
+      {
+	 struct servent *Ent;
+	 if ((flags & NI_DATAGRAM) == NI_DATAGRAM)
+	    Ent = getservbyport(ntohs(sin->sin_port),"udp");
+	 else
+	    Ent = getservbyport(ntohs(sin->sin_port),"tcp");
+	 
+	 if (Ent != 0)
+	    strncpy(serv,Ent->s_name,servlen);
+	 else
+	 {
+	    if ((flags & NI_NAMEREQD) == NI_NAMEREQD)
+	       return EAI_NONAME;
+
+	    flags |= NI_NUMERICSERV;
+	 }
+      }
+      
+      // Resolve as a plain numberic
+      if ((flags & NI_NUMERICSERV) == NI_NUMERICSERV)
+      {
+	 snprintf(serv,servlen,"%u",ntohs(sin->sin_port));
+      }
+   }
+   
+   return 0;
+}
+									/*}}}*/
+#endif // HAVE_GETNAMEINFO

Added: apt-transport-debtorrent/branches/upstream/current/rfc2553emu.h
URL: http://svn.debian.org/wsvn/debtorrent/apt-transport-debtorrent/branches/upstream/current/rfc2553emu.h?rev=239&op=file
==============================================================================
--- apt-transport-debtorrent/branches/upstream/current/rfc2553emu.h (added)
+++ apt-transport-debtorrent/branches/upstream/current/rfc2553emu.h Tue Aug 14 22:28:31 2007
@@ -1,0 +1,113 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+// $Id: rfc2553emu.h,v 1.4 2000/06/18 06:04:45 jgg Exp $
+/* ######################################################################
+
+   RFC 2553 Emulation - Provides emulation for RFC 2553 getaddrinfo,
+                        freeaddrinfo and getnameinfo
+   
+   These functions are necessary to write portable protocol independent
+   networking. They transparently support IPv4, IPv6 and probably many 
+   other protocols too. This implementation is needed when the host does 
+   not support these standards. It implements a simple wrapper that 
+   basically supports only IPv4. 
+
+   Perfect emulation is not provided, but it is passable..
+   
+   Originally written by Jason Gunthorpe <jgg at debian.org> and placed into
+   the Public Domain, do with it what you will.
+  
+   ##################################################################### */
+									/*}}}*/
+#ifndef RFC2553EMU_H
+#define RFC2553EMU_H
+
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+// Autosense getaddrinfo
+#if defined(AI_PASSIVE) && defined(EAI_NONAME)
+#define HAVE_GETADDRINFO
+#endif
+
+// Autosense getnameinfo
+#if defined(NI_NUMERICHOST)
+#define HAVE_GETNAMEINFO
+#endif
+
+// getaddrinfo support?
+#ifndef HAVE_GETADDRINFO
+  // Renamed to advoid type clashing.. (for debugging)
+  struct addrinfo_emu
+  {   
+     int     ai_flags;     /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
+     int     ai_family;    /* PF_xxx */
+     int     ai_socktype;  /* SOCK_xxx */
+     int     ai_protocol;  /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
+     size_t  ai_addrlen;   /* length of ai_addr */
+     char   *ai_canonname; /* canonical name for nodename */
+     struct sockaddr  *ai_addr; /* binary address */
+     struct addrinfo_emu  *ai_next; /* next structure in linked list */
+  };
+  #define addrinfo addrinfo_emu
+
+  int getaddrinfo(const char *nodename, const char *servname,
+                  const struct addrinfo *hints,
+                  struct addrinfo **res);
+  void freeaddrinfo(struct addrinfo *ai);
+
+  #ifndef AI_PASSIVE
+  #define AI_PASSIVE (1<<1)
+  #endif
+  
+  #ifndef EAI_NONAME
+  #define EAI_NONAME     -1
+  #define EAI_AGAIN      -2
+  #define EAI_FAIL       -3
+  #define EAI_NODATA     -4
+  #define EAI_FAMILY     -5
+  #define EAI_SOCKTYPE   -6
+  #define EAI_SERVICE    -7
+  #define EAI_ADDRFAMILY -8
+  #define EAI_SYSTEM     -10
+  #define EAI_MEMORY     -11
+  #endif
+
+  /* If we don't have getaddrinfo then we probably don't have 
+     sockaddr_storage either (same RFC) so we definately will not be
+     doing any IPv6 stuff. Do not use the members of this structure to
+     retain portability, cast to a sockaddr. */
+  #define sockaddr_storage sockaddr_in
+#endif
+
+// getnameinfo support (glibc2.0 has getaddrinfo only)
+#ifndef HAVE_GETNAMEINFO
+
+  int getnameinfo(const struct sockaddr *sa, socklen_t salen,
+		  char *host, size_t hostlen,
+		  char *serv, size_t servlen,
+		  int flags);
+
+  #ifndef NI_MAXHOST
+  #define NI_MAXHOST 1025
+  #define NI_MAXSERV 32
+  #endif
+
+  #ifndef NI_NUMERICHOST
+  #define NI_NUMERICHOST (1<<0)
+  #define NI_NUMERICSERV (1<<1)
+//  #define NI_NOFQDN (1<<2)
+  #define NI_NAMEREQD (1<<3)
+  #define NI_DATAGRAM (1<<4)
+  #endif
+
+  #define sockaddr_storage sockaddr_in
+#endif
+
+// Glibc 2.0.7 misses this one
+#ifndef AI_NUMERICHOST
+#define AI_NUMERICHOST 0
+#endif
+
+#endif




More information about the Debtorrent-commits mailing list