[apt.git] / apt-pkg / acquire-method.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: acquire-method.cc,v 1.27.2.1 2003/12/24 23:09:17 mdz Exp $
/* ######################################################################

   Acquire Method

   This is a skeleton class that implements most of the functionality
   of a method and some useful functions to make method implementation
   simpler. The methods all derive this and specialize it. The most
   complex implementation is the http method which needs to provide
   pipelining, it runs the message engine at the same time it is 
   downloading files..
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/acquire-method.h>
#include <apt-pkg/error.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/hashes.h>

#include <iostream>
#include <stdio.h>
#include <sys/signal.h>
									/*}}}*/

using namespace std;

// AcqMethod::pkgAcqMethod - Constructor				/*{{{*/
// ---------------------------------------------------------------------
/* This constructs the initialization text */
pkgAcqMethod::pkgAcqMethod(const char *Ver,unsigned long Flags)
{
   std::cout << "100 Capabilities\n"
	     << "Version: " << Ver << "\n";

   if ((Flags & SingleInstance) == SingleInstance)
      std::cout << "Single-Instance: true\n";

   if ((Flags & Pipeline) == Pipeline)
      std::cout << "Pipeline: true\n";

   if ((Flags & SendConfig) == SendConfig)
      std::cout << "Send-Config: true\n";

   if ((Flags & LocalOnly) == LocalOnly)
      std::cout <<"Local-Only: true\n";

   if ((Flags & NeedsCleanup) == NeedsCleanup)
      std::cout << "Needs-Cleanup: true\n";

   if ((Flags & Removable) == Removable)
      std::cout << "Removable: true\n";

   std::cout << "\n" << std::flush;

   SetNonBlock(STDIN_FILENO,true);

   Queue = 0;
   QueueBack = 0;
}
									/*}}}*/
// AcqMethod::Fail - A fetch has failed					/*{{{*/
// ---------------------------------------------------------------------
/* */
void pkgAcqMethod::Fail(bool Transient)
{
   string Err = "Undetermined Error";
   if (_error->empty() == false)
      _error->PopMessage(Err);   
   _error->Discard();
   Fail(Err,Transient);
}
									/*}}}*/
// AcqMethod::Fail - A fetch has failed					/*{{{*/
// ---------------------------------------------------------------------
/* */
void pkgAcqMethod::Fail(string Err,bool Transient)
{
   // Strip out junk from the error messages
   for (string::iterator I = Err.begin(); I != Err.end(); ++I)
   {
      if (*I == '\r') 
	 *I = ' ';
      if (*I == '\n') 
	 *I = ' ';
   }

   if (Queue != 0)
   {
      std::cout << "400 URI Failure\nURI: " << Queue->Uri << "\n"
		<< "Message: " << Err << " " << IP << "\n";
      // Dequeue
      FetchItem *Tmp = Queue;
      Queue = Queue->Next;
      delete Tmp;
      if (Tmp == QueueBack)
	 QueueBack = Queue;
   }
   else
      std::cout << "400 URI Failure\nURI: <UNKNOWN>\nMessage: " << Err << "\n";

   if(FailReason.empty() == false)
      std::cout << "FailReason: " << FailReason << "\n";
   if (UsedMirror.empty() == false)
      std::cout << "UsedMirror: " << UsedMirror << "\n";
   // Set the transient flag
   if (Transient == true)
      std::cout << "Transient-Failure: true\n";

   std::cout << "\n" << std::flush;
}
									/*}}}*/
// AcqMethod::URIStart - Indicate a download is starting		/*{{{*/
// ---------------------------------------------------------------------
/* */
void pkgAcqMethod::URIStart(FetchResult &Res)
{
   if (Queue == 0)
      abort();

   std::cout << "200 URI Start\n"
	     << "URI: " << Queue->Uri << "\n";
   if (Res.Size != 0)
      std::cout << "Size: " << Res.Size << "\n";

   if (Res.LastModified != 0)
      std::cout << "Last-Modified: " << TimeRFC1123(Res.LastModified) << "\n";

   if (Res.ResumePoint != 0)
      std::cout << "Resume-Point: " << Res.ResumePoint << "\n";

   if (UsedMirror.empty() == false)
      std::cout << "UsedMirror: " << UsedMirror << "\n";

   std::cout << "\n" << std::flush;
}
									/*}}}*/
