acquire-item.h

Go to the documentation of this file.

// -*- mode: cpp; mode: fold -*-
// Description                                                          /*{{{*/
// $Id: acquire-item.h,v 1.26.2.3 2004/01/02 18:51:00 mdz Exp $
/* ######################################################################

   Acquire Item - Item to acquire

   When an item is instantiated it will add it self to the local list in
   the Owner Acquire class. Derived classes will then call QueueURI to 
   register all the URI's they wish to fetch at the initial moment.   
   
   Three item classes are provided to provide functionality for
   downloading of Index, Translation and Packages files.
   
   A Archive class is provided for downloading .deb files. It does Hash
   checking and source location as well as a retry algorithm.
   
   ##################################################################### */
                                                                        /*}}}*/
#ifndef PKGLIB_ACQUIRE_ITEM_H
#define PKGLIB_ACQUIRE_ITEM_H

#include <apt-pkg/acquire.h>
#include <apt-pkg/hashes.h>
#include <apt-pkg/weakptr.h>
#include <apt-pkg/pkgcache.h>

class indexRecords;
class pkgRecords;
class pkgSourceList;

class pkgAcquire::Item : public WeakPointable
{  
   protected:
   
   pkgAcquire *Owner;

   inline void QueueURI(ItemDesc &Item)
                 {Owner->Enqueue(Item);};

   inline void Dequeue() {Owner->Dequeue(this);};
   
   void Rename(std::string From,std::string To);
   
   public:

   enum ItemState
     {
       StatIdle,

       StatFetching,

       StatDone,

       StatError,

       StatAuthError,

       StatTransientNetworkError
     } Status;

   std::string ErrorText;

   unsigned long long FileSize;

   unsigned long long PartialSize;

   const char *Mode;

   unsigned long ID;

   bool Complete;

   bool Local;
   std::string UsedMirror;

   unsigned int QueueCounter;
   
   std::string DestFile;

   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);

   virtual void Done(std::string Message,unsigned long long Size,std::string Hash,
                     pkgAcquire::MethodConfig *Cnf);

   virtual void Start(std::string Message,unsigned long long Size);

   virtual std::string Custom600Headers() {return std::string();};

   virtual std::string DescURI() = 0;
   virtual std::string ShortDesc() {return DescURI();}

   virtual void Finished() {};
   
   virtual std::string HashSum() {return std::string();};

   pkgAcquire *GetOwner() {return Owner;};

   virtual bool IsTrusted() {return false;};
   
   // report mirror problems
   void ReportMirrorFailure(std::string FailCode);


   Item(pkgAcquire *Owner);

   virtual ~Item();
};
                                                                        /*}}}*/         /*{{{*/
struct DiffInfo {
   std::string file;

   std::string sha1;

   unsigned long size;
};
                                                                        /*}}}*/
class pkgAcqSubIndex : public pkgAcquire::Item
{
 protected:
   bool Debug;

   pkgAcquire::ItemDesc Desc;

   HashString ExpectedHash;

 public:
   // Specialized action members
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string DescURI() {return Desc.URI;};
   virtual std::string Custom600Headers();
   virtual bool ParseIndex(std::string const &IndexFile);

   pkgAcqSubIndex(pkgAcquire *Owner, std::string const &URI,std::string const &URIDesc,
                   std::string const &ShortDesc, HashString const &ExpectedHash);
};
                                                                        /*}}}*/
class pkgAcqDiffIndex : public pkgAcquire::Item
{
 protected:
   bool Debug;

   pkgAcquire::ItemDesc Desc;

   std::string RealURI;

   HashString ExpectedHash;

   std::string CurrentPackagesFile;

   std::string Description;

 public:
   // Specialized action members
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string DescURI() {return RealURI + "Index";};
   virtual std::string Custom600Headers();

   bool ParseDiffIndex(std::string IndexDiffFile);
   

   pkgAcqDiffIndex(pkgAcquire *Owner,std::string URI,std::string URIDesc,
                   std::string ShortDesc, HashString ExpectedHash);
};
                                                                        /*}}}*/
