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
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <string>
  33 #include <vector>
  34
  35 #include <apti18n.h>
  36                                                                         /*}}}*/
  37 // CacheFile::CacheFile - Constructor                                   /*{{{*/
  38 // ---------------------------------------------------------------------
  39 /* */
  40 pkgCacheFile::pkgCacheFile() : d(NULL), Map(NULL), Cache(NULL), DCache(NULL),
  41                                 SrcList(NULL), Policy(NULL)
  42 {
  43 }
  44                                                                         /*}}}*/
  45 // CacheFile::~CacheFile - Destructor                                   /*{{{*/
  46 // ---------------------------------------------------------------------
  47 /* */
  48 pkgCacheFile::~pkgCacheFile()
  49 {
  50    delete DCache;
  51    delete Policy;
  52    delete SrcList;
  53    delete Cache;
  54    delete Map;
  55    _system->UnLock(true);
  56 }
  57                                                                         /*}}}*/
  58 // CacheFile::BuildCaches - Open and build the cache files              /*{{{*/
  59 // ---------------------------------------------------------------------
  60 /* */
  61 bool pkgCacheFile::BuildCaches(OpProgress *Progress, bool WithLock)
  62 {
  63    if (Cache != NULL)
  64       return true;
  65
  66    if (_config->FindB("pkgCacheFile::Generate", true) == false)
  67    {
  68       Map = new MMap(*new FileFd(_config->FindFile("Dir::Cache::pkgcache"),
  69                      FileFd::ReadOnly),MMap::Public|MMap::ReadOnly);
  70       Cache = new pkgCache(Map);
  71       if (_error->PendingError() == true)
  72          return false;
  73       return true;
  74    }
  75
  76    const bool ErrorWasEmpty = _error->empty();
  77    if (WithLock == true)
  78       if (_system->Lock() == false)
  79          return false;
  80
  81    if (_config->FindB("Debug::NoLocking",false) == true)
  82       WithLock = false;
  83
  84    if (_error->PendingError() == true)
  85       return false;
  86
  87    BuildSourceList(Progress);
  88
  89    // Read the caches
  90    bool Res = pkgCacheGenerator::MakeStatusCache(*SrcList,Progress,&Map,!WithLock);
  91    if (Progress != NULL)
  92       Progress->Done();
  93    if (Res == false)
  94       return _error->Error(_("The package lists or status file could not be parsed or opened."));
  95
  96    /* This sux, remove it someday */
  97    if (ErrorWasEmpty == true && _error->empty() == false)
  98       _error->Warning(_("You may want to run apt-get update to correct these problems"));
  99
 100    Cache = new pkgCache(Map);
 101    if (_error->PendingError() == true)
 102       return false;
 103    return true;
 104 }
 105                                                                         /*}}}*/
 106 // CacheFile::BuildSourceList - Open and build all relevant sources.list/*{{{*/
 107 // ---------------------------------------------------------------------
 108 /* */
 109 bool pkgCacheFile::BuildSourceList(OpProgress * /*Progress*/)
 110 {
 111    if (SrcList != NULL)
 112       return true;
 113
 114    SrcList = new pkgSourceList();
 115    if (SrcList->ReadMainList() == false)
 116       return _error->Error(_("The list of sources could not be read."));
 117    return true;
 118 }
 119                                                                         /*}}}*/
 120 // CacheFile::BuildPolicy - Open and build all relevant preferences     /*{{{*/
 121 // ---------------------------------------------------------------------
 122 /* */
 123 bool pkgCacheFile::BuildPolicy(OpProgress * /*Progress*/)
 124 {
 125    if (Policy != NULL)
 126       return true;
 127
 128    Policy = new pkgPolicy(Cache);
 129    if (_error->PendingError() == true)
 130       return false;
 131
 132    if (ReadPinFile(*Policy) == false || ReadPinDir(*Policy) == false)
 133       return false;
 134
 135    return true;
 136 }
 137                                                                         /*}}}*/
 138 // CacheFile::BuildDepCache - Open and build the dependency cache       /*{{{*/
 139 // ---------------------------------------------------------------------
 140 /* */
 141 bool pkgCacheFile::BuildDepCache(OpProgress *Progress)
 142 {
 143    if (DCache != NULL)
 144       return true;
 145
 146    if (BuildPolicy(Progress) == false)
 147       return false;
 148
 149    DCache = new pkgDepCache(Cache,Policy);
 150    if (_error->PendingError() == true)
 151       return false;
 152
 153    DCache->Init(Progress);
 154    return true;
 155 }
 156                                                                         /*}}}*/
 157 // CacheFile::Open - Open the cache files, creating if necessary        /*{{{*/
 158 // ---------------------------------------------------------------------
 159 /* */
 160 bool pkgCacheFile::Open(OpProgress *Progress, bool WithLock)
 161 {
 162    if (BuildCaches(Progress,WithLock) == false)
 163       return false;
 164
 165    if (BuildPolicy(Progress) == false)
 166       return false;
 167
 168    if (BuildDepCache(Progress) == false)
 169       return false;
 170
 171    if (Progress != NULL)
 172       Progress->Done();
 173    if (_error->PendingError() == true)
 174       return false;
 175
 176    return true;
 177 }
 178                                                                         /*}}}*/
 179 // CacheFile::RemoveCaches - remove all cache files from disk           /*{{{*/
 180 // ---------------------------------------------------------------------
 181 /* */
 182 void pkgCacheFile::RemoveCaches()
 183 {
 184    std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
 185    std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
 186
 187    if (pkgcache.empty() == false && RealFileExists(pkgcache) == true)
 188       unlink(pkgcache.c_str());
 189    if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
 190       unlink(srcpkgcache.c_str());
 191    if (pkgcache.empty() == false)
 192    {
 193       std::string cachedir = flNotFile(pkgcache);
 194       std::string cachefile = flNotDir(pkgcache);
 195       if (cachedir.empty() != true && cachefile.empty() != true && DirectoryExists(cachedir) == true)
 196       {
 197          cachefile.append(".");
 198          std::vector<std::string> caches = GetListOfFilesInDir(cachedir, false);
 199          for (std::vector<std::string>::const_iterator file = caches.begin(); file != caches.end(); ++file)
 200          {
 201             std::string nuke = flNotDir(*file);
 202             if (strncmp(cachefile.c_str(), nuke.c_str(), cachefile.length()) != 0)
 203                continue;
 204             unlink(file->c_str());
 205          }
 206       }
 207    }
 208
 209    if (srcpkgcache.empty() == true)
 210       return;
 211
 212    std::string cachedir = flNotFile(srcpkgcache);
 213    std::string cachefile = flNotDir(srcpkgcache);
 214    if (cachedir.empty() == true || cachefile.empty() == true || DirectoryExists(cachedir) == false)
 215       return;
 216    cachefile.append(".");
 217    std::vector<std::string> caches = GetListOfFilesInDir(cachedir, false);
 218    for (std::vector<std::string>::const_iterator file = caches.begin(); file != caches.end(); ++file)
 219    {
 220       std::string nuke = flNotDir(*file);
 221       if (strncmp(cachefile.c_str(), nuke.c_str(), cachefile.length()) != 0)
 222          continue;
 223       unlink(file->c_str());
 224    }
 225 }
 226                                                                         /*}}}*/
 227 // CacheFile::Close - close the cache files                             /*{{{*/
 228 // ---------------------------------------------------------------------
 229 /* */
 230 void pkgCacheFile::Close()
 231 {
 232    delete DCache;
 233    delete Policy;
 234    delete Cache;
 235    delete SrcList;
 236    delete Map;
 237    _system->UnLock(true);
 238
 239    Map = NULL;
 240    DCache = NULL;
 241    Policy = NULL;
 242    Cache = NULL;
 243    SrcList = NULL;
 244 }
 245                                                                         /*}}}*/