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