// AcqMethod::URIDone - A URI is finished				/*{{{*/
// ---------------------------------------------------------------------
/* */
void pkgAcqMethod::URIDone(FetchResult &Res, FetchResult *Alt)
{
   if (Queue == 0)
      abort();

   std::cout << "201 URI Done\n"
	     << "URI: " << Queue->Uri << "\n";

   if (Res.Filename.empty() == false)
      std::cout << "Filename: " << Res.Filename << "\n";

   if (Res.Size != 0)
      std::cout << "Size: " << Res.Size << "\n";

   if (Res.LastModified != 0)
      std::cout << "Last-Modified: " << TimeRFC1123(Res.LastModified) << "\n";

   if (Res.MD5Sum.empty() == false)
      std::cout << "MD5-Hash: " << Res.MD5Sum << "\n"
		<< "MD5Sum-Hash: " << Res.MD5Sum << "\n";
   if (Res.SHA1Sum.empty() == false)
      std::cout << "SHA1-Hash: " << Res.SHA1Sum << "\n";
   if (Res.SHA256Sum.empty() == false)
      std::cout << "SHA256-Hash: " << Res.SHA256Sum << "\n";
   if (UsedMirror.empty() == false)
      std::cout << "UsedMirror: " << UsedMirror << "\n";
   if (Res.GPGVOutput.empty() == false)
   {
      std::cout << "GPGVOutput:\n";
      for (vector<string>::const_iterator I = Res.GPGVOutput.begin();
	   I != Res.GPGVOutput.end(); ++I)
	 std::cout << " " << *I << "\n";
   }

   if (Res.ResumePoint != 0)
      std::cout << "Resume-Point: " << Res.ResumePoint << "\n";

   if (Res.IMSHit == true)
      std::cout << "IMS-Hit: true\n";

   if (Alt != 0)
   {
      if (Alt->Filename.empty() == false)
	 std::cout << "Alt-Filename: " << Alt->Filename << "\n";

      if (Alt->Size != 0)
	 std::cout << "Alt-Size: " << Alt->Size << "\n";

      if (Alt->LastModified != 0)
	 std::cout << "Alt-Last-Modified: " << TimeRFC1123(Alt->LastModified) << "\n";

      if (Alt->MD5Sum.empty() == false)
	 std::cout << "Alt-MD5-Hash: " << Alt->MD5Sum << "\n";
      if (Alt->SHA1Sum.empty() == false)
	 std::cout << "Alt-SHA1-Hash: " << Alt->SHA1Sum << "\n";
      if (Alt->SHA256Sum.empty() == false)
	 std::cout << "Alt-SHA256-Hash: " << Alt->SHA256Sum << "\n";

      if (Alt->IMSHit == true)
	 std::cout << "Alt-IMS-Hit: true\n";
   }

   std::cout << "\n" << std::flush;

   // Dequeue
   FetchItem *Tmp = Queue;
   Queue = Queue->Next;
   delete Tmp;
   if (Tmp == QueueBack)
      QueueBack = Queue;
}
									/*}}}*/
// AcqMethod::MediaFail - Syncronous request for new media		/*{{{*/
// ---------------------------------------------------------------------
/* This sends a 403 Media Failure message to the APT and waits for it
   to be ackd */
bool pkgAcqMethod::MediaFail(string Required,string Drive)
{
   fprintf(stdout, "403 Media Failure\nMedia: %s\nDrive: %s\n",
	    Required.c_str(),Drive.c_str());
   std::cout << "\n" << std::flush;

   vector<string> MyMessages;
   
   /* Here we read messages until we find a 603, each non 603 message is
      appended to the main message list for later processing */
   while (1)
   {
      if (WaitFd(STDIN_FILENO) == false)
	 return false;
      
      if (ReadMessages(STDIN_FILENO,MyMessages) == false)
	 return false;

      string Message = MyMessages.front();
      MyMessages.erase(MyMessages.begin());
      
      // Fetch the message number
      char *End;
      int Number = strtol(Message.c_str(),&End,10);
      if (End == Message.c_str())
      {	 
	 cerr << "Malformed message!" << endl;
	 exit(100);
      }

      // Change ack
      if (Number == 603)
      {
	 while (MyMessages.empty() == false)
	 {
	    Messages.push_back(MyMessages.front());
	    MyMessages.erase(MyMessages.begin());
	 }

	 return !StringToBool(LookupTag(Message,"Failed"),false);
      }
      
      Messages.push_back(Message);
   }   
}
									/*}}}*/
// AcqMethod::Configuration - Handle the configuration message		/*{{{*/
// ---------------------------------------------------------------------
/* This parses each configuration entry and puts it into the _config 
   Configuration class. */