class pkgAcqIndexDiffs : public pkgAcquire::Item
{
   private:

   bool QueueNextDiff();

   void Finish(bool allDone=false);

   protected:

   bool Debug;

   pkgAcquire::ItemDesc Desc;

   std::string RealURI;

   HashString ExpectedHash;

   std::string Description;

   std::vector<DiffInfo> available_patches;

   std::string ServerSha1;

   enum DiffState
     {
         StateFetchUnkown,

         StateFetchDiff,
         
         StateUnzipDiff, // FIXME: No longer used

         StateApplyDiff
   } State;

   public:
   
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);

   virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string DescURI() {return RealURI + "Index";};

   pkgAcqIndexDiffs(pkgAcquire *Owner,std::string URI,std::string URIDesc,
                    std::string ShortDesc, HashString ExpectedHash,
                    std::string ServerSha1,
                    std::vector<DiffInfo> diffs=std::vector<DiffInfo>());
};
                                                                        /*}}}*/
class pkgAcqIndex : public pkgAcquire::Item
{
   protected:

   bool Decompression;

   bool Erase;

   // FIXME: instead of a bool it should use a verify string that will
   //        then be used in the pkgAcqIndex::Done method to ensure that
   //        the downloaded file contains the expected tag
   bool Verify;

   pkgAcquire::ItemDesc Desc;

   std::string RealURI;

   HashString ExpectedHash;

   std::string CompressionExtension;

   public:
   
   // Specialized action members
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string Custom600Headers();
   virtual std::string DescURI() {return Desc.URI;};
   virtual std::string HashSum() {return ExpectedHash.toStr(); };

   pkgAcqIndex(pkgAcquire *Owner,std::string URI,std::string URIDesc,
               std::string ShortDesc, HashString ExpectedHash, 
               std::string compressExt="");
   pkgAcqIndex(pkgAcquire *Owner, struct IndexTarget const * const Target,
                         HashString const &ExpectedHash, indexRecords const *MetaIndexParser);
   void Init(std::string const &URI, std::string const &URIDesc, std::string const &ShortDesc);
};
                                                                        /*}}}*/
class pkgAcqIndexTrans : public pkgAcqIndex
{
   public:
  
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual std::string Custom600Headers();

   pkgAcqIndexTrans(pkgAcquire *Owner,std::string URI,std::string URIDesc,
                    std::string ShortDesc);
   pkgAcqIndexTrans(pkgAcquire *Owner, struct IndexTarget const * const Target,
                    HashString const &ExpectedHash, indexRecords const *MetaIndexParser);
};
                                                                        /*}}}*/                         /*{{{*/
class IndexTarget
{
 public:
   std::string URI;

   std::string Description;

   std::string ShortDesc;

   std::string MetaKey;

   virtual bool IsOptional() const {
      return false;
   }
   virtual bool IsSubIndex() const {
      return false;
   }
};
                                                                        /*}}}*/                 /*{{{*/
class OptionalIndexTarget : public IndexTarget
{
   virtual bool IsOptional() const {
      return true;
   }
};
                                                                        /*}}}*/                 /*{{{*/
class SubIndexTarget : public IndexTarget
{
   virtual bool IsSubIndex() const {
      return true;
   }
};
                                                                        /*}}}*/                 /*{{{*/
class OptionalSubIndexTarget : public OptionalIndexTarget
{
   virtual bool IsSubIndex() const {
      return true;
   }
};
                                                                        /*}}}*/

class pkgAcqMetaSig : public pkgAcquire::Item
{
   protected:
   std::string LastGoodSig;

   pkgAcquire::ItemDesc Desc;

   std::string RealURI;

   std::string MetaIndexURI;

   std::string MetaIndexURIDesc;

   std::string MetaIndexShortDesc;

   indexRecords* MetaIndexParser;

   const std::vector<struct IndexTarget*>* IndexTargets;

   public:
   
   // Specialized action members
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string Custom600Headers();
   virtual std::string DescURI() {return RealURI; };

