| 1 | // -*- mode: cpp; mode: fold -*- |
| 2 | // Description /*{{{*/ |
| 3 | // $Id: debindexfile.cc,v 1.5.2.3 2004/01/04 19:11:00 mdz Exp $ |
| 4 | /* ###################################################################### |
| 5 | |
| 6 | Debian Specific sources.list types and the three sorts of Debian |
| 7 | index files. |
| 8 | |
| 9 | ##################################################################### */ |
| 10 | /*}}}*/ |
| 11 | // Include Files /*{{{*/ |
| 12 | #ifdef __GNUG__ |
| 13 | #pragma implementation "apt-pkg/debindexfile.h" |
| 14 | #endif |
| 15 | |
| 16 | #include <apt-pkg/debindexfile.h> |
| 17 | #include <apt-pkg/debsrcrecords.h> |
| 18 | #include <apt-pkg/deblistparser.h> |
| 19 | #include <apt-pkg/debrecords.h> |
| 20 | #include <apt-pkg/sourcelist.h> |
| 21 | #include <apt-pkg/configuration.h> |
| 22 | #include <apt-pkg/progress.h> |
| 23 | #include <apt-pkg/error.h> |
| 24 | #include <apt-pkg/strutl.h> |
| 25 | #include <apt-pkg/acquire-item.h> |
| 26 | #include <apt-pkg/debmetaindex.h> |
| 27 | |
| 28 | #include <sys/stat.h> |
| 29 | /*}}}*/ |
| 30 | |
| 31 | // SourcesIndex::debSourcesIndex - Constructor /*{{{*/ |
| 32 | // --------------------------------------------------------------------- |
| 33 | /* */ |
| 34 | debSourcesIndex::debSourcesIndex(string URI,string Dist,string Section,bool Trusted) : |
| 35 | pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section) |
| 36 | { |
| 37 | } |
| 38 | /*}}}*/ |
| 39 | // SourcesIndex::SourceInfo - Short 1 liner describing a source /*{{{*/ |
| 40 | // --------------------------------------------------------------------- |
| 41 | /* The result looks like: |
| 42 | http://foo/ stable/main src 1.1.1 (dsc) */ |
| 43 | string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record, |
| 44 | pkgSrcRecords::File const &File) const |
| 45 | { |
| 46 | string Res; |
| 47 | Res = ::URI::SiteOnly(URI) + ' '; |
| 48 | if (Dist[Dist.size() - 1] == '/') |
| 49 | { |
| 50 | if (Dist != "/") |
| 51 | Res += Dist; |
| 52 | } |
| 53 | else |
| 54 | Res += Dist + '/' + Section; |
| 55 | |
| 56 | Res += " "; |
| 57 | Res += Record.Package(); |
| 58 | Res += " "; |
| 59 | Res += Record.Version(); |
| 60 | if (File.Type.empty() == false) |
| 61 | Res += " (" + File.Type + ")"; |
| 62 | return Res; |
| 63 | } |
| 64 | /*}}}*/ |
| 65 | // SourcesIndex::CreateSrcParser - Get a parser for the source files /*{{{*/ |
| 66 | // --------------------------------------------------------------------- |
| 67 | /* */ |
| 68 | pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const |
| 69 | { |
| 70 | string SourcesURI = URItoFileName(IndexURI("Sources")); |
| 71 | return new debSrcRecordParser(_config->FindDir("Dir::State::lists") + |
| 72 | SourcesURI,this); |
| 73 | } |
| 74 | /*}}}*/ |
| 75 | // SourcesIndex::Describe - Give a descriptive path to the index /*{{{*/ |
| 76 | // --------------------------------------------------------------------- |
| 77 | /* */ |
| 78 | string debSourcesIndex::Describe(bool Short) const |
| 79 | { |
| 80 | char S[300]; |
| 81 | if (Short == true) |
| 82 | snprintf(S,sizeof(S),"%s",Info("Sources").c_str()); |
| 83 | else |
| 84 | snprintf(S,sizeof(S),"%s (%s)",Info("Sources").c_str(), |
| 85 | IndexFile("Sources").c_str()); |
| 86 | |
| 87 | return S; |
| 88 | } |
| 89 | /*}}}*/ |
| 90 | // SourcesIndex::Info - One liner describing the index URI /*{{{*/ |
| 91 | // --------------------------------------------------------------------- |
| 92 | /* */ |
| 93 | string debSourcesIndex::Info(const char *Type) const |
| 94 | { |
| 95 | string Info = ::URI::SiteOnly(URI) + ' '; |
| 96 | if (Dist[Dist.size() - 1] == '/') |
| 97 | { |
| 98 | if (Dist != "/") |
| 99 | Info += Dist; |
| 100 | } |
| 101 | else |
| 102 | Info += Dist + '/' + Section; |
| 103 | Info += " "; |
| 104 | Info += Type; |
| 105 | return Info; |
| 106 | } |
| 107 | /*}}}*/ |
| 108 | // SourcesIndex::Index* - Return the URI to the index files /*{{{*/ |
| 109 | // --------------------------------------------------------------------- |
| 110 | /* */ |
| 111 | inline string debSourcesIndex::IndexFile(const char *Type) const |
| 112 | { |
| 113 | return URItoFileName(IndexURI(Type)); |
| 114 | } |
| 115 | string debSourcesIndex::IndexURI(const char *Type) const |
| 116 | { |
| 117 | string Res; |
| 118 | if (Dist[Dist.size() - 1] == '/') |
| 119 | { |
| 120 | if (Dist != "/") |
| 121 | Res = URI + Dist; |
| 122 | else |
| 123 | Res = URI; |
| 124 | } |
| 125 | else |
| 126 | Res = URI + "dists/" + Dist + '/' + Section + |
| 127 | "/source/"; |
| 128 | |
| 129 | Res += Type; |
| 130 | return Res; |
| 131 | } |
| 132 | /*}}}*/ |
| 133 | // SourcesIndex::Exists - Check if the index is available /*{{{*/ |
| 134 | // --------------------------------------------------------------------- |
| 135 | /* */ |
| 136 | bool debSourcesIndex::Exists() const |
| 137 | { |
| 138 | return FileExists(IndexFile("Sources")); |
| 139 | } |
| 140 | /*}}}*/ |
| 141 | // SourcesIndex::Size - Return the size of the index /*{{{*/ |
| 142 | // --------------------------------------------------------------------- |
| 143 | /* */ |
| 144 | unsigned long debSourcesIndex::Size() const |
| 145 | { |
| 146 | struct stat S; |
| 147 | if (stat(IndexFile("Sources").c_str(),&S) != 0) |
| 148 | return 0; |
| 149 | return S.st_size; |
| 150 | } |
| 151 | /*}}}*/ |
| 152 | |
| 153 | // PackagesIndex::debPackagesIndex - Contructor /*{{{*/ |
| 154 | // --------------------------------------------------------------------- |
| 155 | /* */ |
| 156 | debPackagesIndex::debPackagesIndex(string URI,string Dist,string Section,bool Trusted) : |
| 157 | pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section) |
| 158 | { |
| 159 | } |
| 160 | /*}}}*/ |
| 161 | // PackagesIndex::ArchiveInfo - Short version of the archive url /*{{{*/ |
| 162 | // --------------------------------------------------------------------- |
| 163 | /* This is a shorter version that is designed to be < 60 chars or so */ |
| 164 | string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const |
| 165 | { |
| 166 | string Res = ::URI::SiteOnly(URI) + ' '; |
| 167 | if (Dist[Dist.size() - 1] == '/') |
| 168 | { |
| 169 | if (Dist != "/") |
| 170 | Res += Dist; |
| 171 | } |
| 172 | else |
| 173 | Res += Dist + '/' + Section; |
| 174 | |
| 175 | Res += " "; |
| 176 | Res += Ver.ParentPkg().Name(); |
| 177 | Res += " "; |
| 178 | Res += Ver.VerStr(); |
| 179 | return Res; |
| 180 | } |
| 181 | /*}}}*/ |
| 182 | // PackagesIndex::Describe - Give a descriptive path to the index /*{{{*/ |
| 183 | // --------------------------------------------------------------------- |
| 184 | /* This should help the user find the index in the sources.list and |
| 185 | in the filesystem for problem solving */ |
| 186 | string debPackagesIndex::Describe(bool Short) const |
| 187 | { |
| 188 | char S[300]; |
| 189 | if (Short == true) |
| 190 | snprintf(S,sizeof(S),"%s",Info("Packages").c_str()); |
| 191 | else |
| 192 | snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(), |
| 193 | IndexFile("Packages").c_str()); |
| 194 | return S; |
| 195 | } |
| 196 | /*}}}*/ |
| 197 | // PackagesIndex::Info - One liner describing the index URI /*{{{*/ |
| 198 | // --------------------------------------------------------------------- |
| 199 | /* */ |
| 200 | string debPackagesIndex::Info(const char *Type) const |
| 201 | { |
| 202 | string Info = ::URI::SiteOnly(URI) + ' '; |
| 203 | if (Dist[Dist.size() - 1] == '/') |
| 204 | { |
| 205 | if (Dist != "/") |
| 206 | Info += Dist; |
| 207 | } |
| 208 | else |
| 209 | Info += Dist + '/' + Section; |
| 210 | Info += " "; |
| 211 | Info += Type; |
| 212 | return Info; |
| 213 | } |
| 214 | /*}}}*/ |
| 215 | // PackagesIndex::Index* - Return the URI to the index files /*{{{*/ |
| 216 | // --------------------------------------------------------------------- |
| 217 | /* */ |
| 218 | inline string debPackagesIndex::IndexFile(const char *Type) const |
| 219 | { |
| 220 | return _config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type)); |
| 221 | } |
| 222 | string debPackagesIndex::IndexURI(const char *Type) const |
| 223 | { |
| 224 | string Res; |
| 225 | if (Dist[Dist.size() - 1] == '/') |
| 226 | { |
| 227 | if (Dist != "/") |
| 228 | Res = URI + Dist; |
| 229 | else |
| 230 | Res = URI; |
| 231 | } |
| 232 | else |
| 233 | Res = URI + "dists/" + Dist + '/' + Section + |
| 234 | "/binary-" + _config->Find("APT::Architecture") + '/'; |
| 235 | |
| 236 | Res += Type; |
| 237 | return Res; |
| 238 | } |
| 239 | /*}}}*/ |
| 240 | // PackagesIndex::Exists - Check if the index is available /*{{{*/ |
| 241 | // --------------------------------------------------------------------- |
| 242 | /* */ |
| 243 | bool debPackagesIndex::Exists() const |
| 244 | { |
| 245 | return FileExists(IndexFile("Packages")); |
| 246 | } |
| 247 | /*}}}*/ |
| 248 | // PackagesIndex::Size - Return the size of the index /*{{{*/ |
| 249 | // --------------------------------------------------------------------- |
| 250 | /* This is really only used for progress reporting. */ |
| 251 | unsigned long debPackagesIndex::Size() const |
| 252 | { |
| 253 | struct stat S; |
| 254 | if (stat(IndexFile("Packages").c_str(),&S) != 0) |
| 255 | return 0; |
| 256 | return S.st_size; |
| 257 | } |
| 258 | /*}}}*/ |
| 259 | // PackagesIndex::Merge - Load the index file into a cache /*{{{*/ |
| 260 | // --------------------------------------------------------------------- |
| 261 | /* */ |
| 262 | bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const |
| 263 | { |
| 264 | string PackageFile = IndexFile("Packages"); |
| 265 | FileFd Pkg(PackageFile,FileFd::ReadOnly); |
| 266 | debListParser Parser(&Pkg); |
| 267 | if (_error->PendingError() == true) |
| 268 | return _error->Error("Problem opening %s",PackageFile.c_str()); |
| 269 | |
| 270 | Prog.SubProgress(0,Info("Packages")); |
| 271 | ::URI Tmp(URI); |
| 272 | if (Gen.SelectFile(PackageFile,Tmp.Host,*this) == false) |
| 273 | return _error->Error("Problem with SelectFile %s",PackageFile.c_str()); |
| 274 | |
| 275 | // Store the IMS information |
| 276 | pkgCache::PkgFileIterator File = Gen.GetCurFile(); |
| 277 | struct stat St; |
| 278 | if (fstat(Pkg.Fd(),&St) != 0) |
| 279 | return _error->Errno("fstat","Failed to stat"); |
| 280 | File->Size = St.st_size; |
| 281 | File->mtime = St.st_mtime; |
| 282 | |
| 283 | if (Gen.MergeList(Parser) == false) |
| 284 | return _error->Error("Problem with MergeList %s",PackageFile.c_str()); |
| 285 | |
| 286 | // Check the release file |
| 287 | string ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("Release"); |
| 288 | if (FileExists(ReleaseFile) == true) |
| 289 | { |
| 290 | FileFd Rel(ReleaseFile,FileFd::ReadOnly); |
| 291 | if (_error->PendingError() == true) |
| 292 | return false; |
| 293 | Parser.LoadReleaseInfo(File,Rel,Section); |
| 294 | } |
| 295 | |
| 296 | return true; |
| 297 | } |
| 298 | /*}}}*/ |
| 299 | // PackagesIndex::FindInCache - Find this index /*{{{*/ |
| 300 | // --------------------------------------------------------------------- |
| 301 | /* */ |
| 302 | pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const |
| 303 | { |
| 304 | string FileName = IndexFile("Packages"); |
| 305 | pkgCache::PkgFileIterator File = Cache.FileBegin(); |
| 306 | for (; File.end() == false; File++) |
| 307 | { |
| 308 | if (File.FileName() == NULL || FileName != File.FileName()) |
| 309 | continue; |
| 310 | |
| 311 | struct stat St; |
| 312 | if (stat(File.FileName(),&St) != 0) |
| 313 | return pkgCache::PkgFileIterator(Cache); |
| 314 | if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime) |
| 315 | return pkgCache::PkgFileIterator(Cache); |
| 316 | return File; |
| 317 | } |
| 318 | |
| 319 | return File; |
| 320 | } |
| 321 | /*}}}*/ |
| 322 | |
| 323 | // StatusIndex::debStatusIndex - Constructor /*{{{*/ |
| 324 | // --------------------------------------------------------------------- |
| 325 | /* */ |
| 326 | debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), File(File) |
| 327 | { |
| 328 | } |
| 329 | /*}}}*/ |
| 330 | // StatusIndex::Size - Return the size of the index /*{{{*/ |
| 331 | // --------------------------------------------------------------------- |
| 332 | /* */ |
| 333 | unsigned long debStatusIndex::Size() const |
| 334 | { |
| 335 | struct stat S; |
| 336 | if (stat(File.c_str(),&S) != 0) |
| 337 | return 0; |
| 338 | return S.st_size; |
| 339 | } |
| 340 | /*}}}*/ |
| 341 | // StatusIndex::Merge - Load the index file into a cache /*{{{*/ |
| 342 | // --------------------------------------------------------------------- |
| 343 | /* */ |
| 344 | bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const |
| 345 | { |
| 346 | FileFd Pkg(File,FileFd::ReadOnly); |
| 347 | if (_error->PendingError() == true) |
| 348 | return false; |
| 349 | debListParser Parser(&Pkg); |
| 350 | if (_error->PendingError() == true) |
| 351 | return false; |
| 352 | |
| 353 | Prog.SubProgress(0,File); |
| 354 | if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false) |
| 355 | return _error->Error("Problem with SelectFile %s",File.c_str()); |
| 356 | |
| 357 | // Store the IMS information |
| 358 | pkgCache::PkgFileIterator CFile = Gen.GetCurFile(); |
| 359 | struct stat St; |
| 360 | if (fstat(Pkg.Fd(),&St) != 0) |
| 361 | return _error->Errno("fstat","Failed to stat"); |
| 362 | CFile->Size = St.st_size; |
| 363 | CFile->mtime = St.st_mtime; |
| 364 | CFile->Archive = Gen.WriteUniqString("now"); |
| 365 | |
| 366 | if (Gen.MergeList(Parser) == false) |
| 367 | return _error->Error("Problem with MergeList %s",File.c_str()); |
| 368 | return true; |
| 369 | } |
| 370 | /*}}}*/ |
| 371 | // StatusIndex::FindInCache - Find this index /*{{{*/ |
| 372 | // --------------------------------------------------------------------- |
| 373 | /* */ |
| 374 | pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const |
| 375 | { |
| 376 | pkgCache::PkgFileIterator File = Cache.FileBegin(); |
| 377 | for (; File.end() == false; File++) |
| 378 | { |
| 379 | if (this->File != File.FileName()) |
| 380 | continue; |
| 381 | |
| 382 | struct stat St; |
| 383 | if (stat(File.FileName(),&St) != 0) |
| 384 | return pkgCache::PkgFileIterator(Cache); |
| 385 | if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime) |
| 386 | return pkgCache::PkgFileIterator(Cache); |
| 387 | return File; |
| 388 | } |
| 389 | return File; |
| 390 | } |
| 391 | /*}}}*/ |
| 392 | // StatusIndex::Exists - Check if the index is available /*{{{*/ |
| 393 | // --------------------------------------------------------------------- |
| 394 | /* */ |
| 395 | bool debStatusIndex::Exists() const |
| 396 | { |
| 397 | // Abort if the file does not exist. |
| 398 | return true; |
| 399 | } |
| 400 | /*}}}*/ |
| 401 | |
| 402 | // Index File types for Debian /*{{{*/ |
| 403 | class debIFTypeSrc : public pkgIndexFile::Type |
| 404 | { |
| 405 | public: |
| 406 | |
| 407 | debIFTypeSrc() {Label = "Debian Source Index";}; |
| 408 | }; |
| 409 | class debIFTypePkg : public pkgIndexFile::Type |
| 410 | { |
| 411 | public: |
| 412 | |
| 413 | virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const |
| 414 | { |
| 415 | return new debRecordParser(File.FileName(),*File.Cache()); |
| 416 | }; |
| 417 | debIFTypePkg() {Label = "Debian Package Index";}; |
| 418 | }; |
| 419 | class debIFTypeStatus : public pkgIndexFile::Type |
| 420 | { |
| 421 | public: |
| 422 | |
| 423 | virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const |
| 424 | { |
| 425 | return new debRecordParser(File.FileName(),*File.Cache()); |
| 426 | }; |
| 427 | debIFTypeStatus() {Label = "Debian dpkg status file";}; |
| 428 | }; |
| 429 | static debIFTypeSrc _apt_Src; |
| 430 | static debIFTypePkg _apt_Pkg; |
| 431 | static debIFTypeStatus _apt_Status; |
| 432 | |
| 433 | const pkgIndexFile::Type *debSourcesIndex::GetType() const |
| 434 | { |
| 435 | return &_apt_Src; |
| 436 | } |
| 437 | const pkgIndexFile::Type *debPackagesIndex::GetType() const |
| 438 | { |
| 439 | return &_apt_Pkg; |
| 440 | } |
| 441 | const pkgIndexFile::Type *debStatusIndex::GetType() const |
| 442 | { |
| 443 | return &_apt_Status; |
| 444 | } |
| 445 | |
| 446 | /*}}}*/ |