bool pkgAcqMethod::Configuration(string Message)
{
   ::Configuration &Cnf = *_config;
   
   const char *I = Message.c_str();
   const char *MsgEnd = I + Message.length();
   
   unsigned int Length = strlen("Config-Item");
   for (; I + Length < MsgEnd; I++)
   {
      // Not a config item
      if (I[Length] != ':' || stringcasecmp(I,I+Length,"Config-Item") != 0)
	 continue;
      
      I += Length + 1;
      
      for (; I < MsgEnd && *I == ' '; I++);
      const char *Equals = (const char*) memchr(I, '=', MsgEnd - I);
      if (Equals == NULL)
	 return false;
      const char *End = (const char*) memchr(Equals, '\n', MsgEnd - Equals);
      if (End == NULL)
	 End = MsgEnd;
      
      Cnf.Set(DeQuoteString(string(I,Equals-I)),
	      DeQuoteString(string(Equals+1,End-Equals-1)));
      I = End;
   }
   
   return true;
}
									/*}}}*/
// AcqMethod::Run - Run the message engine				/*{{{*/
// ---------------------------------------------------------------------
/* Fetch any messages and execute them. In single mode it returns 1 if
   there are no more available messages - any other result is a 
   fatal failure code! */
int pkgAcqMethod::Run(bool Single)
{
   while (1)
   {
      // Block if the message queue is empty
      if (Messages.empty() == true)
      {
	 if (Single == false)
	    if (WaitFd(STDIN_FILENO) == false)
	       break;
	 if (ReadMessages(STDIN_FILENO,Messages) == false)
	    break;
      }
            
      // Single mode exits if the message queue is empty
      if (Single == true && Messages.empty() == true)
	 return -1;
      
      string Message = Messages.front();
      Messages.erase(Messages.begin());
      
      // Fetch the message number
      char *End;
      int Number = strtol(Message.c_str(),&End,10);
      if (End == Message.c_str())
      {	 
	 cerr << "Malformed message!" << endl;
	 return 100;
      }

      switch (Number)
      {	 
	 case 601:
	 if (Configuration(Message) == false)
	    return 100;
	 break;
	 
	 case 600:
	 {
	    FetchItem *Tmp = new FetchItem;
	    
	    Tmp->Uri = LookupTag(Message,"URI");
	    Tmp->DestFile = LookupTag(Message,"FileName");
	    if (RFC1123StrToTime(LookupTag(Message,"Last-Modified").c_str(),Tmp->LastModified) == false)
	       Tmp->LastModified = 0;
	    Tmp->IndexFile = StringToBool(LookupTag(Message,"Index-File"),false);
	    Tmp->FailIgnore = StringToBool(LookupTag(Message,"Fail-Ignore"),false);
	    Tmp->Next = 0;
	    
	    // Append it to the list
	    FetchItem **I = &Queue;
	    for (; *I != 0; I = &(*I)->Next);
	    *I = Tmp;
	    if (QueueBack == 0)
	       QueueBack = Tmp;
	    
	    // Notify that this item is to be fetched.
	    if (Fetch(Tmp) == false)
	       Fail();
	    
	    break;					     
	 }   
      }      
   }

   Exit();
   return 0;
}
									/*}}}*/
// AcqMethod::PrintStatus - privately really send a log/status message	/*{{{*/
// ---------------------------------------------------------------------
/* */
void pkgAcqMethod::PrintStatus(char const * const header, const char* Format,
			       va_list &args) const
{
   string CurrentURI = "<UNKNOWN>";
   if (Queue != 0)
      CurrentURI = Queue->Uri;
   if (UsedMirror.empty() == true)
      fprintf(stdout, "%s\nURI: %s\nMessage: ",
	      header, CurrentURI.c_str());
   else
      fprintf(stdout, "%s\nURI: %s\nUsedMirror: %s\nMessage: ",
	      header, CurrentURI.c_str(), UsedMirror.c_str());
   vfprintf(stdout,Format,args);
   std::cout << "\n\n" << std::flush;
}
									/*}}}*/
// AcqMethod::Log - Send a log message					/*{{{*/
// ---------------------------------------------------------------------
/* */
void pkgAcqMethod::Log(const char *Format,...)
{
   va_list args;
   va_start(args,Format);
   PrintStatus("101 Log", Format, args);
   va_end(args);
}
									/*}}}*/
// AcqMethod::Status - Send a status message				/*{{{*/
// ---------------------------------------------------------------------
/* */
void pkgAcqMethod::Status(const char *Format,...)
{
   va_list args;
   va_start(args,Format);
   PrintStatus("102 Status", Format, args);
   va_end(args);
}
									/*}}}*/
// AcqMethod::Redirect - Send a redirect message                       /*{{{*/
// ---------------------------------------------------------------------
/* This method sends the redirect message and also manipulates the queue
   to keep the pipeline synchronized. */
