pkgcache.h

Go to the documentation of this file.

// -*- mode: cpp; mode: fold -*-
// Description                                                          /*{{{*/
                                                                        /*}}}*/
#ifndef PKGLIB_PKGCACHE_H
#define PKGLIB_PKGCACHE_H
#define __PKGLIB_IN_PKGCACHE_H
#include <apt-pkg/macros.h>
#include <apt-pkg/mmap.h>
 
#include <cstddef> // required for nullptr_t
#include <cstdint>
#include <ctime>
#include <string>
#include <string_view>
 
 
 
// size of (potentially big) files like debs or the install size of them
typedef uint64_t map_filesize_t;
// storing file sizes of indexes, which are way below 4 GB for now
typedef uint32_t map_filesize_small_t;
// each package/group/dependency gets an id
typedef uint32_t map_id_t;
// some files get an id, too, but in far less absolute numbers
typedef uint16_t map_fileid_t;
 
// relative pointer from cache start
template <typename T> class map_pointer {
   uint32_t val;
public:
   map_pointer() noexcept : val(0) {}
   map_pointer(std::nullptr_t) noexcept : val(0) {}
   explicit map_pointer(uint32_t n) noexcept : val(n) {}
   explicit operator uint32_t() noexcept { return val; }
   explicit operator bool() noexcept { return val != 0; }
};
 
template<typename T> inline T *operator +(T *p, map_pointer<T> m) { return p + uint32_t(m); }
template<typename T> inline bool operator ==(map_pointer<T> u, map_pointer<T> m) { return uint32_t(u) == uint32_t(m); }
template<typename T> inline bool operator !=(map_pointer<T> u, map_pointer<T> m) { return uint32_t(u) != uint32_t(m); }
template<typename T> inline bool operator <(map_pointer<T> u, map_pointer<T> m) { return uint32_t(u) < uint32_t(m); }
template<typename T> inline bool operator >(map_pointer<T> u, map_pointer<T> m) { return uint32_t(u) > uint32_t(m); }
template<typename T> inline uint32_t operator -(map_pointer<T> u, map_pointer<T> m) { return uint32_t(u) - uint32_t(m); }
template<typename T> bool operator ==(map_pointer<T> m, std::nullptr_t) { return uint32_t(m) == 0; }
template<typename T> bool operator !=(map_pointer<T> m, std::nullptr_t) { return uint32_t(m) != 0; }
 
// same as the previous, but documented to be to a string item
typedef map_pointer<char> map_stringitem_t;
 
// we have only a small amount of flags for each item
typedef uint8_t map_flags_t;
typedef uint8_t map_number_t;
 
class pkgVersioningSystem;
class APT_PUBLIC pkgCache                                                               /*{{{*/
{
   public:
   // Cache element predeclarations
   struct Header;
   struct Group;
   struct Package;
   struct ReleaseFile;
   struct PackageFile;
   struct SourceVersion;
   struct Version;
   struct Description;
   struct Provides;
   struct Dependency;
   struct DependencyData;
   struct StringItem;
   struct VerFile;
   struct DescFile;
   
   // Iterators
   template<typename Str, typename Itr> class Iterator;
   class GrpIterator;
   class PkgIterator;
   class VerIterator;
   class SrcVerIterator;
   class DescIterator;
   class DepIterator;
   class PrvIterator;
   class RlsFileIterator;
   class PkgFileIterator;
   class VerFileIterator;
   class DescFileIterator;
   
   class Namespace;
   
   // These are all the constants used in the cache structures
 
