// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: http.cc,v 1.2 1998/11/01 08:07:13 jgg Exp $
+// $Id: http.cc,v 1.44 2000/01/30 08:16:43 jgg Exp $
/* ######################################################################
HTTP Aquire Method - This is the HTTP aquire method for APT.
#include <sys/time.h>
#include <utime.h>
#include <unistd.h>
+#include <signal.h>
#include <stdio.h>
+#include <errno.h>
// Internet stuff
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
#include <netdb.h>
+#include "connect.h"
+#include "rfc2553emu.h"
#include "http.h"
+
/*}}}*/
+string HttpMethod::FailFile;
+int HttpMethod::FailFd = -1;
+time_t HttpMethod::FailTime = 0;
+unsigned long PipelineDepth = 10;
+unsigned long TimeOut = 120;
+bool Debug = false;
+
// CircleBuf::CircleBuf - Circular input buffer /*{{{*/
// ---------------------------------------------------------------------
/* */
// ---------------------------------------------------------------------
/* */
ServerState::ServerState(URI Srv,HttpMethod *Owner) : Owner(Owner),
- In(64*1024), Out(1*1024),
+ In(64*1024), Out(4*1024),
ServerName(Srv)
{
Reset();
// ---------------------------------------------------------------------
/* This opens a connection to the server. */
string LastHost;
-in_addr LastHostA;
+int LastPort = 0;
+struct addrinfo *LastHostAddr = 0;
bool ServerState::Open()
{
// Use the already open connection if possible.
return true;
Close();
+ In.Reset();
+ Out.Reset();
+
+ // 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");
- int Port = 80;
- string Host;
+ // Parse no_proxy, a , seperated list of hosts
+ if (getenv("no_proxy") != 0)
+ {
+ const char *Start = getenv("no_proxy");
+ for (const char *Cur = Start; true ; Cur++)
+ {
+ if (*Cur != ',' && *Cur != 0)
+ continue;
+ if (stringcasecmp(ServerName.Host.begin(),ServerName.Host.end(),
+ Start,Cur) == 0)
+ {
+ Proxy = "";
+ break;
+ }
+
+ Start = Cur + 1;
+ if (*Cur == 0)
+ break;
+ }
+ }
+ // Determine what host and port to use based on the proxy settings
+ int Port = 0;
+ string Host;
if (Proxy.empty() == true)
{
if (ServerName.Port != 0)
Host = Proxy.Host;
}
- if (LastHost != Host)
- {
- Owner->Status("Connecting to %s",Host.c_str());
-
- // Lookup the host
- hostent *Addr = gethostbyname(Host.c_str());
- if (Addr == 0)
- return _error->Error("Could not resolve '%s'",Host.c_str());
- LastHost = Host;
- LastHostA = *(in_addr *)(Addr->h_addr_list[0]);
- }
-
- Owner->Status("Connecting to %s (%s)",Host.c_str(),inet_ntoa(LastHostA));
-
- // Get a socket
- if ((ServerFd = socket(AF_INET,SOCK_STREAM,0)) < 0)
- return _error->Errno("socket","Could not create a socket");
+ // Connect to the remote server
+ if (Connect(Host,Port,"http",80,ServerFd,TimeOut,Owner) == false)
+ return false;
- // Connect to the server
- struct sockaddr_in server;
- server.sin_family = AF_INET;
- server.sin_port = htons(Port);
- server.sin_addr = LastHostA;
- if (connect(ServerFd,(sockaddr *)&server,sizeof(server)) < 0)
- return _error->Errno("socket","Could not create a socket");
-
- SetNonBlock(ServerFd,true);
return true;
}
/*}}}*/
{
close(ServerFd);
ServerFd = -1;
- In.Reset();
- Out.Reset();
return true;
}
/*}}}*/
string Data;
if (In.WriteTillEl(Data) == false)
continue;
+
+ if (Debug == true)
+ clog << Data;
for (string::const_iterator I = Data.begin(); I < Data.end(); I++)
{
while ((Last = Owner->Go(false,this)) == true);
if (Last == false)
return false;
- return true;
+ return !_error->PendingError();
}
// Transfer the block
continue;
In.Limit(-1);
- return true;
+ return !_error->PendingError();
}
while (Owner->Go(true,this) == true);
}
- return Owner->Flush(this);
+ return Owner->Flush(this) && !_error->PendingError();
}
/*}}}*/
// ServerState::HeaderLine - Process a header 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())
- return _error->Error("Bad header line");
-
- string Tag = string(Line,0,Pos);
- string Val = string(Line,Pos+1);
+ {
+ // 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.begin(),Tag.begin()+4,"HTTP") == 0)
{
// Evil servers return no version
void HttpMethod::SendReq(FetchItem *Itm,CircleBuf &Out)
{
URI Uri = Itm->Uri;
-
+
// The HTTP server expects a hostname with a trailing :port
- char Buf[300];
+ char Buf[1000];
string ProperHost = Uri.Host;
if (Uri.Port != 0)
{
ProperHost += Buf;
}
- // Build the request
+ // 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)
sprintf(Buf,"GET %s HTTP/1.1\r\nHost: %s\r\nConnection: keep-alive\r\n",
- Uri.Path.c_str(),ProperHost.c_str());
+ 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());
- string Req = Buf;
+ if (_config->FindB("Acquire::http::No-Cache",false) == true)
+ strcat(Buf,"Cache-Control: no-cache\r\nPragma: no-cache\r\n");
+ else
+ {
+ if (Itm->IndexFile == true)
+ sprintf(Buf+strlen(Buf),"Cache-Control: max-age=%u\r\n",
+ _config->FindI("Acquire::http::Max-Age",60*60*24));
+ else
+ {
+ if (_config->FindB("Acquire::http::No-Store",false) == true)
+ strcat(Buf,"Cache-Control: no-store\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",SBuf.st_size - 1,
+ sprintf(Buf,"Range: bytes=%li-\r\nIf-Range: %s\r\n",(long)SBuf.st_size - 1,
TimeRFC1123(SBuf.st_mtime).c_str());
Req += Buf;
}
}
}
-/* if (ProxyAuth.empty() == false)
- Req += string("Proxy-Authorization: Basic ") + Base64Encode(ProxyAuth) + "\r\n";*/
+ if (Proxy.User.empty() == false || Proxy.Password.empty() == false)
+ Req += string("Proxy-Authorization: Basic ") +
+ Base64Encode(Proxy.User + ":" + Proxy.Password) + "\r\n";
Req += "User-Agent: Debian APT-HTTP/1.2\r\n\r\n";
-// cout << Req << endl;
+ if (Debug == true)
+ cerr << Req << endl;
+
Out.Read(Req);
}
/*}}}*/
bool HttpMethod::Go(bool ToFile,ServerState *Srv)
{
// Server has closed the connection
- if (Srv->ServerFd == -1 && Srv->In.WriteSpace() == false)
+ if (Srv->ServerFd == -1 && (Srv->In.WriteSpace() == false ||
+ ToFile == false))
return false;
- fd_set rfds,wfds,efds;
+ fd_set rfds,wfds;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
- FD_ZERO(&efds);
// Add the server
if (Srv->Out.WriteSpace() == true && Srv->ServerFd != -1)
// Add stdin
FD_SET(STDIN_FILENO,&rfds);
- // Error Set
- if (FileFD != -1)
- FD_SET(FileFD,&efds);
- if (Srv->ServerFd != -1)
- FD_SET(Srv->ServerFd,&efds);
-
// Figure out the max fd
int MaxFd = FileFD;
if (MaxFd < Srv->ServerFd)
MaxFd = Srv->ServerFd;
-
+
// Select
struct timeval tv;
- tv.tv_sec = 120;
+ tv.tv_sec = TimeOut;
tv.tv_usec = 0;
int Res = 0;
- if ((Res = select(MaxFd+1,&rfds,&wfds,&efds,&tv)) < 0)
+ if ((Res = select(MaxFd+1,&rfds,&wfds,0,&tv)) < 0)
return _error->Errno("select","Select failed");
if (Res == 0)
return ServerDie(Srv);
}
- // Some kind of exception (error) on the sockets, die
- if ((FileFD != -1 && FD_ISSET(FileFD,&efds)) ||
- (Srv->ServerFd != -1 && FD_ISSET(Srv->ServerFd,&efds)))
- return _error->Error("Socket Exception");
-
// Handle server IO
if (Srv->ServerFd != -1 && FD_ISSET(Srv->ServerFd,&rfds))
{
// Handle commands from APT
if (FD_ISSET(STDIN_FILENO,&rfds))
{
- if (Run(true) != 0)
+ if (Run(true) != -1)
exit(100);
}
/* */
bool HttpMethod::ServerDie(ServerState *Srv)
{
+ unsigned int LErrno = errno;
+
// Dump the buffer to the file
if (Srv->State == ServerState::Data)
{
if (Srv->In.IsLimit() == false && Srv->State != ServerState::Header &&
Srv->Encoding != ServerState::Closes)
{
- if (errno == 0)
+ 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
0 - File is open,
1 - IMS hit
3 - Unrecoverable error
- 4 - Error with error content page */
+ 4 - Error with error content page
+ 5 - Unrecoverable non-server error (close the connection) */
int HttpMethod::DealWithHeaders(FetchResult &Res,ServerState *Srv)
{
// Not Modified
delete File;
File = new FileFd(Queue->DestFile,FileFd::WriteAny);
if (_error->PendingError() == true)
- return 3;
-
+ 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)
{
if (Srv->In.MD5->AddFD(File->Fd(),Srv->StartPos) == false)
{
_error->Errno("read","Problem hashing file");
- return 3;
+ return 5;
}
lseek(File->Fd(),0,SEEK_END);
}
return 0;
}
/*}}}*/
-// HttpMethod::Loop /*{{{*/
+// 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;
+ bool Tail = false;
+ 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)
+ Tail = true;
+ if (Tail == true)
+ {
+ 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()
{
- ServerState *Server = 0;
+ signal(SIGTERM,SigTerm);
+ signal(SIGINT,SigTerm);
+
+ Server = 0;
int FailCounter = 0;
while (1)
- {
- if (FailCounter >= 2)
- {
- Fail("Massive Server Brain Damage");
- FailCounter = 0;
- }
-
+ {
// We have no commands, wait for some to arrive
if (Queue == 0)
{
return 0;
}
- // Run messages
- if (Run(true) != 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)
Server = new ServerState(Queue->Uri,this);
}
+ // Reset the pipeline
+ if (Server->ServerFd == -1)
+ QueueBack = Queue;
+
// Connnect to the host
if (Server->Open() == false)
{
- Fail();
+ Fail(true);
+ delete Server;
+ Server = 0;
continue;
}
-
- // Queue the request
- SendReq(Queue,Server->Out);
+ // Fill the pipeline.
+ Fetch(0);
+
// Fetch the next URL header data from the server.
switch (Server->RunHeaders())
{
case 2:
{
_error->Error("Bad header Data");
- Fail();
+ Fail(true);
continue;
}
case 1:
{
FailCounter++;
- _error->DumpErrors();
+ _error->Discard();
Server->Close();
+ Server->Pipeline = false;
+
+ if (FailCounter >= 2)
+ {
+ Fail("Connection failed",true);
+ FailCounter = 0;
+ }
+
continue;
}
};
-
+
// Decide what to do.
FetchResult Res;
+ Res.Filename = Queue->DestFile;
switch (DealWithHeaders(Res,Server))
{
// Ok, the file is Open
URIStart(Res);
// Run the data
- if (Server->RunData() == false)
- Fail();
- else
+ bool Result = Server->RunData();
+
+ // 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.MD5Sum = Server->In.MD5->Result();
URIDone(Res);
}
-
- delete File;
- File = 0;
+ else
+ Fail(true);
+
break;
}
Fail();
break;
}
+
+ // Hard internal error, kill the connection and fail
+ case 5:
+ {
+ Fail();
+ Server->Close();
+ break;
+ }
// We need to flush the data, the header is like a 404 w/ error text
case 4:
projects / apt.git / blobdiff