void pkgAcqMethod::Redirect(const string &NewURI)
{
   std::cout << "103 Redirect\nURI: " << Queue->Uri << "\n"
	     << "New-URI: " << NewURI << "\n"
	     << "\n" << std::flush;

   // Change the URI for the request.
   Queue->Uri = NewURI;

   /* To keep the pipeline synchronized, move the current request to
      the end of the queue, past the end of the current pipeline. */
   FetchItem *I;
   for (I = Queue; I->Next != 0; I = I->Next) ;
   I->Next = Queue;
   Queue = Queue->Next;
   I->Next->Next = 0;
   if (QueueBack == 0)
      QueueBack = I->Next;
}
                                                                        /*}}}*/
// AcqMethod::FetchResult::FetchResult - Constructor			/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgAcqMethod::FetchResult::FetchResult() : LastModified(0),
                                   IMSHit(false), Size(0), ResumePoint(0)
{
}
									/*}}}*/
// AcqMethod::FetchResult::TakeHashes - Load hashes			/*{{{*/
// ---------------------------------------------------------------------
/* This hides the number of hashes we are supporting from the caller. 
   It just deals with the hash class. */
void pkgAcqMethod::FetchResult::TakeHashes(Hashes &Hash)
{
   MD5Sum = Hash.MD5.Result();
   SHA1Sum = Hash.SHA1.Result();
   SHA256Sum = Hash.SHA256.Result();
}
									/*}}}*/
Commit	Line	Data
93bf083d AL	1	// -- mode: cpp; mode: fold --
93bf083d AL	2	// Description /{{{/
b3d44315	3	// $Id: acquire-method.cc,v 1.27.2.1 2003/12/24 23:09:17 mdz Exp $
93bf083d AL	4	/* ######################################################################
	5
	6	Acquire Method
	7
8384ebdf	8	This is a skeleton class that implements most of the functionality
b2e465d6	9	of a method and some useful functions to make method implementation
8384ebdf AL	10	simpler. The methods all derive this and specialize it. The most
	11	complex implementation is the http method which needs to provide
	12	pipelining, it runs the message engine at the same time it is
	13	downloading files..
	14
93bf083d AL	15	##################################################################### */
	16	/}}}/
	17	// Include Files /{{{/
93bf083d AL	18	#include <apt-pkg/acquire-method.h>
	19	#include <apt-pkg/error.h>
	20	#include <apt-pkg/configuration.h>
cdcc6d34	21	#include <apt-pkg/strutl.h>
93bf083d	22	#include <apt-pkg/fileutl.h>
a7c835af	23	#include <apt-pkg/hashes.h>
b4fc9b6f AL	24
b4fc9b6f AL	25	#include <iostream>
93bf083d	26	#include <stdio.h>
b3d44315	27	#include <sys/signal.h>
93bf083d AL	28	/}}}/
93bf083d AL	29
b4fc9b6f AL	30	using namespace std;
b4fc9b6f AL	31
93bf083d AL	32	// AcqMethod::pkgAcqMethod - Constructor /{{{/
	33	// ---------------------------------------------------------------------
	34	/* This constructs the initialization text */
	35	pkgAcqMethod::pkgAcqMethod(const char *Ver,unsigned long Flags)
	36	{
c8848ae2 DK	37	std::cout << "100 Capabilities\n"
c8848ae2 DK	38	<< "Version: " << Ver << "\n";
93bf083d AL	39
93bf083d AL	40	if ((Flags & SingleInstance) == SingleInstance)
c8848ae2 DK	41	std::cout << "Single-Instance: true\n";
c8848ae2 DK	42
93bf083d	43	if ((Flags & Pipeline) == Pipeline)
c8848ae2 DK	44	std::cout << "Pipeline: true\n";
c8848ae2 DK	45
93bf083d	46	if ((Flags & SendConfig) == SendConfig)
c8848ae2	47	std::cout << "Send-Config: true\n";
e331f6ed AL	48
e331f6ed AL	49	if ((Flags & LocalOnly) == LocalOnly)
c8848ae2	50	std::cout <<"Local-Only: true\n";
8e5fc8f5 AL	51
8e5fc8f5 AL	52	if ((Flags & NeedsCleanup) == NeedsCleanup)
c8848ae2	53	std::cout << "Needs-Cleanup: true\n";
459681d3 AL	54
459681d3 AL	55	if ((Flags & Removable) == Removable)
c8848ae2	56	std::cout << "Removable: true\n";
93bf083d	57
c8848ae2	58	std::cout << "\n" << std::flush;
be4401bf AL	59
be4401bf AL	60	SetNonBlock(STDIN_FILENO,true);
5cb5d8dc	61
92e889c8	62	Queue = 0;
5cb5d8dc	63	QueueBack = 0;
93bf083d AL	64	}
	65	/}}}/
	66	// AcqMethod::Fail - A fetch has failed /{{{/
	67	// ---------------------------------------------------------------------
	68	/* */