   // WARNING - if you change these lists you must also edit
   // the stringification in pkgcache.cc and also consider whether
   // the cache file will become incompatible.
   struct Dep
   {
      enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
         Conflicts=5,Replaces=6,Obsoletes=7,DpkgBreaks=8,Enhances=9};
      enum DepCompareOp {NoOp=0,LessEq=0x1,GreaterEq=0x2,Less=0x3,
         Greater=0x4,Equals=0x5,NotEquals=0x6,
         Or=0x10, 
         MultiArchImplicit=0x20, 
         ArchSpecific=0x40 
      };
   };
   
   struct State
   {
      enum VerPriority {Required=1,Important=2,Standard=3,Optional=4,Extra=5};
      enum PkgSelectedState {Unknown=0,Install=1,Hold=2,DeInstall=3,Purge=4};
      enum PkgInstState {Ok=0,ReInstReq=1,HoldInst=2,HoldReInstReq=3};
      enum PkgCurrentState {NotInstalled=0,UnPacked=1,HalfConfigured=2,
           HalfInstalled=4,ConfigFiles=5,Installed=6,
           TriggersAwaited=7,TriggersPending=8};
   };
   
   struct Flag
   {
      enum PkgFlags {Auto=(1<<0),Essential=(1<<3),Important=(1<<4)};
      enum PkgFFlags {
         NotSource=(1<<0), 
         LocalSource=(1<<1), 
         NoPackages=(1<<2), 
      };
      enum ReleaseFileFlags {
         NotAutomatic=(1<<0), 
         ButAutomaticUpgrades=(1<<1), 
      };
      enum ProvidesFlags {
         MultiArchImplicit=pkgCache::Dep::MultiArchImplicit, 
         ArchSpecific=pkgCache::Dep::ArchSpecific 
      };
   };
   
   protected:
   
   // Memory mapped cache file
   std::string CacheFile;
   MMap &Map;
   map_id_t sHash(std::string_view S) const APT_PURE;
   
   public:
   
   // Pointers to the arrays of items
   Header *HeaderP;
   Group *GrpP;
   Package *PkgP;
   VerFile *VerFileP;
   DescFile *DescFileP;
   ReleaseFile *RlsFileP;
   PackageFile *PkgFileP;
   SourceVersion *SrcVerP; // reserved for SourceVersion objects
   Version *VerP;
   Description *DescP;
   Provides *ProvideP;
   Dependency *DepP;
   DependencyData *DepDataP;
   char *StrP;
   void *reserved[13];
 
   virtual bool ReMap(bool const &Errorchecks = true);
   inline bool Sync() {return Map.Sync();}
   inline MMap &GetMap() {return Map;}
   inline void *DataEnd() {return ((unsigned char *)Map.Data()) + Map.Size();}
      
   // String hashing function (512 range)
   inline map_id_t Hash(std::string_view S) const {return sHash(S);}
 
   APT_HIDDEN uint32_t CacheHash();
 
   // Useful transformation things
   static const char *Priority(unsigned char Priority);
   static std::string_view Priority_NoL10n(unsigned char Prio);
 
   // Accessors
   GrpIterator FindGrp(std::string_view Name);
   PkgIterator FindPkg(std::string_view Name);
   PkgIterator FindPkg(std::string_view Name, std::string_view Arch);
 
   std::string_view ViewString(map_stringitem_t idx) const
   {
      char *name = StrP + idx;
      size_t len = *reinterpret_cast<const uint16_t*>(name - sizeof(uint16_t));
      return {name, len};
   }
 
   Header &Head() {return *HeaderP;}
   inline GrpIterator GrpBegin();
   inline GrpIterator GrpEnd();
   inline PkgIterator PkgBegin();
   inline PkgIterator PkgEnd();
   inline PkgFileIterator FileBegin();
   inline PkgFileIterator FileEnd();
   inline RlsFileIterator RlsFileBegin();
   inline RlsFileIterator RlsFileEnd();
 
   inline bool MultiArchCache() const { return MultiArchEnabled; }
   inline char const * NativeArch();
 
   // Make me a function
   pkgVersioningSystem *VS;
   
   // Converters
   static const char *CompTypeDeb(unsigned char Comp) APT_PURE;
   static const char *CompType(unsigned char Comp) APT_PURE;
   static const char *DepType(unsigned char Dep);
   static std::string_view DepType_NoL10n(unsigned char Dep);
 
   pkgCache(MMap *Map,bool DoMap = true);
   virtual ~pkgCache();
 
private:
   void * const d;
   bool MultiArchEnabled;
};
                                                                        /*}}}*/
// Header structure                                                     /*{{{*/
struct pkgCache::Header
{
   uint32_t Signature;
   map_number_t MajorVersion;
   map_number_t MinorVersion;
   bool Dirty;
 
   uint16_t HeaderSz;
   map_number_t GroupSz;
   map_number_t PackageSz;
   map_number_t ReleaseFileSz;
   map_number_t PackageFileSz;
   map_number_t VersionSz;
   map_number_t SourceVersionSz;
   map_number_t DescriptionSz;
   map_number_t DependencySz;
   map_number_t DependencyDataSz;
   map_number_t ProvidesSz;
   map_number_t VerFileSz;
   map_number_t DescFileSz;
 
   map_id_t GroupCount;
   map_id_t PackageCount;
   map_id_t VersionCount;
   map_id_t SourceVersionCount;
   map_id_t DescriptionCount;
   map_id_t DependsCount;
   map_id_t DependsDataCount;
   map_fileid_t ReleaseFileCount;
   map_fileid_t PackageFileCount;
   map_id_t VerFileCount;
   map_id_t DescFileCount;
   map_id_t ProvidesCount;
 
   map_pointer<PackageFile> FileList;
   map_pointer<ReleaseFile> RlsFileList;
 
