acquire-item.h

Go to the documentation of this file.

// -*- mode: cpp; mode: fold -*-
// Description                                                          /*{{{*/
/* ######################################################################
 
   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/indexfile.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/weakptr.h>
 
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
 
 
class pkgRecords;
class pkgSourceList;
class pkgAcqMetaClearSig;
class pkgAcqIndexMergeDiffs;
class metaIndex;
 
class APT_PUBLIC pkgAcquire::Item : public WeakPointable                                /*{{{*/
{
   public:
 
   enum ItemState
     {
       StatIdle,
 
       StatFetching,
 
       StatDone,
 
       StatError,
 
       StatAuthError,
 
       StatTransientNetworkError,
     } Status;
 
   std::string ErrorText;
 
   unsigned long long FileSize;
 
   unsigned long long PartialSize;
 
   std::string ActiveSubprocess;
 
   unsigned long ID;
 
   bool Complete;
 
   bool Local;
 
   std::string UsedMirror;
 
   unsigned int QueueCounter;
 
   unsigned int ExpectedAdditionalItems;
 
   std::string DestFile;
 
   unsigned int Retries;
 
   virtual void Failed(std::string const &Message,pkgAcquire::MethodConfig const * const Cnf);
   APT_HIDDEN void FailMessage(std::string const &Message);
 
   virtual bool VerifyDone(std::string const &Message,
         pkgAcquire::MethodConfig const * const Cnf);
 
   virtual void Done(std::string const &Message, HashStringList const &Hashes,
                     pkgAcquire::MethodConfig const *const Cnf);
 
   virtual void Start(std::string const &Message, unsigned long long const Size);
 
   virtual std::string Custom600Headers() const;
   // this is more a hack than a proper external interface, hence hidden
   APT_HIDDEN std::unordered_map<std::string, std::string> &ModifyCustomFields();
   // this isn't the super nicest interface either…
   APT_HIDDEN bool PopAlternativeURI(std::string &NewURI);
   APT_HIDDEN bool IsGoodAlternativeURI(std::string const &AltUri) const;
   APT_HIDDEN void PushAlternativeURI(std::string &&NewURI, std::unordered_map<std::string, std::string> &&fields, bool const at_the_back);
   APT_HIDDEN void RemoveAlternativeSite(std::string const &AltUri);
 
   virtual std::string DescURI() const = 0;
   virtual std::string ShortDesc() const;
 
   virtual void Finished();
 
   virtual HashStringList GetExpectedHashes() const = 0;
   std::string HashSum() const;
 
   virtual bool HashesRequired() const { return true; }
 
   pkgAcquire *GetOwner() const;
   pkgAcquire::ItemDesc &GetItemDesc();
 
   virtual bool IsTrusted() const;
 
   void SetActiveSubprocess(std::string const &subprocess);
 
   explicit Item(pkgAcquire * const Owner);
 
   virtual ~Item();
 
   bool APT_HIDDEN IsRedirectionLoop(std::string const &NewURI);
   int APT_HIDDEN Priority();
 
   void APT_HIDDEN FetchAfter(time_point FetchAfter);
   time_point APT_HIDDEN FetchAfter();
 
   protected:
   pkgAcquire * const Owner;
 
   pkgAcquire::ItemDesc Desc;
 
   enum RenameOnErrorState {
      HashSumMismatch,
      SizeMismatch,
      InvalidFormat,
      SignatureError,
      NotClearsigned,
      MaximumSizeExceeded,
      PDiffError,
   };
 
   bool RenameOnError(RenameOnErrorState const state);
 
   virtual bool QueueURI(ItemDesc &Item);
 
   void Dequeue();
 
   bool Rename(std::string const &From, std::string const &To);
 
   virtual std::string GetFinalFilename() const;
 
   private:
   class Private;
   Private * const d;
 