a72ace20	69	void pkgAcqMethod::Fail(bool Transient)
93bf083d AL	70	{
	71	string Err = "Undetermined Error";
	72	if (_error->empty() == false)
	73	_error->PopMessage(Err);
	74	_error->Discard();
a72ace20	75	Fail(Err,Transient);
93bf083d AL	76	}
	77	/}}}/
	78	// AcqMethod::Fail - A fetch has failed /{{{/
	79	// ---------------------------------------------------------------------
	80	/* */
a72ace20	81	void pkgAcqMethod::Fail(string Err,bool Transient)
6d5dd02a AL	82	{
6d5dd02a AL	83	// Strip out junk from the error messages
f7f0d6c7	84	for (string::iterator I = Err.begin(); I != Err.end(); ++I)
6d5dd02a AL	85	{
	86	if (*I == '\r')
	87	*I = ' ';
	88	if (*I == '\n')
	89	*I = ' ';
	90	}
c8848ae2	91
be4401bf AL	92	if (Queue != 0)
be4401bf AL	93	{
c8848ae2 DK	94	std::cout << "400 URI Failure\nURI: " << Queue->Uri << "\n"
c8848ae2 DK	95	<< "Message: " << Err << " " << IP << "\n";
be4401bf AL	96	// Dequeue
	97	FetchItem *Tmp = Queue;
	98	Queue = Queue->Next;
	99	delete Tmp;
5cb5d8dc AL	100	if (Tmp == QueueBack)
5cb5d8dc AL	101	QueueBack = Queue;
be4401bf AL	102	}
be4401bf AL	103	else
c8848ae2 DK	104	std::cout << "400 URI Failure\nURI: <UNKNOWN>\nMessage: " << Err << "\n";
c8848ae2 DK	105
36280399	106	if(FailReason.empty() == false)
c8848ae2	107	std::cout << "FailReason: " << FailReason << "\n";
36280399	108	if (UsedMirror.empty() == false)
c8848ae2 DK	109	std::cout << "UsedMirror: " << UsedMirror << "\n";
c8848ae2 DK	110	// Set the transient flag
a72ace20	111	if (Transient == true)
c8848ae2 DK	112	std::cout << "Transient-Failure: true\n";
	113
	114	std::cout << "\n" << std::flush;
93bf083d AL	115	}
	116	/}}}/
	117	// AcqMethod::URIStart - Indicate a download is starting /{{{/
	118	// ---------------------------------------------------------------------
	119	/* */