   map_stringitem_t VerSysName;
   map_stringitem_t Architecture;
   map_stringitem_t Architectures;
   map_filesize_t MaxVerFileSize;
   map_filesize_t MaxDescFileSize;
 
   DynamicMMap::Pool Pools[2 * 13];
 
   uint32_t HashTableSize;
   uint32_t GetHashTableSize() const { return HashTableSize; }
   void SetHashTableSize(unsigned int const sz) { HashTableSize = sz; }
   map_stringitem_t GetArchitectures() const { return Architectures; }
   void SetArchitectures(map_stringitem_t const idx) { Architectures = idx; }
 
#ifdef APT_COMPILING_APT
   map_pointer<Group> * GrpHashTableP() const { return (map_pointer<Group>*) (this + 1); }
   map_pointer<Package> * PkgHashTableP() const { return reinterpret_cast<map_pointer<Package> *>(GrpHashTableP() + GetHashTableSize()); }
#endif
 
   map_filesize_small_t CacheFileSize;
 
   bool CheckSizes(Header &Against) const APT_PURE;
   Header();
};
                                                                        /*}}}*/
// Group structure                                                      /*{{{*/
struct pkgCache::Group
{
   map_stringitem_t Name;
 
   // Linked List
   map_pointer<Package> FirstPackage;
   map_pointer<Package> LastPackage;
 
   map_pointer<Group> Next;
   map_id_t ID;
 
   map_pointer<Version> VersionsInSource;
 
   map_pointer<SourceVersion> SourceVersionList;
 
   map_pointer<void> d;
};
                                                                        /*}}}*/
// Package structure                                                    /*{{{*/
struct pkgCache::Package
{
   map_stringitem_t Arch;
   map_pointer<Version> VersionList;
   map_pointer<Version> CurrentVer;
   map_pointer<pkgCache::Group> Group;
 
   // Linked list
   map_pointer<Package> NextPackage;
   map_pointer<Dependency> RevDepends;
   map_pointer<Provides> ProvidesList;
 
   // Install/Remove/Purge etc
   map_number_t SelectedState;     // What
   map_number_t InstState;         // Flags
   map_number_t CurrentState;      // State
 
   map_id_t ID;
   map_flags_t Flags;
 
   map_pointer<void> d;
};
                                                                        /*}}}*/
// Release File structure                                               /*{{{*/
struct pkgCache::ReleaseFile
{
   map_stringitem_t FileName;
   map_stringitem_t Archive;
   map_stringitem_t Codename;
   map_stringitem_t Version;
   map_stringitem_t Origin;
   map_stringitem_t Label;
   map_stringitem_t Site;
 
   map_filesize_t Size;
   time_t mtime;
 
   map_flags_t Flags;
 
   // Linked list
   map_pointer<ReleaseFile> NextFile;
   map_fileid_t ID;
 
   map_pointer<void> d;
};
                                                                        /*}}}*/
// Package File structure                                               /*{{{*/
struct pkgCache::PackageFile
{
   map_stringitem_t FileName;
   map_pointer<ReleaseFile> Release;
 
   map_stringitem_t Component;
   map_stringitem_t Architecture;
 
   map_stringitem_t IndexType;
   map_filesize_t Size;
   time_t mtime;
 
   map_flags_t Flags;
 
   // Linked list
   map_pointer<PackageFile> NextFile;
   map_fileid_t ID;
 
   map_pointer<void> d;
};
                                                                        /*}}}*/
// VerFile structure                                                    /*{{{*/
struct pkgCache::VerFile
{
   map_pointer<PackageFile> File;
   map_pointer<VerFile> NextFile;
   map_filesize_t Offset;         // File offset
};
                                                                        /*}}}*/
// DescFile structure                                                   /*{{{*/
struct pkgCache::DescFile
{
   map_pointer<PackageFile> File;
   map_pointer<DescFile> NextFile;
   map_filesize_t Offset;         // File offset
};
                                                                        /*}}}*/
// SourceVersion structure                                              /*{{{*/
struct pkgCache::SourceVersion
{
   map_id_t ID;
   map_pointer<pkgCache::Group> Group;
   map_stringitem_t VerStr;
   map_pointer<Version> VersionList [[gnu::unavailable("not yet available")]];
   map_pointer<SourceVersion> NextSourceVersion [[gnu::unavailable("not yet available")]];
 
   map_pointer<void> d;
};
                                                                        /*}}}*/
// Version structure                                                    /*{{{*/
struct pkgCache::Version
{
   struct Extra;
 
   map_stringitem_t VerStr;
   map_stringitem_t Section;
 
   map_pointer<pkgCache::SourceVersion> SourceVersion;
   map_pointer<Version> NextInSourceVersion;
 
