apt-pkg/cachefile.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: cachefile.cc,v 1.8 2002/04/27 04:28:04 jgg Exp $
   4 /* ######################################################################
   5
   6    CacheFile - Simple wrapper class for opening, generating and whatnot
   7
   8    This class implements a simple 2 line mechanism to open various sorts
   9    of caches. It can operate as root, as not root, show progress and so on,
  10    it transparently handles everything necessary.
  11
  12    ##################################################################### */
  13                                                                         /*}}}*/
  14 // Include Files                                                        /*{{{*/
  15 #include <config.h>
  16
  17 #include <apt-pkg/cachefile.h>
  18 #include <apt-pkg/error.h>
  19 #include <apt-pkg/sourcelist.h>
  20 #include <apt-pkg/pkgcachegen.h>
  21 #include <apt-pkg/configuration.h>
  22 #include <apt-pkg/policy.h>
  23 #include <apt-pkg/pkgsystem.h>
  24 #include <apt-pkg/fileutl.h>
  25 #include <apt-pkg/progress.h>
  26 #include <apt-pkg/depcache.h>
  27 #include <apt-pkg/mmap.h>
  28 #include <apt-pkg/pkgcache.h>
  29 #include <apt-pkg/indexfile.h>
  30
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <string>
  34 #include <vector>
  35 #include <memory>
  36
  37 #include <apti18n.h>
  38                                                                         /*}}}*/
  39 // CacheFile::CacheFile - Constructor                                   /*{{{*/
  40 pkgCacheFile::pkgCacheFile() : d(NULL), ExternOwner(false), Map(NULL), Cache(NULL),
  41                                 DCache(NULL), SrcList(NULL), Policy(NULL)
  42 {
  43 }
  44 pkgCacheFile::pkgCacheFile(pkgDepCache * const Owner) : d(NULL), ExternOwner(true),
  45    Map(&Owner->GetCache().GetMap()), Cache(&Owner->GetCache()),
  46    DCache(Owner), SrcList(NULL), Policy(NULL)
  47 {
  48 }
  49                                                                         /*}}}*/
  50 // CacheFile::~CacheFile - Destructor                                   /*{{{*/
  51 // ---------------------------------------------------------------------
  52 /* */
  53 pkgCacheFile::~pkgCacheFile()
  54 {
  55    if (ExternOwner == false)
  56    {
  57       delete DCache;
  58       delete Cache;
  59       delete Map;
  60    }
  61    delete Policy;
  62    delete SrcList;
  63    if (ExternOwner == false)
  64       _system->UnLock(true);
  65 }
  66                                                                         /*}}}*/
  67 // CacheFile::BuildCaches - Open and build the cache files              /*{{{*/
  68 class APT_HIDDEN ScopedErrorMerge {
  69 public:
  70    ScopedErrorMerge() { _error->PushToStack(); }
  71    ~ScopedErrorMerge() { _error->MergeWithStack(); }
  72 };
  73
  74 bool pkgCacheFile::BuildCaches(OpProgress *Progress, bool WithLock)
  75 {
  76    std::unique_ptr<pkgCache> Cache;
  77    std::unique_ptr<MMap> Map;
  78
  79    if (this->Cache != NULL)
  80       return true;
  81
  82    ScopedErrorMerge sem;
  83    if (_config->FindB("pkgCacheFile::Generate", true) == false)
  84    {
  85       FileFd file(_config->FindFile("Dir::Cache::pkgcache"), FileFd::ReadOnly);
  86       if (file.IsOpen() == false || file.Failed())
  87          return false;
  88       Map.reset(new MMap(file, MMap::Public|MMap::ReadOnly));
  89       if (unlikely(Map->validData() == false))
  90          return false;
  91       Cache.reset(new pkgCache(Map.get()));
  92       if (_error->PendingError() == true)
  93          return false;
  94
  95       this->Cache = Cache.release();
  96       this->Map = Map.release();
  97       return true;
  98    }
  99
 100    if (WithLock == true)
 101       if (_system->Lock() == false)
 102          return false;
 103
 104    if (_error->PendingError() == true)
 105       return false;
 106
 107    if (BuildSourceList(Progress) == false)
 108       return false;
 109
 110    // Read the caches
 111    MMap *TmpMap = nullptr;
 112    pkgCache *TmpCache = nullptr;
 113    bool Res = pkgCacheGenerator::MakeStatusCache(*SrcList,Progress,&TmpMap, &TmpCache, true);
 114    Map.reset(TmpMap);
 115    Cache.reset(TmpCache);
 116    if (Progress != NULL)
 117       Progress->Done();
 118    if (Res == false)
 119       return _error->Error(_("The package lists or status file could not be parsed or opened."));
 120
 121    /* This sux, remove it someday */
 122    if (_error->PendingError() == true)
 123       _error->Warning(_("You may want to run apt-get update to correct these problems"));
 124
 125    if (Cache == nullptr)
 126       Cache.reset(new pkgCache(Map.get()));
 127    if (_error->PendingError() == true)
 128       return false;
 129    this->Map = Map.release();
 130    this->Cache = Cache.release();
 131
 132    return true;
 133 }
 134                                                                         /*}}}*/
 135 // CacheFile::BuildSourceList - Open and build all relevant sources.list/*{{{*/
 136 // ---------------------------------------------------------------------
 137 /* */
 138 bool pkgCacheFile::BuildSourceList(OpProgress * /*Progress*/)
 139 {
 140    std::unique_ptr<pkgSourceList> SrcList;
 141    if (this->SrcList != NULL)
 142       return true;
 143
 144    SrcList.reset(new pkgSourceList());
 145    if (SrcList->ReadMainList() == false)
 146       return _error->Error(_("The list of sources could not be read."));
 147    this->SrcList = SrcList.release();
 148    return true;
 149 }
 150                                                                         /*}}}*/
 151 // CacheFile::BuildPolicy - Open and build all relevant preferences     /*{{{*/
 152 // ---------------------------------------------------------------------
 153 /* */
 154 bool pkgCacheFile::BuildPolicy(OpProgress * /*Progress*/)
 155 {
 156    std::unique_ptr<pkgPolicy> Policy;
 157    if (this->Policy != NULL)
 158       return true;
 159
 160    Policy.reset(new pkgPolicy(Cache));
 161    if (_error->PendingError() == true)
 162       return false;
 163
 164    if (ReadPinFile(*Policy) == false || ReadPinDir(*Policy) == false)
 165       return false;
 166
 167    this->Policy = Policy.release();
 168    return true;
 169 }
 170                                                                         /*}}}*/
 171 // CacheFile::BuildDepCache - Open and build the dependency cache       /*{{{*/
 172 // ---------------------------------------------------------------------
 173 /* */
 174 bool pkgCacheFile::BuildDepCache(OpProgress *Progress)
 175 {
 176    if (BuildCaches(Progress, false) == false)
 177       return false;
 178
 179    std::unique_ptr<pkgDepCache> DCache;
 180    if (this->DCache != NULL)
 181       return true;
 182
 183    if (BuildPolicy(Progress) == false)
 184       return false;
 185
 186    DCache.reset(new pkgDepCache(Cache,Policy));
 187    if (_error->PendingError() == true)
 188       return false;
 189    if (DCache->Init(Progress) == false)
 190       return false;
 191
 192    this->DCache = DCache.release();
 193    return true;
 194 }
 195                                                                         /*}}}*/
 196 // CacheFile::Open - Open the cache files, creating if necessary        /*{{{*/
 197 // ---------------------------------------------------------------------
 198 /* */
 199 bool pkgCacheFile::Open(OpProgress *Progress, bool WithLock)
 200 {
 201    if (BuildCaches(Progress,WithLock) == false)
 202       return false;
 203
 204    if (BuildPolicy(Progress) == false)
 205       return false;
 206
 207    if (BuildDepCache(Progress) == false)
 208       return false;
 209
 210    if (Progress != NULL)
 211       Progress->Done();
 212    if (_error->PendingError() == true)
 213       return false;
 214
 215    return true;
 216 }
 217                                                                         /*}}}*/
 218 bool pkgCacheFile::AddIndexFile(pkgIndexFile * const File)              /*{{{*/
 219 {
 220    if (SrcList == NULL)
 221       if (BuildSourceList() == false)
 222          return false;
 223    SrcList->AddVolatileFile(File);
 224
 225    if (Cache == nullptr || File->HasPackages() == false || File->Exists() == false)
 226       return true;
 227
 228    if (File->FindInCache(*Cache).end() == false)
 229       return _error->Warning("Duplicate sources.list entry %s",
 230             File->Describe().c_str());
 231
 232    if (ExternOwner == false)
 233    {
 234       delete DCache;
 235       delete Cache;
 236    }
 237    delete Policy;
 238    DCache = NULL;
 239    Policy = NULL;
 240    Cache = NULL;
 241
 242    if (ExternOwner == false)
 243    {
 244       // a dynamic mmap means that we have build at least parts of the cache
 245       // in memory – which we might or might not have written to disk.
 246       // Throwing away would therefore be a very costly operation we want to avoid
 247       DynamicMMap * dynmmap = dynamic_cast<DynamicMMap*>(Map);
 248       if (dynmmap != nullptr)
 249       {
 250          {
 251             pkgCacheGenerator Gen(dynmmap, nullptr);
 252             if (Gen.Start() == false || File->Merge(Gen, nullptr) == false)
 253                return false;
 254          }
 255          Cache = new pkgCache(Map);
 256          if (_error->PendingError() == true) {
 257             delete Cache;
 258             Cache = nullptr;
 259             return false;
 260          }
 261          return true;
 262       }
 263       else
 264       {
 265          delete Map;
 266          Map = NULL;
 267       }
 268    }
 269    else
 270    {
 271       ExternOwner = false;
 272       Map = NULL;
 273    }
 274    _system->UnLock(true);
 275    return true;
 276 }
 277                                                                         /*}}}*/
 278 // CacheFile::RemoveCaches - remove all cache files from disk           /*{{{*/
 279 // ---------------------------------------------------------------------
 280 /* */
 281 void pkgCacheFile::RemoveCaches()
 282 {
 283    std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
 284    std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
 285
 286    if (pkgcache.empty() == false && RealFileExists(pkgcache) == true)
 287       RemoveFile("RemoveCaches", pkgcache);
 288    if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
 289       RemoveFile("RemoveCaches", srcpkgcache);
 290    if (pkgcache.empty() == false)
 291    {
 292       std::string cachedir = flNotFile(pkgcache);
 293       std::string cachefile = flNotDir(pkgcache);
 294       if (cachedir.empty() != true && cachefile.empty() != true && DirectoryExists(cachedir) == true)
 295       {
 296          cachefile.append(".");
 297          std::vector<std::string> caches = GetListOfFilesInDir(cachedir, false);
 298          for (std::vector<std::string>::const_iterator file = caches.begin(); file != caches.end(); ++file)
 299          {
 300             std::string nuke = flNotDir(*file);
 301             if (strncmp(cachefile.c_str(), nuke.c_str(), cachefile.length()) != 0)
 302                continue;
 303             RemoveFile("RemoveCaches", *file);
 304          }
 305       }
 306    }
 307
 308    if (srcpkgcache.empty() == true)
 309       return;
 310
 311    std::string cachedir = flNotFile(srcpkgcache);
 312    std::string cachefile = flNotDir(srcpkgcache);
 313    if (cachedir.empty() == true || cachefile.empty() == true || DirectoryExists(cachedir) == false)
 314       return;
 315    cachefile.append(".");
 316    std::vector<std::string> caches = GetListOfFilesInDir(cachedir, false);
 317    for (std::vector<std::string>::const_iterator file = caches.begin(); file != caches.end(); ++file)
 318    {
 319       std::string nuke = flNotDir(*file);
 320       if (strncmp(cachefile.c_str(), nuke.c_str(), cachefile.length()) != 0)
 321          continue;
 322       RemoveFile("RemoveCaches", *file);
 323    }
 324 }
 325                                                                         /*}}}*/
 326 // CacheFile::Close - close the cache files                             /*{{{*/
 327 // ---------------------------------------------------------------------
 328 /* */
 329 void pkgCacheFile::Close()
 330 {
 331    if (ExternOwner == false)
 332    {
 333       delete DCache;
 334       delete Cache;
 335       delete Map;
 336    }
 337    else
 338       ExternOwner = false;
 339    delete Policy;
 340    delete SrcList;
 341    _system->UnLock(true);
 342
 343    Map = NULL;
 344    DCache = NULL;
 345    Policy = NULL;
 346    Cache = NULL;
 347    SrcList = NULL;
 348 }
 349                                                                         /*}}}*/