be4401bf	120	void pkgAcqMethod::URIStart(FetchResult &Res)
93bf083d	121	{
be4401bf AL	122	if (Queue == 0)
be4401bf AL	123	abort();
c8848ae2 DK	124
	125	std::cout << "200 URI Start\n"
	126	<< "URI: " << Queue->Uri << "\n";
93bf083d	127	if (Res.Size != 0)
c8848ae2 DK	128	std::cout << "Size: " << Res.Size << "\n";
c8848ae2 DK	129
93bf083d	130	if (Res.LastModified != 0)
c8848ae2 DK	131	std::cout << "Last-Modified: " << TimeRFC1123(Res.LastModified) << "\n";
c8848ae2 DK	132
be4401bf	133	if (Res.ResumePoint != 0)
c8848ae2 DK	134	std::cout << "Resume-Point: " << Res.ResumePoint << "\n";
c8848ae2 DK	135
196fd136	136	if (UsedMirror.empty() == false)
c8848ae2 DK	137	std::cout << "UsedMirror: " << UsedMirror << "\n";
	138
	139	std::cout << "\n" << std::flush;
93bf083d AL	140	}
	141	/}}}/
	142	// AcqMethod::URIDone - A URI is finished /{{{/
	143	// ---------------------------------------------------------------------
	144	/* */
	145	void pkgAcqMethod::URIDone(FetchResult &Res, FetchResult *Alt)
	146	{
be4401bf AL	147	if (Queue == 0)
be4401bf AL	148	abort();
c8848ae2 DK	149
	150	std::cout << "201 URI Done\n"
	151	<< "URI: " << Queue->Uri << "\n";
93bf083d AL	152
93bf083d AL	153	if (Res.Filename.empty() == false)
c8848ae2 DK	154	std::cout << "Filename: " << Res.Filename << "\n";
c8848ae2 DK	155
93bf083d	156	if (Res.Size != 0)
c8848ae2 DK	157	std::cout << "Size: " << Res.Size << "\n";
c8848ae2 DK	158
93bf083d	159	if (Res.LastModified != 0)
c8848ae2	160	std::cout << "Last-Modified: " << TimeRFC1123(Res.LastModified) << "\n";
93bf083d AL	161
93bf083d AL	162	if (Res.MD5Sum.empty() == false)
c8848ae2 DK	163	std::cout << "MD5-Hash: " << Res.MD5Sum << "\n"
c8848ae2 DK	164	<< "MD5Sum-Hash: " << Res.MD5Sum << "\n";
a7c835af	165	if (Res.SHA1Sum.empty() == false)
c8848ae2	166	std::cout << "SHA1-Hash: " << Res.SHA1Sum << "\n";
5d0d7fae	167	if (Res.SHA256Sum.empty() == false)
c8848ae2	168	std::cout << "SHA256-Hash: " << Res.SHA256Sum << "\n";
36280399	169	if (UsedMirror.empty() == false)
c8848ae2 DK	170	std::cout << "UsedMirror: " << UsedMirror << "\n";
	171	if (Res.GPGVOutput.empty() == false)
	172	{
	173	std::cout << "GPGVOutput:\n";
	174	for (vector<string>::const_iterator I = Res.GPGVOutput.begin();
	175	I != Res.GPGVOutput.end(); ++I)
	176	std::cout << " " << *I << "\n";
	177	}
93bf083d	178
b98f2859	179	if (Res.ResumePoint != 0)
c8848ae2	180	std::cout << "Resume-Point: " << Res.ResumePoint << "\n";
b98f2859	181
93bf083d	182	if (Res.IMSHit == true)
c8848ae2 DK	183	std::cout << "IMS-Hit: true\n";
c8848ae2 DK	184
93bf083d AL	185	if (Alt != 0)
	186	{
	187	if (Alt->Filename.empty() == false)
c8848ae2 DK	188	std::cout << "Alt-Filename: " << Alt->Filename << "\n";
c8848ae2 DK	189
93bf083d	190	if (Alt->Size != 0)
c8848ae2 DK	191	std::cout << "Alt-Size: " << Alt->Size << "\n";
c8848ae2 DK	192
93bf083d	193	if (Alt->LastModified != 0)
c8848ae2 DK	194	std::cout << "Alt-Last-Modified: " << TimeRFC1123(Alt->LastModified) << "\n";
c8848ae2 DK	195
93bf083d	196	if (Alt->MD5Sum.empty() == false)
c8848ae2	197	std::cout << "Alt-MD5-Hash: " << Alt->MD5Sum << "\n";
a7c835af	198	if (Alt->SHA1Sum.empty() == false)
c8848ae2	199	std::cout << "Alt-SHA1-Hash: " << Alt->SHA1Sum << "\n";
5d0d7fae	200	if (Alt->SHA256Sum.empty() == false)
c8848ae2 DK	201	std::cout << "Alt-SHA256-Hash: " << Alt->SHA256Sum << "\n";
c8848ae2 DK	202
93bf083d	203	if (Alt->IMSHit == true)
c8848ae2	204	std::cout << "Alt-IMS-Hit: true\n";
93bf083d	205	}
c8848ae2 DK	206
c8848ae2 DK	207	std::cout << "\n" << std::flush;
be4401bf AL	208
	209	// Dequeue
	210	FetchItem *Tmp = Queue;
	211	Queue = Queue->Next;
	212	delete Tmp;
5cb5d8dc AL	213	if (Tmp == QueueBack)
5cb5d8dc AL	214	QueueBack = Queue;
93bf083d AL	215	}
93bf083d AL	216	/}}}/
f46e7681 AL	217	// AcqMethod::MediaFail - Syncronous request for new media /{{{/
	218	// ---------------------------------------------------------------------
	219	/* This sends a 403 Media Failure message to the APT and waits for it
	220	to be ackd */
018f1533	221	bool pkgAcqMethod::MediaFail(string Required,string Drive)
f46e7681	222	{
c8848ae2	223	fprintf(stdout, "403 Media Failure\nMedia: %s\nDrive: %s\n",
f46e7681	224	Required.c_str(),Drive.c_str());
c8848ae2	225	std::cout << "\n" << std::flush;
f46e7681	226
f46e7681 AL	227	vector<string> MyMessages;
	228
	229	/* Here we read messages until we find a 603, each non 603 message is
	230	appended to the main message list for later processing */
	231	while (1)
	232	{
	233	if (WaitFd(STDIN_FILENO) == false)
76d97c26	234	return false;
f46e7681 AL	235
f46e7681 AL	236	if (ReadMessages(STDIN_FILENO,MyMessages) == false)
76d97c26 AL	237	return false;
76d97c26 AL	238
f46e7681 AL	239	string Message = MyMessages.front();
	240	MyMessages.erase(MyMessages.begin());
	241
	242	// Fetch the message number
	243	char *End;
	244	int Number = strtol(Message.c_str(),&End,10);
	245	if (End == Message.c_str())
	246	{
	247	cerr << "Malformed message!" << endl;
	248	exit(100);
	249	}
	250
	251	// Change ack
	252	if (Number == 603)
	253	{
76d97c26	254	while (MyMessages.empty() == false)
f46e7681 AL	255	{
	256	Messages.push_back(MyMessages.front());
	257	MyMessages.erase(MyMessages.begin());
	258	}
542ec555	259
2a749770	260	return !StringToBool(LookupTag(Message,"Failed"),false);
f46e7681 AL	261	}
	262
	263	Messages.push_back(Message);
	264	}
	265	}
	266	/}}}/