   pkgAcqMetaSig(pkgAcquire *Owner,std::string URI,std::string URIDesc, std::string ShortDesc,
                 std::string MetaIndexURI, std::string MetaIndexURIDesc, std::string MetaIndexShortDesc,
                 const std::vector<struct IndexTarget*>* IndexTargets,
                 indexRecords* MetaIndexParser);
};
                                                                        /*}}}*/
class pkgAcqMetaIndex : public pkgAcquire::Item
{
   protected:
   pkgAcquire::ItemDesc Desc;

   std::string RealURI;

   std::string SigFile;

   const std::vector<struct IndexTarget*>* IndexTargets;

   indexRecords* MetaIndexParser;

   bool AuthPass;
   // required to deal gracefully with problems caused by incorrect ims hits
   bool IMSHit; 

   bool VerifyVendor(std::string Message);

   void RetrievalDone(std::string Message);

   void AuthDone(std::string Message);

   void QueueIndexes(bool verify);
   
   public:
   
   // Specialized action members
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual void Done(std::string Message,unsigned long long Size, std::string Hash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string Custom600Headers();
   virtual std::string DescURI() {return RealURI; };

   pkgAcqMetaIndex(pkgAcquire *Owner,
                   std::string URI,std::string URIDesc, std::string ShortDesc,
                   std::string SigFile,
                   const std::vector<struct IndexTarget*>* IndexTargets,
                   indexRecords* MetaIndexParser);
};
                                                                        /*}}}*/
class pkgAcqMetaClearSig : public pkgAcqMetaIndex
{
   std::string MetaIndexURI;

   std::string MetaIndexURIDesc;

   std::string MetaIndexShortDesc;

   std::string MetaSigURI;

   std::string MetaSigURIDesc;

   std::string MetaSigShortDesc;

public:
   void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual std::string Custom600Headers();

   pkgAcqMetaClearSig(pkgAcquire *Owner,
                std::string const &URI, std::string const &URIDesc, std::string const &ShortDesc,
                std::string const &MetaIndexURI, std::string const &MetaIndexURIDesc, std::string const &MetaIndexShortDesc,
                std::string const &MetaSigURI, std::string const &MetaSigURIDesc, std::string const &MetaSigShortDesc,
                const std::vector<struct IndexTarget*>* IndexTargets,
                indexRecords* MetaIndexParser);
};
                                                                        /*}}}*/
class pkgAcqArchive : public pkgAcquire::Item
{
   protected:
   pkgCache::VerIterator Version;

   pkgAcquire::ItemDesc Desc;

   pkgSourceList *Sources;

   pkgRecords *Recs;

   HashString ExpectedHash;

   std::string &StoreFilename;

   pkgCache::VerFileIterator Vf;

   unsigned int Retries;

   bool Trusted; 

   bool QueueNext();
   
   public:
   
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual void Done(std::string Message,unsigned long long Size,std::string Hash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string DescURI() {return Desc.URI;};
   virtual std::string ShortDesc() {return Desc.ShortDesc;};
   virtual void Finished();
   virtual std::string HashSum() {return ExpectedHash.toStr(); };
   virtual bool IsTrusted();
   
   pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
                 pkgRecords *Recs,pkgCache::VerIterator const &Version,
                 std::string &StoreFilename);
};
                                                                        /*}}}*/
class pkgAcqFile : public pkgAcquire::Item
{
   pkgAcquire::ItemDesc Desc;

   HashString ExpectedHash;

   unsigned int Retries;
   
   bool IsIndexFile;

   public:
   
   // Specialized action members
   virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
   virtual void Done(std::string Message,unsigned long long Size,std::string CalcHash,
                     pkgAcquire::MethodConfig *Cnf);
   virtual std::string DescURI() {return Desc.URI;};
   virtual std::string HashSum() {return ExpectedHash.toStr(); };
   virtual std::string Custom600Headers();

   pkgAcqFile(pkgAcquire *Owner, std::string URI, std::string Hash, unsigned long long Size,
              std::string Desc, std::string ShortDesc,
              const std::string &DestDir="", const std::string &DestFilename="",
              bool IsIndexFile=false);
};
                                                                        /*}}}*/
#endif