   friend class pkgAcqMetaBase;
   friend class pkgAcqMetaClearSig;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqTransactionItem: public pkgAcquire::Item         /*{{{*/
{
   void * const d;
   protected:
   HashStringList GetExpectedHashesFor(std::string const &MetaKey) const;
 
   bool QueueURI(pkgAcquire::ItemDesc &Item) override;
 
   public:
   IndexTarget const Target;
 
   std::string PartialFile;
 
   pkgAcqMetaClearSig * const TransactionManager;
 
   enum TransactionStates {
      TransactionStarted,
      TransactionCommit,
      TransactionAbort,
   };
   virtual bool TransactionState(TransactionStates const state);
 
   [[nodiscard]] std::string DescURI() const override { return Target.URI; }
   [[nodiscard]] HashStringList GetExpectedHashes() const override;
   [[nodiscard]] virtual std::string GetMetaKey() const;
   [[nodiscard]] bool HashesRequired() const override;
   [[nodiscard]] virtual bool AcquireByHash() const;
 
   pkgAcqTransactionItem(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager, IndexTarget const &Target) APT_NONNULL(2, 3);
   ~pkgAcqTransactionItem() override;
 
   friend class pkgAcqMetaBase;
   friend class pkgAcqMetaClearSig;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqMetaBase : public pkgAcqTransactionItem          /*{{{*/
{
   void * const d;
 protected:
   std::vector<pkgAcqTransactionItem*> Transaction;
 
   bool AuthPass;
 
   bool CheckDownloadDone(pkgAcqTransactionItem * const I, const std::string &Message, HashStringList const &Hashes) const;
 
   void QueueForSignatureVerify(pkgAcqTransactionItem * const I, std::string const &File, std::string const &Signature);
 
   [[nodiscard]] std::string Custom600Headers() const override;
 
   bool CheckAuthDone(std::string const &Message, pkgAcquire::MethodConfig const *const Cnf);
 
   bool CheckStopAuthentication(pkgAcquire::Item * const I, const std::string &Message);
 
   bool VerifyVendor(std::string const &Message);
 
   bool TransactionState(TransactionStates state) override;
 
 public:
   // This refers more to the Transaction-Manager than the actual file
   bool IMSHit;
   TransactionStates State;
   std::string BaseURI;
 
   bool QueueURI(pkgAcquire::ItemDesc &Item) override;
   [[nodiscard]] HashStringList GetExpectedHashes() const override;
   [[nodiscard]] bool HashesRequired() const override;
 
   // transaction code
   void Add(pkgAcqTransactionItem * const I);
   void AbortTransaction();
   bool TransactionHasError() const;
   void CommitTransaction();
 
   void TransactionStageCopy(pkgAcqTransactionItem * const I,
                             const std::string &From,
                             const std::string &To);
   void TransactionStageRemoval(pkgAcqTransactionItem * const I, const std::string &FinalFile);
 
   [[nodiscard]] std::string GetFinalFilename() const override;
 
   pkgAcqMetaBase(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                  IndexTarget const &DataTarget) APT_NONNULL(2, 3);
   ~pkgAcqMetaBase() override;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqMetaIndex : public pkgAcqMetaBase
{
   void * const d;
   protected:
   IndexTarget const DetachedSigTarget;
 
   void Init(std::string const &URIDesc, std::string const &ShortDesc);
 
   public:
   [[nodiscard]] std::string DescURI() const override;
 
   // Specialized action members
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   void Done(std::string const &Message, HashStringList const &Hashes,
                     pkgAcquire::MethodConfig const *Cnf) override;
 
   pkgAcqMetaIndex(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                   IndexTarget const &DataTarget, IndexTarget const &DetachedSigTarget) APT_NONNULL(2, 3);
   ~pkgAcqMetaIndex() override;
 
   friend class pkgAcqMetaSig;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqMetaSig final : public pkgAcqTransactionItem
{
   void * const d;
 
   pkgAcqMetaIndex * const MetaIndex;
 
   std::string MetaIndexFileSignature;
 
   protected:
 
   [[nodiscard]] std::string GetFinalFilename() const override;
 
   public:
   [[nodiscard]] bool HashesRequired() const override { return false; }
 
   // Specialized action members
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   void Done(std::string const &Message, HashStringList const &Hashes,
                     pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string Custom600Headers() const override;
 
   pkgAcqMetaSig(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
         IndexTarget const &Target, pkgAcqMetaIndex * const MetaIndex) APT_NONNULL(2, 3, 5);
   ~pkgAcqMetaSig() override;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqMetaClearSig final : public pkgAcqMetaIndex
{
   void * const d;
   IndexTarget const DetachedDataTarget;
 
 public:
   metaIndex *MetaIndexParser;
   metaIndex *LastMetaIndexParser;
 
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string Custom600Headers() const override;
   bool VerifyDone(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   void Done(std::string const &Message, HashStringList const &Hashes,
                     pkgAcquire::MethodConfig const *Cnf) override;
   void Finished() override;
 
   void QueueIndexes(bool const verify);
 
   pkgAcqMetaClearSig(pkgAcquire * const Owner,
                IndexTarget const &ClearsignedTarget,
                IndexTarget const &DetachedDataTarget,
                IndexTarget const &DetachedSigTarget,
                metaIndex * const MetaIndexParser);
   ~pkgAcqMetaClearSig() override;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqBaseIndex : public pkgAcqTransactionItem
{
   void * const d;
 
 public:
   [[nodiscard]] std::string GetFinalFilename() const override;
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
 
   pkgAcqBaseIndex(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                   IndexTarget const &Target) APT_NONNULL(2, 3);
   ~pkgAcqBaseIndex() override;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqIndex : public pkgAcqBaseIndex
{
   void * const d;
 
   protected:
 
   enum AllStages {
      STAGE_DOWNLOAD,
      STAGE_DECOMPRESS_AND_VERIFY,
   };
   AllStages Stage;
 
   void StageDownloadDone(std::string const &Message);
 
   void StageDecompressDone();
 
   std::string EraseFileName;
 
   std::string CompressionExtensions;
 
   std::string CurrentCompressionExtension;
 
   void InitByHashIfNeeded();
 
   [[nodiscard]] std::string GetFinalFilename() const override;
 
   bool TransactionState(TransactionStates state) override;
 
   public:
   // Specialized action members
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   void Done(std::string const &Message, HashStringList const &Hashes,
                     pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string Custom600Headers() const override;
   [[nodiscard]] std::string DescURI() const override { return Desc.URI; };
   [[nodiscard]] std::string GetMetaKey() const override;
 
   pkgAcqIndex(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
               IndexTarget const &Target, bool const Derived = false) APT_NONNULL(2, 3);
   ~pkgAcqIndex() override;
 
   protected:
   APT_HIDDEN void Init(std::string const &URI, std::string const &URIDesc,
             std::string const &ShortDesc);
   APT_HIDDEN bool CommonFailed(std::string const &TargetURI,
                                std::string const &Message, pkgAcquire::MethodConfig const *const Cnf);
};
                                                                        /*}}}*/
struct APT_HIDDEN DiffInfo {                                            /*{{{*/
   std::string file;
 
   HashStringList result_hashes;
 
   HashStringList patch_hashes;
 
   HashStringList download_hashes;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqDiffIndex final : public pkgAcqIndex
{
   void * const d;
   std::vector<pkgAcqIndexMergeDiffs*> * diffs;
   std::vector<DiffInfo> available_patches;
   bool pdiff_merge;
 
 protected:
   bool Debug;
 
   [[nodiscard]] std::string GetFinalFilename() const override;
 
   bool QueueURI(pkgAcquire::ItemDesc &Item) override;
 
   bool TransactionState(TransactionStates state) override;
 
   public:
   // Specialized action members
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   bool VerifyDone(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   void Done(std::string const &Message, HashStringList const &Hashes,
                     pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string DescURI() const override { return Target.URI + "Index"; };
   [[nodiscard]] std::string GetMetaKey() const override;
 
   bool ParseDiffIndex(std::string const &IndexDiffFile);
 
   pkgAcqDiffIndex(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                   IndexTarget const &Target) APT_NONNULL(2, 3);
   ~pkgAcqDiffIndex() override;
 private:
   APT_HIDDEN void QueueOnIMSHit() const;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqIndexMergeDiffs final : public pkgAcqBaseIndex
{
   protected:
 
   bool Debug;
 
   struct DiffInfo const patch;
 
   std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches;
 
   enum DiffState
   {
      StateFetchDiff,
 
      StateApplyDiff,
 
      StateDoneDiff,
 
      StateErrorDiff
   } State;
 
   public:
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   void Done(std::string const &Message, HashStringList const &Hashes,
             pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string Custom600Headers() const override;
   [[nodiscard]] std::string DescURI() const override { return Target.URI + "Index"; };
   [[nodiscard]] HashStringList GetExpectedHashes() const override;
   [[nodiscard]] bool HashesRequired() const override;
   [[nodiscard]] bool AcquireByHash() const override;
 
   pkgAcqIndexMergeDiffs(pkgAcquire *const Owner, pkgAcqMetaClearSig *const TransactionManager,
                         IndexTarget const &Target, DiffInfo const &patch,
                         std::vector<pkgAcqIndexMergeDiffs *> const *const allPatches) APT_NONNULL(2, 3, 6);
   ~pkgAcqIndexMergeDiffs() override;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqIndexDiffs final : public pkgAcqBaseIndex
{
   private:
 
   APT_HIDDEN bool QueueNextDiff();
 
   APT_HIDDEN void Finish(bool const allDone=false);
 
   protected:
 
   bool Debug;
 
   std::vector<DiffInfo> available_patches;
 
   enum DiffState
   {
         StateFetchDiff,
 
         StateApplyDiff
   } State;
 
   public:
 
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
 
   void Done(std::string const &Message, HashStringList const &Hashes,
             pkgAcquire::MethodConfig const * Cnf) override;
   [[nodiscard]] std::string Custom600Headers() const override;
   [[nodiscard]] std::string DescURI() const override { return Target.URI + "IndexDiffs"; };
   [[nodiscard]] HashStringList GetExpectedHashes() const override;
   [[nodiscard]] bool HashesRequired() const override;
   [[nodiscard]] bool AcquireByHash() const override;
 
   pkgAcqIndexDiffs(pkgAcquire *const Owner, pkgAcqMetaClearSig *const TransactionManager,
                    IndexTarget const &Target,
                    std::vector<DiffInfo> const &diffs = std::vector<DiffInfo>()) APT_NONNULL(2, 3);
   ~pkgAcqIndexDiffs() override;
};
                                                                        /*}}}*/
class APT_PUBLIC pkgAcqArchive : public pkgAcquire::Item
{
   void * const d;
 
   bool LocalSource;
   HashStringList ExpectedHashes;
 
   protected:
   pkgCache::VerIterator Version;
 
   pkgSourceList *Sources;
 
   pkgRecords *Recs;
 
   std::string &StoreFilename;
 
   bool Trusted;
 
   bool QueueNext();
 
   [[nodiscard]] std::string GetFinalFilename() const override;
 
   public:
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const * Cnf) override;
   void Done(std::string const &Message, HashStringList const &Hashes,
             pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string DescURI() const override;
   [[nodiscard]] std::string ShortDesc() const override;
   void Finished() override;
   [[nodiscard]] bool IsTrusted() const override;
   [[nodiscard]] HashStringList GetExpectedHashes() const override;
   [[nodiscard]] bool HashesRequired() const override;
 
   pkgAcqArchive(pkgAcquire * const Owner,pkgSourceList * const Sources,
                 pkgRecords * const Recs,pkgCache::VerIterator const &Version,
                 std::string &StoreFilename);
   ~pkgAcqArchive() override;
};
                                                                        /*}}}*/
class APT_PUBLIC pkgAcqChangelog : public pkgAcquire::Item
{
   class Private;
   Private * const d;
   std::string TemporaryDirectory;
   std::string const SrcName;
   std::string const SrcVersion;
 
   public:
   // we will never have hashes for changelogs.
   // If you need verified ones, download the deb and extract the changelog.
   [[nodiscard]] HashStringList GetExpectedHashes() const override { return {}; }
   [[nodiscard]] bool HashesRequired() const override { return false; }
 
   // Specialized action members
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const *Cnf) override;
   void Done(std::string const &Message, HashStringList const &CalcHashes,
             pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string DescURI() const override { return Desc.URI; };
 
   static std::string URI(pkgCache::VerIterator const &Ver);
 
   static std::string URI(pkgCache::RlsFileIterator const &Rls,
         char const * const Component, char const * const SrcName,
         char const * const SrcVersion);
 
   static std::string URI(std::string const &Template,
         char const * const Component, char const * const SrcName,
         char const * const SrcVersion);
 
   static std::string URITemplate(pkgCache::RlsFileIterator const &Rls);
 
   pkgAcqChangelog(pkgAcquire * const Owner, pkgCache::VerIterator const &Ver,
         std::string const &DestDir="", std::string const &DestFilename="");
 
   pkgAcqChangelog(pkgAcquire * const Owner, pkgCache::RlsFileIterator const &Rls,
         char const * const Component, char const * const SrcName, char const * const SrcVersion,
         std::string const &DestDir="", std::string const &DestFilename="");
 
   pkgAcqChangelog(pkgAcquire * const Owner, std::string const &URI,
         char const * const SrcName, char const * const SrcVersion,
         std::string const &DestDir="", std::string const &DestFilename="");
 
   ~pkgAcqChangelog() override;
 
private:
   APT_HIDDEN void Init(std::string const &DestDir, std::string const &DestFilename);
};
                                                                        /*}}}*/
class APT_PUBLIC pkgAcqFile : public pkgAcquire::Item
{
   void * const d;
 
   bool IsIndexFile;
 
   HashStringList const ExpectedHashes;
   public:
   [[nodiscard]] HashStringList GetExpectedHashes() const override;
   [[nodiscard]] bool HashesRequired() const override;
 
   // Specialized action members
   void Done(std::string const &Message, HashStringList const &CalcHashes,
             pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string DescURI() const override { return Desc.URI; };
   [[nodiscard]] std::string Custom600Headers() const override;
 
   pkgAcqFile(pkgAcquire * const Owner, std::string const &URI, HashStringList const &Hashes, unsigned long long const Size,
              std::string const &Desc, std::string const &ShortDesc,
              std::string const &DestDir="", std::string const &DestFilename="",
              bool const IsIndexFile=false);
   ~pkgAcqFile() override;
};
                                                                        /*}}}*/
class APT_HIDDEN pkgAcqAuxFile final : public pkgAcqFile                /*{{{*/
{
   pkgAcquire::Item *const Owner;
   pkgAcquire::Worker *const Worker;
   unsigned long long MaximumSize;
 
   public:
   void Failed(std::string const &Message, pkgAcquire::MethodConfig const * Cnf) override;
   void Done(std::string const &Message, HashStringList const &CalcHashes,
             pkgAcquire::MethodConfig const *Cnf) override;
   [[nodiscard]] std::string Custom600Headers() const override;
   void Finished() override;
 
   pkgAcqAuxFile(pkgAcquire::Item *const Owner, pkgAcquire::Worker *const Worker,
                 std::string const &ShortDesc, std::string const &Desc, std::string const &URI,
                 HashStringList const &Hashes, unsigned long long const MaximumSize);
   ~pkgAcqAuxFile() override;
};
                                                                        /*}}}*/
#endif