93bf083d AL	267	// AcqMethod::Configuration - Handle the configuration message /{{{/
	268	// ---------------------------------------------------------------------
	269	/* This parses each configuration entry and puts it into the _config
	270	Configuration class. */
	271	bool pkgAcqMethod::Configuration(string Message)
	272	{
	273	::Configuration &Cnf = *_config;
	274
b4fc9b6f AL	275	const char *I = Message.c_str();
b4fc9b6f AL	276	const char *MsgEnd = I + Message.length();
93bf083d AL	277
93bf083d AL	278	unsigned int Length = strlen("Config-Item");
b4fc9b6f	279	for (; I + Length < MsgEnd; I++)
93bf083d AL	280	{
	281	// Not a config item
	282	if (I[Length] != ':' \|\| stringcasecmp(I,I+Length,"Config-Item") != 0)
	283	continue;
	284
	285	I += Length + 1;
	286
b4fc9b6f	287	for (; I < MsgEnd && *I == ' '; I++);
404528bd DK	288	const char Equals = (const char) memchr(I, '=', MsgEnd - I);
404528bd DK	289	if (Equals == NULL)
93bf083d	290	return false;
404528bd DK	291	const char End = (const char) memchr(Equals, '\n', MsgEnd - Equals);
	292	if (End == NULL)
	293	End = MsgEnd;
93bf083d	294
6d5dd02a AL	295	Cnf.Set(DeQuoteString(string(I,Equals-I)),
6d5dd02a AL	296	DeQuoteString(string(Equals+1,End-Equals-1)));
93bf083d AL	297	I = End;
	298	}
	299
	300	return true;
	301	}
	302	/}}}/
	303	// AcqMethod::Run - Run the message engine /{{{/
	304	// ---------------------------------------------------------------------
8384ebdf AL	305	/* Fetch any messages and execute them. In single mode it returns 1 if
	306	there are no more available messages - any other result is a
	307	fatal failure code! */
be4401bf	308	int pkgAcqMethod::Run(bool Single)
93bf083d	309	{
93bf083d AL	310	while (1)
93bf083d AL	311	{
be4401bf	312	// Block if the message queue is empty
93bf083d	313	if (Messages.empty() == true)
be4401bf AL	314	{
	315	if (Single == false)
	316	if (WaitFd(STDIN_FILENO) == false)
8e5fc8f5	317	break;
92e889c8	318	if (ReadMessages(STDIN_FILENO,Messages) == false)
8e5fc8f5	319	break;
92e889c8 AL	320	}
92e889c8 AL	321
be4401bf AL	322	// Single mode exits if the message queue is empty
be4401bf AL	323	if (Single == true && Messages.empty() == true)
8384ebdf	324	return -1;
be4401bf	325
93bf083d AL	326	string Message = Messages.front();
	327	Messages.erase(Messages.begin());
	328
	329	// Fetch the message number
	330	char *End;
	331	int Number = strtol(Message.c_str(),&End,10);
	332	if (End == Message.c_str())
	333	{
	334	cerr << "Malformed message!" << endl;
	335	return 100;
	336	}
	337
	338	switch (Number)
8e5fc8f5	339	{
93bf083d AL	340	case 601:
	341	if (Configuration(Message) == false)
	342	return 100;
	343	break;
	344
	345	case 600:
be4401bf AL	346	{
	347	FetchItem *Tmp = new FetchItem;
	348
	349	Tmp->Uri = LookupTag(Message,"URI");
	350	Tmp->DestFile = LookupTag(Message,"FileName");
96cc64a5	351	if (RFC1123StrToTime(LookupTag(Message,"Last-Modified").c_str(),Tmp->LastModified) == false)
b98f2859	352	Tmp->LastModified = 0;
a72ace20	353	Tmp->IndexFile = StringToBool(LookupTag(Message,"Index-File"),false);
963b16dc	354	Tmp->FailIgnore = StringToBool(LookupTag(Message,"Fail-Ignore"),false);
be4401bf AL	355	Tmp->Next = 0;
	356
	357	// Append it to the list
	358	FetchItem **I = &Queue;
92e889c8	359	for (; I != 0; I = &(I)->Next);
be4401bf	360	*I = Tmp;
5cb5d8dc AL	361	if (QueueBack == 0)
	362	QueueBack = Tmp;
	363
bfd22fc0	364	// Notify that this item is to be fetched.
be4401bf	365	if (Fetch(Tmp) == false)
93bf083d	366	Fail();
bfd22fc0	367
93bf083d AL	368	break;
	369	}
	370	}
	371	}
	372
8e5fc8f5	373	Exit();
93bf083d AL	374	return 0;
	375	}
	376	/}}}/