   enum VerMultiArch { No = 0, 
                       All = (1<<0), 
                       Foreign = (1<<1), 
                       Same = (1<<2), 
                       Allowed = (1<<3), 
                       AllForeign = All | Foreign,
                       AllAllowed = All | Allowed };
 
   map_number_t MultiArch;
 
   map_pointer<VerFile> FileList;
   map_pointer<Version> NextVer;
   map_pointer<Description> DescriptionList;
   map_pointer<Dependency> DependsList;
   map_pointer<Package> ParentPkg;
   map_pointer<Provides> ProvidesList;
 
   map_filesize_t Size; // These are the .deb size
   map_filesize_t InstalledSize;
   uint32_t Hash;
   map_id_t ID;
   map_number_t Priority;
   map_pointer<Version> NextInSource;
 
   map_pointer<Extra> d;
};
 
#ifdef APT_COMPILING_APT
struct pkgCache::Version::Extra
{
   uint8_t PhasedUpdatePercentage;
};
#endif
                                                                        /*}}}*/
// Description structure                                                /*{{{*/
struct pkgCache::Description
{
   map_stringitem_t language_code;
   map_stringitem_t md5sum;
 
   map_pointer<DescFile> FileList;
   map_pointer<Description> NextDesc;
   map_pointer<Package> ParentPkg;
 
   map_id_t ID;
};
                                                                        /*}}}*/
// Dependency structure                                                 /*{{{*/
struct pkgCache::DependencyData
{
   map_stringitem_t Version;
   map_pointer<pkgCache::Package> Package;
 
   map_number_t Type;
   map_flags_t CompareOp;
 
   map_pointer<DependencyData> NextData;
};
struct pkgCache::Dependency
{
   map_pointer<pkgCache::DependencyData> DependencyData;
   map_pointer<Version> ParentVer;
   map_pointer<Dependency> NextRevDepends;
   map_pointer<Dependency> NextDepends;
 
   map_id_t ID;
};
                                                                        /*}}}*/
// Provides structure                                                   /*{{{*/
struct pkgCache::Provides
{
   map_pointer<Package> ParentPkg;
   map_pointer<pkgCache::Version> Version;
   map_stringitem_t ProvideVersion;
   map_flags_t Flags;
   map_pointer<Provides> NextProvides;
   map_pointer<Provides> NextPkgProv;
};
                                                                        /*}}}*/
 
inline char const * pkgCache::NativeArch()
        { return StrP + HeaderP->Architecture; }
 
#include <apt-pkg/cacheiterators.h>
 
        inline pkgCache::GrpIterator pkgCache::GrpBegin()
        {
           return GrpIterator(*this);
        }
        inline pkgCache::GrpIterator pkgCache::GrpEnd()
        {
           return GrpIterator(*this, GrpP);}
inline pkgCache::PkgIterator pkgCache::PkgBegin()
       {return PkgIterator(*this);}
inline pkgCache::PkgIterator pkgCache::PkgEnd()
       {return PkgIterator(*this,PkgP);}
inline pkgCache::PkgFileIterator pkgCache::FileBegin()
       {return PkgFileIterator(*this,PkgFileP + HeaderP->FileList);}
inline pkgCache::PkgFileIterator pkgCache::FileEnd()
       {return PkgFileIterator(*this,PkgFileP);}
inline pkgCache::RlsFileIterator pkgCache::RlsFileBegin()
       {return RlsFileIterator(*this,RlsFileP + HeaderP->RlsFileList);}
inline pkgCache::RlsFileIterator pkgCache::RlsFileEnd()
       {return RlsFileIterator(*this,RlsFileP);}
 
 
// Oh I wish for Real Name Space Support
class pkgCache::Namespace                                               /*{{{*/
{
   public:
   typedef pkgCache::GrpIterator GrpIterator;
   typedef pkgCache::PkgIterator PkgIterator;
   typedef pkgCache::VerIterator VerIterator;
   typedef pkgCache::SrcVerIterator SrcVerIterator;
   typedef pkgCache::DescIterator DescIterator;
   typedef pkgCache::DepIterator DepIterator;
   typedef pkgCache::PrvIterator PrvIterator;
   typedef pkgCache::RlsFileIterator RlsFileIterator;
   typedef pkgCache::PkgFileIterator PkgFileIterator;
   typedef pkgCache::VerFileIterator VerFileIterator;
   typedef pkgCache::Version Version;
   typedef pkgCache::Description Description;
   typedef pkgCache::Package Package;
   typedef pkgCache::Header Header;
   typedef pkgCache::Dep Dep;
   typedef pkgCache::Flag Flag;
};
                                                                        /*}}}*/
#undef __PKGLIB_IN_PKGCACHE_H
#endif