| 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 | /*}}}*/ |