apt-pkg/pkgcachegen.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    Package Cache Generator - Generator for the cache structure.
   6
   7    This builds the cache structure from the abstract package list parser.
   8    Each archive source has it's own list parser that is instantiated by
   9    the caller to provide data for the generator.
  10
  11    Parts of the cache are created by this generator class while other
  12    parts are created by the list parser. The list parser is responsible
  13    for creating version, depends and provides structures, and some of
  14    their contents
  15
  16    ##################################################################### */
  17                                                                         /*}}}*/
  18 #ifndef PKGLIB_PKGCACHEGEN_H
  19 #define PKGLIB_PKGCACHEGEN_H
  20
  21 #include <apt-pkg/md5.h>
  22 #include <apt-pkg/mmap.h>
  23 #include <apt-pkg/pkgcache.h>
  24 #include <apt-pkg/cacheiterators.h>
  25 #include <apt-pkg/macros.h>
  26
  27 #include <vector>
  28 #include <string>
  29 #if __cplusplus >= 201103L
  30 #include <unordered_set>
  31 #endif
  32 #ifdef APT_PKG_EXPOSE_STRING_VIEW
  33 #include <apt-pkg/string_view.h>
  34 #endif
  35
  36 class FileFd;
  37 class pkgSourceList;
  38 class OpProgress;
  39 class pkgIndexFile;
  40 class pkgCacheListParser;
  41
  42 class APT_HIDDEN pkgCacheGenerator                                      /*{{{*/
  43 {
  44 #ifdef APT_PKG_EXPOSE_STRING_VIEW
  45    APT_HIDDEN map_stringitem_t WriteStringInMap(APT::StringView String) { return WriteStringInMap(String.data(), String.size()); };
  46 #endif
  47    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String);
  48    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len);
  49    APT_HIDDEN map_pointer_t AllocateInMap(const unsigned long &size);
  50
  51    // Dirty hack for public users that do not use C++11 yet
  52 #if __cplusplus >= 201103L
  53    struct string_pointer {
  54       const char *data_;
  55       size_t size;
  56       pkgCacheGenerator *generator;
  57       map_stringitem_t item;
  58
  59       const char *data() const {
  60          return data_ != nullptr ? data_ : static_cast<char*>(generator->Map.Data()) + item;
  61       }
  62
  63       bool operator ==(string_pointer const &other) const {
  64          return size == other.size && memcmp(data(), other.data(), size) == 0;
  65       }
  66    };
  67    struct hash {
  68       uint32_t operator()(string_pointer const &that) const {
  69          uint32_t Hash = 5381;
  70          const char * const end = that.data() + that.size;
  71          for (const char *I = that.data(); I != end; ++I)
  72             Hash = 33 * Hash + *I;
  73          return Hash;
  74       }
  75    };
  76
  77    std::unordered_set<string_pointer, hash> strMixed;
  78    std::unordered_set<string_pointer, hash> strPkgNames;
  79    std::unordered_set<string_pointer, hash> strVersions;
  80    std::unordered_set<string_pointer, hash> strSections;
  81 #endif
  82
  83    friend class pkgCacheListParser;
  84    typedef pkgCacheListParser ListParser;
  85
  86    public:
  87
  88    template<typename Iter> class Dynamic {
  89       public:
  90       static std::vector<Iter*> toReMap;
  91       explicit Dynamic(Iter &I) {
  92          toReMap.push_back(&I);
  93       }
  94
  95       ~Dynamic() {
  96          toReMap.pop_back();
  97       }
  98
  99 #if __cplusplus >= 201103L
 100       Dynamic(const Dynamic&) = delete;
 101       void operator=(const Dynamic&) = delete;
 102 #endif
 103    };
 104
 105    protected:
 106
 107    DynamicMMap &Map;
 108    pkgCache Cache;
 109    OpProgress *Progress;
 110
 111    std::string RlsFileName;
 112    pkgCache::ReleaseFile *CurrentRlsFile;
 113    std::string PkgFileName;
 114    pkgCache::PackageFile *CurrentFile;
 115
 116 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 117    bool NewGroup(pkgCache::GrpIterator &Grp, APT::StringView Name);
 118    bool NewPackage(pkgCache::PkgIterator &Pkg, APT::StringView Name, APT::StringView Arch);
 119    map_pointer_t NewVersion(pkgCache::VerIterator &Ver, APT::StringView const &VerStr,
 120                             map_pointer_t const ParentPkg, unsigned short const Hash,
 121                             map_pointer_t const Next);
 122    map_pointer_t NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang, APT::StringView md5sum,map_stringitem_t const idxmd5str);
 123 #endif
 124    bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
 125    bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
 126    bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
 127                    map_pointer_t const Version, uint8_t const Op,
 128                    uint8_t const Type, map_pointer_t* &OldDepLast);
 129    bool NewProvides(pkgCache::VerIterator &Ver, pkgCache::PkgIterator &Pkg,
 130                     map_stringitem_t const ProvidesVersion, uint8_t const Flags);
 131
 132    public:
 133
 134    enum StringType { MIXED, PKGNAME, VERSIONNUMBER, SECTION };
 135    map_stringitem_t StoreString(StringType const type, const char * S, unsigned int const Size);
 136
 137 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 138    inline map_stringitem_t StoreString(enum StringType const type, APT::StringView S) {return StoreString(type, S.data(),S.length());};
 139 #endif
 140
 141    void DropProgress() {Progress = 0;};
 142    bool SelectFile(const std::string &File,pkgIndexFile const &Index, std::string const &Architecture, std::string const &Component, unsigned long Flags = 0);
 143    bool SelectReleaseFile(const std::string &File, const std::string &Site, unsigned long Flags = 0);
 144    bool MergeList(ListParser &List,pkgCache::VerIterator *Ver = 0);
 145    inline pkgCache &GetCache() {return Cache;};
 146    inline pkgCache::PkgFileIterator GetCurFile()
 147          {return pkgCache::PkgFileIterator(Cache,CurrentFile);};
 148    inline pkgCache::RlsFileIterator GetCurRlsFile()
 149          {return pkgCache::RlsFileIterator(Cache,CurrentRlsFile);};
 150
 151    APT_PUBLIC static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
 152                         MMap **OutMap = 0,bool AllowMem = false);
 153    APT_HIDDEN static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
 154                         MMap **OutMap,pkgCache **OutCache, bool AllowMem = false);
 155    APT_PUBLIC static bool MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap);
 156
 157    void ReMap(void const * const oldMap, void const * const newMap, size_t oldSize);
 158    bool Start();
 159
 160    pkgCacheGenerator(DynamicMMap *Map,OpProgress *Progress);
 161    virtual ~pkgCacheGenerator();
 162
 163    private:
 164    void * const d;
 165    APT_HIDDEN bool MergeListGroup(ListParser &List, std::string const &GrpName);
 166    APT_HIDDEN bool MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg);
 167 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 168    APT_HIDDEN bool MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg,
 169                          APT::StringView const &Version, pkgCache::VerIterator* &OutVer);
 170 #endif
 171
 172    APT_HIDDEN bool AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P,
 173                            pkgCache::VerIterator &V);
 174    APT_HIDDEN bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D);
 175
 176 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 177    APT_HIDDEN bool AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver,
 178          std::string const &lang, APT::StringView CurMd5, map_stringitem_t &md5idx);
 179 #endif
 180 };
 181                                                                         /*}}}*/
 182 // This is the abstract package list parser class.                      /*{{{*/
 183 class APT_HIDDEN pkgCacheListParser
 184 {
 185    pkgCacheGenerator *Owner;
 186    friend class pkgCacheGenerator;
 187
 188    // Some cache items
 189    pkgCache::VerIterator OldDepVer;
 190    map_pointer_t *OldDepLast;
 191
 192    void * const d;
 193
 194    protected:
 195
 196    inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, const char *S,unsigned int Size) {return Owner->StoreString(type, S, Size);};
 197 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 198    inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, APT::StringView S) {return Owner->StoreString(type, S);};
 199    inline map_stringitem_t WriteString(APT::StringView S) {return Owner->WriteStringInMap(S.data(), S.size());};
 200 #endif
 201
 202    inline map_stringitem_t WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
 203 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 204    bool NewDepends(pkgCache::VerIterator &Ver,APT::StringView Package, APT::StringView Arch,
 205                    APT::StringView Version,uint8_t const Op,
 206                    uint8_t const Type);
 207    bool NewProvides(pkgCache::VerIterator &Ver,APT::StringView PkgName,
 208                     APT::StringView PkgArch, APT::StringView Version,
 209                     uint8_t const Flags);
 210    bool NewProvidesAllArch(pkgCache::VerIterator &Ver, APT::StringView Package,
 211                            APT::StringView Version, uint8_t const Flags);
 212 #endif
 213    public:
 214
 215    // These all operate against the current section
 216    virtual std::string Package() = 0;
 217    virtual bool ArchitectureAll() = 0;
 218 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 219    virtual APT::StringView Architecture() = 0;
 220    virtual APT::StringView Version() = 0;
 221 #endif
 222    virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0;
 223    virtual std::vector<std::string> AvailableDescriptionLanguages() = 0;
 224 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 225    virtual APT::StringView Description_md5() = 0;
 226 #endif
 227    virtual unsigned short VersionHash() = 0;
 228    /** compare currently parsed version with given version
 229     *
 230     * \param Hash of the currently parsed version
 231     * \param Ver to compare with
 232     */
 233    virtual bool SameVersion(unsigned short const Hash, pkgCache::VerIterator const &Ver);
 234    virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
 235                            pkgCache::VerIterator &Ver) = 0;
 236    virtual map_filesize_t Offset() = 0;
 237    virtual map_filesize_t Size() = 0;
 238
 239    virtual bool Step() = 0;
 240
 241    virtual bool CollectFileProvides(pkgCache &/*Cache*/,
 242                                     pkgCache::VerIterator &/*Ver*/) {return true;};
 243
 244    pkgCacheListParser();
 245    virtual ~pkgCacheListParser();
 246 };
 247                                                                         /*}}}*/
 248
 249 APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeStatusCache instead") bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
 250                         MMap **OutMap = 0,bool AllowMem = false);
 251 APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeOnlyStatusCache instead") bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap);
 252
 253 #endif