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