1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
|
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgcache.h,v 1.25 2001/07/01 22:28:24 jgg Exp $
/* ######################################################################
Cache - Structure definitions for the cache file
Please see doc/apt-pkg/cache.sgml for a more detailed description of
this format. Also be sure to keep that file up-to-date!!
Clients should always use the CacheIterators classes for access to the
cache. They provide a simple STL-like method for traversing the links
of the datastructure.
See pkgcachegen.h for information about generating cache structures.
##################################################################### */
/*}}}*/
#ifndef PKGLIB_PKGCACHE_H
#define PKGLIB_PKGCACHE_H
#ifdef __GNUG__
#pragma interface "apt-pkg/pkgcache.h"
#endif
#include <string>
#include <time.h>
#include <apt-pkg/mmap.h>
using std::string;
class pkgVersioningSystem;
class pkgCache
{
public:
// Cache element predeclarations
struct Header;
struct Package;
struct PackageFile;
struct Version;
struct Provides;
struct Dependency;
struct StringItem;
struct VerFile;
// Iterators
class PkgIterator;
class VerIterator;
class DepIterator;
class PrvIterator;
class PkgFileIterator;
class VerFileIterator;
friend class PkgIterator;
friend class VerIterator;
friend class DepIterator;
friend class PrvIterator;
friend class PkgFileIterator;
friend class VerFileIterator;
class Namespace;
// These are all the constants used in the cache structures
struct Dep
{
enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
Conflicts=5,Replaces=6,Obsoletes=7};
enum DepCompareOp {Or=0x10,NoOp=0,LessEq=0x1,GreaterEq=0x2,Less=0x3,
Greater=0x4,Equals=0x5,NotEquals=0x6};
};
struct State
{
enum VerPriority {Important=1,Required=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};
};
struct Flag
{
enum PkgFlags {Auto=(1<<0),Essential=(1<<3),Important=(1<<4)};
enum PkgFFlags {NotSource=(1<<0),NotAutomatic=(1<<1)};
};
protected:
// Memory mapped cache file
string CacheFile;
MMap ⤅
unsigned long sHash(const string &S) const;
unsigned long sHash(const char *S) const;
public:
// Pointers to the arrays of items
Header *HeaderP;
Package *PkgP;
VerFile *VerFileP;
PackageFile *PkgFileP;
Version *VerP;
Provides *ProvideP;
Dependency *DepP;
StringItem *StringItemP;
char *StrP;
virtual bool ReMap();
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 unsigned long Hash(const string &S) const {return sHash(S);};
inline unsigned long Hash(const char *S) const {return sHash(S);};
// Usefull transformation things
const char *Priority(unsigned char Priority);
// Accessors
PkgIterator FindPkg(const string &Name);
Header &Head() {return *HeaderP;};
inline PkgIterator PkgBegin();
inline PkgIterator PkgEnd();
inline PkgFileIterator FileBegin();
inline PkgFileIterator FileEnd();
// Make me a function
pkgVersioningSystem *VS;
// Converters
static const char *CompTypeDeb(unsigned char Comp);
static const char *CompType(unsigned char Comp);
static const char *DepType(unsigned char Dep);
pkgCache(MMap *Map,bool DoMap = true);
virtual ~pkgCache() {};
};
// Header structure
struct pkgCache::Header
{
// Signature information
unsigned long Signature;
short MajorVersion;
short MinorVersion;
bool Dirty;
// Size of structure values
unsigned short HeaderSz;
unsigned short PackageSz;
unsigned short PackageFileSz;
unsigned short VersionSz;
unsigned short DependencySz;
unsigned short ProvidesSz;
unsigned short VerFileSz;
// Structure counts
unsigned long PackageCount;
unsigned long VersionCount;
unsigned long DependsCount;
unsigned long PackageFileCount;
unsigned long VerFileCount;
unsigned long ProvidesCount;
// Offsets
map_ptrloc FileList; // struct PackageFile
map_ptrloc StringList; // struct StringItem
map_ptrloc VerSysName; // StringTable
map_ptrloc Architecture; // StringTable
unsigned long MaxVerFileSize;
/* Allocation pools, there should be one of these for each structure
excluding the header */
DynamicMMap::Pool Pools[7];
// Rapid package name lookup
map_ptrloc HashTable[2*1048];
bool CheckSizes(Header &Against) const;
Header();
};
struct pkgCache::Package
{
// Pointers
map_ptrloc Name; // Stringtable
map_ptrloc VersionList; // Version
map_ptrloc CurrentVer; // Version
map_ptrloc Section; // StringTable (StringItem)
// Linked list
map_ptrloc NextPackage; // Package
map_ptrloc RevDepends; // Dependency
map_ptrloc ProvidesList; // Provides
// Install/Remove/Purge etc
unsigned char SelectedState; // What
unsigned char InstState; // Flags
unsigned char CurrentState; // State
unsigned short ID;
unsigned long Flags;
};
struct pkgCache::PackageFile
{
// Names
map_ptrloc FileName; // Stringtable
map_ptrloc Archive; // Stringtable
map_ptrloc Component; // Stringtable
map_ptrloc Version; // Stringtable
map_ptrloc Origin; // Stringtable
map_ptrloc Label; // Stringtable
map_ptrloc Architecture; // Stringtable
map_ptrloc Site; // Stringtable
map_ptrloc IndexType; // Stringtable
unsigned long Size;
unsigned long Flags;
// Linked list
map_ptrloc NextFile; // PackageFile
unsigned short ID;
time_t mtime; // Modification time for the file
};
struct pkgCache::VerFile
{
map_ptrloc File; // PackageFile
map_ptrloc NextFile; // PkgVerFile
map_ptrloc Offset; // File offset
unsigned short Size;
};
struct pkgCache::Version
{
map_ptrloc VerStr; // Stringtable
map_ptrloc Section; // StringTable (StringItem)
map_ptrloc Arch; // StringTable
// Lists
map_ptrloc FileList; // VerFile
map_ptrloc NextVer; // Version
map_ptrloc DependsList; // Dependency
map_ptrloc ParentPkg; // Package
map_ptrloc ProvidesList; // Provides
map_ptrloc Size; // These are the .deb size
map_ptrloc InstalledSize;
unsigned short Hash;
unsigned short ID;
unsigned char Priority;
};
struct pkgCache::Dependency
{
map_ptrloc Version; // Stringtable
map_ptrloc Package; // Package
map_ptrloc NextDepends; // Dependency
map_ptrloc NextRevDepends; // Dependency
map_ptrloc ParentVer; // Version
// Specific types of depends
map_ptrloc ID;
unsigned char Type;
unsigned char CompareOp;
};
struct pkgCache::Provides
{
map_ptrloc ParentPkg; // Pacakge
map_ptrloc Version; // Version
map_ptrloc ProvideVersion; // Stringtable
map_ptrloc NextProvides; // Provides
map_ptrloc NextPkgProv; // Provides
};
struct pkgCache::StringItem
{
map_ptrloc String; // Stringtable
map_ptrloc NextItem; // StringItem
};
#include <apt-pkg/cacheiterators.h>
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);};
// Oh I wish for Real Name Space Support
class pkgCache::Namespace
{
public:
typedef pkgCache::PkgIterator PkgIterator;
typedef pkgCache::VerIterator VerIterator;
typedef pkgCache::DepIterator DepIterator;
typedef pkgCache::PrvIterator PrvIterator;
typedef pkgCache::PkgFileIterator PkgFileIterator;
typedef pkgCache::VerFileIterator VerFileIterator;
typedef pkgCache::Version Version;
typedef pkgCache::Package Package;
typedef pkgCache::Header Header;
typedef pkgCache::Dep Dep;
typedef pkgCache::Flag Flag;
};
#endif
|