f1bdfe81	377	// AcqMethod::PrintStatus - privately really send a log/status message /{{{/
be4401bf AL	378	// ---------------------------------------------------------------------
be4401bf AL	379	/* */
f1bdfe81 DK	380	void pkgAcqMethod::PrintStatus(char const * const header, const char* Format,
f1bdfe81 DK	381	va_list &args) const
be4401bf AL	382	{
	383	string CurrentURI = "<UNKNOWN>";
	384	if (Queue != 0)
	385	CurrentURI = Queue->Uri;
f1bdfe81 DK	386	if (UsedMirror.empty() == true)
	387	fprintf(stdout, "%s\nURI: %s\nMessage: ",
	388	header, CurrentURI.c_str());
	389	else
	390	fprintf(stdout, "%s\nURI: %s\nUsedMirror: %s\nMessage: ",
	391	header, CurrentURI.c_str(), UsedMirror.c_str());
	392	vfprintf(stdout,Format,args);
	393	std::cout << "\n\n" << std::flush;
	394	}
	395	/}}}/
	396	// AcqMethod::Log - Send a log message /{{{/
	397	// ---------------------------------------------------------------------
	398	/* */
	399	void pkgAcqMethod::Log(const char *Format,...)
	400	{
be4401bf AL	401	va_list args;
be4401bf AL	402	va_start(args,Format);
f1bdfe81	403	PrintStatus("101 Log", Format, args);
c8848ae2	404	va_end(args);
be4401bf AL	405	}
	406	/}}}/
	407	// AcqMethod::Status - Send a status message /{{{/
	408	// ---------------------------------------------------------------------
	409	/* */
	410	void pkgAcqMethod::Status(const char *Format,...)
	411	{
be4401bf AL	412	va_list args;
be4401bf AL	413	va_start(args,Format);
f1bdfe81	414	PrintStatus("102 Status", Format, args);
c8848ae2	415	va_end(args);
be4401bf AL	416	}
be4401bf AL	417	/}}}/
ebb461fd MV	418	// AcqMethod::Redirect - Send a redirect message /{{{/
	419	// ---------------------------------------------------------------------
	420	/* This method sends the redirect message and also manipulates the queue
	421	to keep the pipeline synchronized. */
	422	void pkgAcqMethod::Redirect(const string &NewURI)
	423	{
b40b7c38 DK	424	std::cout << "103 Redirect\nURI: " << Queue->Uri << "\n"
b40b7c38 DK	425	<< "New-URI: " << NewURI << "\n"
c8848ae2	426	<< "\n" << std::flush;
ebb461fd MV	427
	428	// Change the URI for the request.
	429	Queue->Uri = NewURI;
	430
	431	/* To keep the pipeline synchronized, move the current request to
	432	the end of the queue, past the end of the current pipeline. */
	433	FetchItem *I;
	434	for (I = Queue; I->Next != 0; I = I->Next) ;
	435	I->Next = Queue;
	436	Queue = Queue->Next;
	437	I->Next->Next = 0;
	438	if (QueueBack == 0)
	439	QueueBack = I->Next;
	440	}
	441	/}}}/
93bf083d AL	442	// AcqMethod::FetchResult::FetchResult - Constructor /{{{/
	443	// ---------------------------------------------------------------------
	444	/* */
93274b8d AL	445	pkgAcqMethod::FetchResult::FetchResult() : LastModified(0),
93274b8d AL	446	IMSHit(false), Size(0), ResumePoint(0)
93bf083d AL	447	{
	448	}
	449	/}}}/
a7c835af AL	450	// AcqMethod::FetchResult::TakeHashes - Load hashes /{{{/
	451	// ---------------------------------------------------------------------
	452	/* This hides the number of hashes we are supporting from the caller.
	453	It just deals with the hash class. */
	454	void pkgAcqMethod::FetchResult::TakeHashes(Hashes &Hash)
	455	{
	456	MD5Sum = Hash.MD5.Result();
	457	SHA1Sum = Hash.SHA1.Result();
5d0d7fae	458	SHA256Sum = Hash.SHA256.Result();
a7c835af AL	459	}
a7c835af AL	460	/}}}/