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    APT_HIDDEN map_stringitem_t WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
  45    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String);
  46    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len);
  47    APT_HIDDEN map_pointer_t AllocateInMap(const unsigned long &size);
  48
  49    // Dirty hack for public users that do not use C++11 yet
  50 #if __cplusplus >= 201103L
  51    struct string_pointer {
  52       const char *data_;
  53       size_t size;
  54       pkgCacheGenerator *generator;
  55       map_stringitem_t item;
  56
  57       const char *data() const {
  58          return data_ != nullptr ? data_ : static_cast<char*>(generator->Map.Data()) + item;
  59       }
  60
  61       bool operator ==(string_pointer const &other) const {
  62          return size == other.size && memcmp(data(), other.data(), size) == 0;
  63       }
  64    };
  65    struct hash {
  66       uint32_t operator()(string_pointer const &that) const {
  67          uint32_t Hash = 5381;
  68          const char * const end = that.data() + that.size;
  69          for (const char *I = that.data(); I != end; ++I)
  70             Hash = 33 * Hash + *I;
  71          return Hash;
  72       }
  73    };
  74
  75    std::unordered_set<string_pointer, hash> strMixed;
  76    std::unordered_set<string_pointer, hash> strPkgNames;
  77    std::unordered_set<string_pointer, hash> strVersions;
  78    std::unordered_set<string_pointer, hash> strSections;
  79 #endif
  80
  81    friend class pkgCacheListParser;
  82    typedef pkgCacheListParser ListParser;
  83
  84    public:
  85
  86    template<typename Iter> class Dynamic {
  87       public:
  88       static std::vector<Iter*> toReMap;
  89       explicit Dynamic(Iter &I) {
  90          toReMap.push_back(&I);
  91       }
  92
  93       ~Dynamic() {
  94          toReMap.pop_back();
  95       }
  96
  97 #if __cplusplus >= 201103L
  98       Dynamic(const Dynamic&) = delete;
  99       void operator=(const Dynamic&) = delete;
 100 #endif
 101    };
 102
 103    protected:
 104
 105    DynamicMMap &Map;
 106    pkgCache Cache;
 107    OpProgress *Progress;
 108
 109    std::string RlsFileName;
 110    pkgCache::ReleaseFile *CurrentRlsFile;
 111    std::string PkgFileName;
 112    pkgCache::PackageFile *CurrentFile;
 113
 114 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 115    bool NewGroup(pkgCache::GrpIterator &Grp, APT::StringView Name);
 116    bool NewPackage(pkgCache::PkgIterator &Pkg, APT::StringView Name, APT::StringView Arch);
 117 #endif
 118    bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
 119    bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
 120    bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
 121                    map_pointer_t const Version, uint8_t const Op,
 122                    uint8_t const Type, map_pointer_t* &OldDepLast);
 123    map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,map_pointer_t const Next) APT_DEPRECATED
 124    { return NewVersion(Ver, VerStr, 0, 0, Next); }
 125    map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,
 126                             map_pointer_t const ParentPkg, unsigned short const Hash,
 127                             map_pointer_t const Next);
 128    map_pointer_t NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_stringitem_t const idxmd5str);
 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
 159    pkgCacheGenerator(DynamicMMap *Map,OpProgress *Progress);
 160    virtual ~pkgCacheGenerator();
 161
 162    private:
 163    void * const d;
 164    APT_HIDDEN bool MergeListGroup(ListParser &List, std::string const &GrpName);
 165    APT_HIDDEN bool MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg);
 166    APT_HIDDEN bool MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg,
 167                          std::string const &Version, pkgCache::VerIterator* &OutVer);
 168
 169    APT_HIDDEN bool AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P,
 170                            pkgCache::VerIterator &V);
 171    APT_HIDDEN bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D);
 172
 173    APT_HIDDEN bool AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver,
 174          std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx);
 175 };
 176                                                                         /*}}}*/
 177 // This is the abstract package list parser class.                      /*{{{*/
 178 class APT_HIDDEN pkgCacheListParser
 179 {
 180    pkgCacheGenerator *Owner;
 181    friend class pkgCacheGenerator;
 182
 183    // Some cache items
 184    pkgCache::VerIterator OldDepVer;
 185    map_pointer_t *OldDepLast;
 186
 187    void * const d;
 188
 189    protected:
 190
 191    inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, const char *S,unsigned int Size) {return Owner->StoreString(type, S, Size);};
 192 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 193    inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, APT::StringView S) {return Owner->StoreString(type, S);};
 194 #endif
 195
 196    inline map_stringitem_t WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
 197    inline map_stringitem_t WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
 198 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 199    bool NewDepends(pkgCache::VerIterator &Ver,APT::StringView Package, APT::StringView Arch,
 200                    APT::StringView Version,uint8_t const Op,
 201                    uint8_t const Type);
 202    bool NewProvides(pkgCache::VerIterator &Ver,APT::StringView PkgName,
 203                     APT::StringView PkgArch, APT::StringView Version,
 204                     uint8_t const Flags);
 205    bool NewProvidesAllArch(pkgCache::VerIterator &Ver, APT::StringView Package,
 206                            APT::StringView Version, uint8_t const Flags);
 207 #endif
 208    public:
 209
 210    // These all operate against the current section
 211    virtual std::string Package() = 0;
 212    virtual std::string Architecture() = 0;
 213    virtual bool ArchitectureAll() = 0;
 214    virtual std::string Version() = 0;
 215    virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0;
 216    virtual std::vector<std::string> AvailableDescriptionLanguages() = 0;
 217    virtual MD5SumValue Description_md5() = 0;
 218    virtual unsigned short VersionHash() = 0;
 219    /** compare currently parsed version with given version
 220     *
 221     * \param Hash of the currently parsed version
 222     * \param Ver to compare with
 223     */
 224    virtual bool SameVersion(unsigned short const Hash, pkgCache::VerIterator const &Ver);
 225    virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
 226                            pkgCache::VerIterator &Ver) = 0;
 227    virtual map_filesize_t Offset() = 0;
 228    virtual map_filesize_t Size() = 0;
 229
 230    virtual bool Step() = 0;
 231
 232    virtual bool CollectFileProvides(pkgCache &/*Cache*/,
 233                                     pkgCache::VerIterator &/*Ver*/) {return true;};
 234
 235    pkgCacheListParser();
 236    virtual ~pkgCacheListParser();
 237 };
 238                                                                         /*}}}*/
 239
 240 APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeStatusCache instead") bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
 241                         MMap **OutMap = 0,bool AllowMem = false);
 242 APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeOnlyStatusCache instead") bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap);
 243
 244 #endif