apt-pkg/deb/debindexfile.cc

   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 (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 // TranslationsIndex::debTranslationsIndex - Contructor                 /*{{{*/
 324 // ---------------------------------------------------------------------
 325 /* */
 326 debTranslationsIndex::debTranslationsIndex(string URI,string Dist,string Section) :
 327                   pkgIndexFile(true), URI(URI), Dist(Dist), Section(Section)
 328 {
 329 }
 330                                                                         /*}}}*/
 331 // TranslationIndex::Trans* - Return the URI to the translation files   /*{{{*/
 332 // ---------------------------------------------------------------------
 333 /* */
 334 inline string debTranslationsIndex::IndexFile(const char *Type) const
 335 {
 336    return _config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
 337 }
 338 string debTranslationsIndex::IndexURI(const char *Type) const
 339 {
 340    string Res;
 341
 342    string theURI = URI;
 343    // FIXME: EVIL! Remove as soon as pdiff support is offical
 344    string remap = _config->Find("DDTP::URL-Remap::"+URI,"");
 345    if(!remap.empty())
 346       theURI = remap;
 347
 348
 349    if (Dist[Dist.size() - 1] == '/')
 350    {
 351       if (Dist != "/")
 352          Res = theURI + Dist;
 353       else
 354          Res = theURI;
 355    }
 356    else
 357       Res = theURI + "dists/" + Dist + '/' + Section +
 358       "/i18n/Translation-";
 359
 360    Res += Type;
 361    return Res;
 362 }
 363                                                                         /*}}}*/
 364 // TranslationsIndex::GetIndexes - Fetch the index files                /*{{{*/
 365 // ---------------------------------------------------------------------
 366 /* */
 367 bool debTranslationsIndex::GetIndexes(pkgAcquire *Owner) const
 368 {
 369    if (TranslationsAvailable()) {
 370      string TranslationFile = "Translation-" + LanguageCode();
 371      new pkgAcqIndexTrans(Owner, IndexURI(LanguageCode().c_str()),
 372                           Info(TranslationFile.c_str()),
 373                           TranslationFile);
 374    }
 375
 376    return true;
 377 }
 378                                                                         /*}}}*/
 379 // TranslationsIndex::Describe - Give a descriptive path to the index   /*{{{*/
 380 // ---------------------------------------------------------------------
 381 /* This should help the user find the index in the sources.list and
 382    in the filesystem for problem solving */
 383 string debTranslationsIndex::Describe(bool Short) const
 384 {
 385    char S[300];
 386    if (Short == true)
 387       snprintf(S,sizeof(S),"%s",Info(TranslationFile().c_str()).c_str());
 388    else
 389       snprintf(S,sizeof(S),"%s (%s)",Info(TranslationFile().c_str()).c_str(),
 390                IndexFile(LanguageCode().c_str()).c_str());
 391    return S;
 392 }
 393                                                                         /*}}}*/
 394 // TranslationsIndex::Info - One liner describing the index URI         /*{{{*/
 395 // ---------------------------------------------------------------------
 396 /* */
 397 string debTranslationsIndex::Info(const char *Type) const
 398 {
 399    string Info = ::URI::SiteOnly(URI) + ' ';
 400    if (Dist[Dist.size() - 1] == '/')
 401    {
 402       if (Dist != "/")
 403          Info += Dist;
 404    }
 405    else
 406       Info += Dist + '/' + Section;
 407    Info += " ";
 408    Info += Type;
 409    return Info;
 410 }
 411                                                                         /*}}}*/
 412 bool debTranslationsIndex::HasPackages() const
 413 {
 414    if(!TranslationsAvailable())
 415       return false;
 416
 417    return FileExists(IndexFile(LanguageCode().c_str()));
 418 }
 419
 420 // TranslationsIndex::Exists - Check if the index is available          /*{{{*/
 421 // ---------------------------------------------------------------------
 422 /* */
 423 bool debTranslationsIndex::Exists() const
 424 {
 425    return FileExists(IndexFile(LanguageCode().c_str()));
 426 }
 427                                                                         /*}}}*/
 428 // TranslationsIndex::Size - Return the size of the index               /*{{{*/
 429 // ---------------------------------------------------------------------
 430 /* This is really only used for progress reporting. */
 431 unsigned long debTranslationsIndex::Size() const
 432 {
 433    struct stat S;
 434    if (stat(IndexFile(LanguageCode().c_str()).c_str(),&S) != 0)
 435       return 0;
 436    return S.st_size;
 437 }
 438                                                                         /*}}}*/
 439 // TranslationsIndex::Merge - Load the index file into a cache          /*{{{*/
 440 // ---------------------------------------------------------------------
 441 /* */
 442 bool debTranslationsIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
 443 {
 444    // Check the translation file, if in use
 445    string TranslationFile = IndexFile(LanguageCode().c_str());
 446    if (TranslationsAvailable() && FileExists(TranslationFile))
 447    {
 448      FileFd Trans(TranslationFile,FileFd::ReadOnly);
 449      debListParser TransParser(&Trans);
 450      if (_error->PendingError() == true)
 451        return false;
 452
 453      Prog.SubProgress(0, Info(TranslationFile.c_str()));
 454      if (Gen.SelectFile(TranslationFile,string(),*this) == false)
 455        return _error->Error("Problem with SelectFile %s",TranslationFile.c_str());
 456
 457      // Store the IMS information
 458      pkgCache::PkgFileIterator TransFile = Gen.GetCurFile();
 459      struct stat TransSt;
 460      if (fstat(Trans.Fd(),&TransSt) != 0)
 461        return _error->Errno("fstat","Failed to stat");
 462      TransFile->Size = TransSt.st_size;
 463      TransFile->mtime = TransSt.st_mtime;
 464
 465      if (Gen.MergeList(TransParser) == false)
 466        return _error->Error("Problem with MergeList %s",TranslationFile.c_str());
 467    }
 468
 469    return true;
 470 }
 471                                                                         /*}}}*/
 472 // TranslationsIndex::FindInCache - Find this index                             /*{{{*/
 473 // ---------------------------------------------------------------------
 474 /* */
 475 pkgCache::PkgFileIterator debTranslationsIndex::FindInCache(pkgCache &Cache) const
 476 {
 477    string FileName = IndexFile(LanguageCode().c_str());
 478
 479    pkgCache::PkgFileIterator File = Cache.FileBegin();
 480    for (; File.end() == false; File++)
 481    {
 482       if (FileName != File.FileName())
 483          continue;
 484
 485       struct stat St;
 486       if (stat(File.FileName(),&St) != 0)
 487          return pkgCache::PkgFileIterator(Cache);
 488       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 489          return pkgCache::PkgFileIterator(Cache);
 490       return File;
 491    }
 492    return File;
 493 }
 494                                                                         /*}}}*/
 495 // StatusIndex::debStatusIndex - Constructor                            /*{{{*/
 496 // ---------------------------------------------------------------------
 497 /* */
 498 debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), File(File)
 499 {
 500 }
 501                                                                         /*}}}*/
 502 // StatusIndex::Size - Return the size of the index                     /*{{{*/
 503 // ---------------------------------------------------------------------
 504 /* */
 505 unsigned long debStatusIndex::Size() const
 506 {
 507    struct stat S;
 508    if (stat(File.c_str(),&S) != 0)
 509       return 0;
 510    return S.st_size;
 511 }
 512                                                                         /*}}}*/
 513 // StatusIndex::Merge - Load the index file into a cache                /*{{{*/
 514 // ---------------------------------------------------------------------
 515 /* */
 516 bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
 517 {
 518    FileFd Pkg(File,FileFd::ReadOnly);
 519    if (_error->PendingError() == true)
 520       return false;
 521    debListParser Parser(&Pkg);
 522    if (_error->PendingError() == true)
 523       return false;
 524
 525    Prog.SubProgress(0,File);
 526    if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false)
 527       return _error->Error("Problem with SelectFile %s",File.c_str());
 528
 529    // Store the IMS information
 530    pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
 531    struct stat St;
 532    if (fstat(Pkg.Fd(),&St) != 0)
 533       return _error->Errno("fstat","Failed to stat");
 534    CFile->Size = St.st_size;
 535    CFile->mtime = St.st_mtime;
 536    CFile->Archive = Gen.WriteUniqString("now");
 537
 538    if (Gen.MergeList(Parser) == false)
 539       return _error->Error("Problem with MergeList %s",File.c_str());
 540    return true;
 541 }
 542                                                                         /*}}}*/
 543 // StatusIndex::FindInCache - Find this index                           /*{{{*/
 544 // ---------------------------------------------------------------------
 545 /* */
 546 pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
 547 {
 548    pkgCache::PkgFileIterator File = Cache.FileBegin();
 549    for (; File.end() == false; File++)
 550    {
 551       if (this->File != File.FileName())
 552          continue;
 553
 554       struct stat St;
 555       if (stat(File.FileName(),&St) != 0)
 556          return pkgCache::PkgFileIterator(Cache);
 557       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 558          return pkgCache::PkgFileIterator(Cache);
 559       return File;
 560    }
 561    return File;
 562 }
 563                                                                         /*}}}*/
 564 // StatusIndex::Exists - Check if the index is available                /*{{{*/
 565 // ---------------------------------------------------------------------
 566 /* */
 567 bool debStatusIndex::Exists() const
 568 {
 569    // Abort if the file does not exist.
 570    return true;
 571 }
 572                                                                         /*}}}*/
 573
 574 // Index File types for Debian                                          /*{{{*/
 575 class debIFTypeSrc : public pkgIndexFile::Type
 576 {
 577    public:
 578
 579    debIFTypeSrc() {Label = "Debian Source Index";};
 580 };
 581 class debIFTypePkg : public pkgIndexFile::Type
 582 {
 583    public:
 584
 585    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 586    {
 587       return new debRecordParser(File.FileName(),*File.Cache());
 588    };
 589    debIFTypePkg() {Label = "Debian Package Index";};
 590 };
 591 class debIFTypeTrans : public debIFTypePkg
 592 {
 593    public:
 594    debIFTypeTrans() {Label = "Debian Translation Index";};
 595 };
 596 class debIFTypeStatus : public pkgIndexFile::Type
 597 {
 598    public:
 599
 600    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 601    {
 602       return new debRecordParser(File.FileName(),*File.Cache());
 603    };
 604    debIFTypeStatus() {Label = "Debian dpkg status file";};
 605 };
 606 static debIFTypeSrc _apt_Src;
 607 static debIFTypePkg _apt_Pkg;
 608 static debIFTypeTrans _apt_Trans;
 609 static debIFTypeStatus _apt_Status;
 610
 611 const pkgIndexFile::Type *debSourcesIndex::GetType() const
 612 {
 613    return &_apt_Src;
 614 }
 615 const pkgIndexFile::Type *debPackagesIndex::GetType() const
 616 {
 617    return &_apt_Pkg;
 618 }
 619 const pkgIndexFile::Type *debTranslationsIndex::GetType() const
 620 {
 621    return &_apt_Trans;
 622 }
 623 const pkgIndexFile::Type *debStatusIndex::GetType() const
 624 {
 625    return &_apt_Status;
 626 }
 627
 628                                                                         /*}}}*/