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 #include <config.h>
  13
  14 #include <apt-pkg/debindexfile.h>
  15 #include <apt-pkg/debsrcrecords.h>
  16 #include <apt-pkg/deblistparser.h>
  17 #include <apt-pkg/debrecords.h>
  18 #include <apt-pkg/configuration.h>
  19 #include <apt-pkg/progress.h>
  20 #include <apt-pkg/error.h>
  21 #include <apt-pkg/strutl.h>
  22 #include <apt-pkg/acquire-item.h>
  23 #include <apt-pkg/debmetaindex.h>
  24 #include <apt-pkg/gpgv.h>
  25 #include <apt-pkg/fileutl.h>
  26 #include <apt-pkg/indexfile.h>
  27 #include <apt-pkg/mmap.h>
  28 #include <apt-pkg/pkgcache.h>
  29 #include <apt-pkg/cacheiterators.h>
  30 #include <apt-pkg/pkgcachegen.h>
  31 #include <apt-pkg/pkgrecords.h>
  32 #include <apt-pkg/srcrecords.h>
  33 #include <apt-pkg/sptr.h>
  34
  35 #include <stdio.h>
  36 #include <iostream>
  37 #include <string>
  38 #include <sys/stat.h>
  39                                                                         /*}}}*/
  40
  41 using std::string;
  42
  43 // SourcesIndex::debSourcesIndex - Constructor                          /*{{{*/
  44 // ---------------------------------------------------------------------
  45 /* */
  46 debSourcesIndex::debSourcesIndex(string URI,string Dist,string Section,bool Trusted) :
  47      pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section)
  48 {
  49 }
  50                                                                         /*}}}*/
  51 // SourcesIndex::SourceInfo - Short 1 liner describing a source         /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* The result looks like:
  54      http://foo/debian/ stable/main src 1.1.1 (dsc) */
  55 string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
  56                                    pkgSrcRecords::File const &File) const
  57 {
  58    string Res;
  59    Res = ::URI::NoUserPassword(URI) + ' ';
  60    if (Dist[Dist.size() - 1] == '/')
  61    {
  62       if (Dist != "/")
  63          Res += Dist;
  64    }
  65    else
  66       Res += Dist + '/' + Section;
  67
  68    Res += " ";
  69    Res += Record.Package();
  70    Res += " ";
  71    Res += Record.Version();
  72    if (File.Type.empty() == false)
  73       Res += " (" + File.Type + ")";
  74    return Res;
  75 }
  76                                                                         /*}}}*/
  77 // SourcesIndex::CreateSrcParser - Get a parser for the source files    /*{{{*/
  78 // ---------------------------------------------------------------------
  79 /* */
  80 pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
  81 {
  82    string SourcesURI = _config->FindDir("Dir::State::lists") +
  83       URItoFileName(IndexURI("Sources"));
  84
  85    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
  86    for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
  87    {
  88       string p;
  89       p = SourcesURI + '.' + *t;
  90       if (FileExists(p))
  91          return new debSrcRecordParser(p, this);
  92    }
  93    if (FileExists(SourcesURI))
  94       return new debSrcRecordParser(SourcesURI, this);
  95    return NULL;
  96 }
  97                                                                         /*}}}*/
  98 // SourcesIndex::Describe - Give a descriptive path to the index        /*{{{*/
  99 // ---------------------------------------------------------------------
 100 /* */
 101 string debSourcesIndex::Describe(bool Short) const
 102 {
 103    char S[300];
 104    if (Short == true)
 105       snprintf(S,sizeof(S),"%s",Info("Sources").c_str());
 106    else
 107       snprintf(S,sizeof(S),"%s (%s)",Info("Sources").c_str(),
 108                IndexFile("Sources").c_str());
 109
 110    return S;
 111 }
 112                                                                         /*}}}*/
 113 // SourcesIndex::Info - One liner describing the index URI              /*{{{*/
 114 // ---------------------------------------------------------------------
 115 /* */
 116 string debSourcesIndex::Info(const char *Type) const
 117 {
 118    string Info = ::URI::NoUserPassword(URI) + ' ';
 119    if (Dist[Dist.size() - 1] == '/')
 120    {
 121       if (Dist != "/")
 122          Info += Dist;
 123    }
 124    else
 125       Info += Dist + '/' + Section;
 126    Info += " ";
 127    Info += Type;
 128    return Info;
 129 }
 130                                                                         /*}}}*/
 131 // SourcesIndex::Index* - Return the URI to the index files             /*{{{*/
 132 // ---------------------------------------------------------------------
 133 /* */
 134 string debSourcesIndex::IndexFile(const char *Type) const
 135 {
 136    string s = URItoFileName(IndexURI(Type));
 137
 138    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 139    for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 140    {
 141       string p = s + '.' + *t;
 142       if (FileExists(p))
 143          return p;
 144    }
 145    return s;
 146 }
 147
 148 string debSourcesIndex::IndexURI(const char *Type) const
 149 {
 150    string Res;
 151    if (Dist[Dist.size() - 1] == '/')
 152    {
 153       if (Dist != "/")
 154          Res = URI + Dist;
 155       else
 156          Res = URI;
 157    }
 158    else
 159       Res = URI + "dists/" + Dist + '/' + Section +
 160       "/source/";
 161
 162    Res += Type;
 163    return Res;
 164 }
 165                                                                         /*}}}*/
 166 // SourcesIndex::Exists - Check if the index is available               /*{{{*/
 167 // ---------------------------------------------------------------------
 168 /* */
 169 bool debSourcesIndex::Exists() const
 170 {
 171    return FileExists(IndexFile("Sources"));
 172 }
 173                                                                         /*}}}*/
 174 // SourcesIndex::Size - Return the size of the index                    /*{{{*/
 175 // ---------------------------------------------------------------------
 176 /* */
 177 unsigned long debSourcesIndex::Size() const
 178 {
 179    unsigned long size = 0;
 180
 181    /* we need to ignore errors here; if the lists are absent, just return 0 */
 182    _error->PushToStack();
 183
 184    FileFd f(IndexFile("Sources"), FileFd::ReadOnly, FileFd::Extension);
 185    if (!f.Failed())
 186       size = f.Size();
 187
 188    if (_error->PendingError() == true)
 189        size = 0;
 190    _error->RevertToStack();
 191
 192    return size;
 193 }
 194                                                                         /*}}}*/
 195
 196 // PackagesIndex::debPackagesIndex - Contructor                         /*{{{*/
 197 // ---------------------------------------------------------------------
 198 /* */
 199 debPackagesIndex::debPackagesIndex(string const &URI, string const &Dist, string const &Section,
 200                                         bool const &Trusted, string const &Arch) :
 201                   pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section), Architecture(Arch)
 202 {
 203         if (Architecture == "native")
 204                 Architecture = _config->Find("APT::Architecture");
 205 }
 206                                                                         /*}}}*/
 207 // PackagesIndex::ArchiveInfo - Short version of the archive url        /*{{{*/
 208 // ---------------------------------------------------------------------
 209 /* This is a shorter version that is designed to be < 60 chars or so */
 210 string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const
 211 {
 212    string Res = ::URI::NoUserPassword(URI) + ' ';
 213    if (Dist[Dist.size() - 1] == '/')
 214    {
 215       if (Dist != "/")
 216          Res += Dist;
 217    }
 218    else
 219       Res += Dist + '/' + Section;
 220
 221    Res += " ";
 222    Res += Ver.ParentPkg().Name();
 223    Res += " ";
 224    if (Dist[Dist.size() - 1] != '/')
 225       Res.append(Ver.Arch()).append(" ");
 226    Res += Ver.VerStr();
 227    return Res;
 228 }
 229                                                                         /*}}}*/
 230 // PackagesIndex::Describe - Give a descriptive path to the index       /*{{{*/
 231 // ---------------------------------------------------------------------
 232 /* This should help the user find the index in the sources.list and
 233    in the filesystem for problem solving */
 234 string debPackagesIndex::Describe(bool Short) const
 235 {
 236    char S[300];
 237    if (Short == true)
 238       snprintf(S,sizeof(S),"%s",Info("Packages").c_str());
 239    else
 240       snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(),
 241                IndexFile("Packages").c_str());
 242    return S;
 243 }
 244                                                                         /*}}}*/
 245 // PackagesIndex::Info - One liner describing the index URI             /*{{{*/
 246 // ---------------------------------------------------------------------
 247 /* */
 248 string debPackagesIndex::Info(const char *Type) const
 249 {
 250    string Info = ::URI::NoUserPassword(URI) + ' ';
 251    if (Dist[Dist.size() - 1] == '/')
 252    {
 253       if (Dist != "/")
 254          Info += Dist;
 255    }
 256    else
 257       Info += Dist + '/' + Section;
 258    Info += " ";
 259    if (Dist[Dist.size() - 1] != '/')
 260       Info += Architecture + " ";
 261    Info += Type;
 262    return Info;
 263 }
 264                                                                         /*}}}*/
 265 // PackagesIndex::Index* - Return the URI to the index files            /*{{{*/
 266 // ---------------------------------------------------------------------
 267 /* */
 268 string debPackagesIndex::IndexFile(const char *Type) const
 269 {
 270    string s =_config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
 271
 272    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 273    for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 274    {
 275       string p = s + '.' + *t;
 276       if (FileExists(p))
 277          return p;
 278    }
 279    return s;
 280 }
 281 string debPackagesIndex::IndexURI(const char *Type) const
 282 {
 283    string Res;
 284    if (Dist[Dist.size() - 1] == '/')
 285    {
 286       if (Dist != "/")
 287          Res = URI + Dist;
 288       else
 289          Res = URI;
 290    }
 291    else
 292       Res = URI + "dists/" + Dist + '/' + Section +
 293       "/binary-" + Architecture + '/';
 294
 295    Res += Type;
 296    return Res;
 297 }
 298                                                                         /*}}}*/
 299 // PackagesIndex::Exists - Check if the index is available              /*{{{*/
 300 // ---------------------------------------------------------------------
 301 /* */
 302 bool debPackagesIndex::Exists() const
 303 {
 304    return FileExists(IndexFile("Packages"));
 305 }
 306                                                                         /*}}}*/
 307 // PackagesIndex::Size - Return the size of the index                   /*{{{*/
 308 // ---------------------------------------------------------------------
 309 /* This is really only used for progress reporting. */
 310 unsigned long debPackagesIndex::Size() const
 311 {
 312    unsigned long size = 0;
 313
 314    /* we need to ignore errors here; if the lists are absent, just return 0 */
 315    _error->PushToStack();
 316
 317    FileFd f(IndexFile("Packages"), FileFd::ReadOnly, FileFd::Extension);
 318    if (!f.Failed())
 319       size = f.Size();
 320
 321    if (_error->PendingError() == true)
 322        size = 0;
 323    _error->RevertToStack();
 324
 325    return size;
 326 }
 327                                                                         /*}}}*/
 328 // PackagesIndex::Merge - Load the index file into a cache              /*{{{*/
 329 // ---------------------------------------------------------------------
 330 /* */
 331 bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
 332 {
 333    string PackageFile = IndexFile("Packages");
 334    FileFd Pkg(PackageFile,FileFd::ReadOnly, FileFd::Extension);
 335    debListParser Parser(&Pkg, Architecture);
 336
 337    if (_error->PendingError() == true)
 338       return _error->Error("Problem opening %s",PackageFile.c_str());
 339    if (Prog != NULL)
 340       Prog->SubProgress(0,Info("Packages"));
 341    ::URI Tmp(URI);
 342    if (Gen.SelectFile(PackageFile,Tmp.Host,*this) == false)
 343       return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
 344
 345    // Store the IMS information
 346    pkgCache::PkgFileIterator File = Gen.GetCurFile();
 347    pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
 348    File->Size = Pkg.FileSize();
 349    File->mtime = Pkg.ModificationTime();
 350
 351    if (Gen.MergeList(Parser) == false)
 352       return _error->Error("Problem with MergeList %s",PackageFile.c_str());
 353
 354    // Check the release file
 355    string ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("InRelease");
 356    bool releaseExists = false;
 357    if (FileExists(ReleaseFile) == true)
 358       releaseExists = true;
 359    else
 360       ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("Release");
 361
 362    if (releaseExists == true || FileExists(ReleaseFile) == true)
 363    {
 364       FileFd Rel;
 365       // Beware: The 'Release' file might be clearsigned in case the
 366       // signature for an 'InRelease' file couldn't be checked
 367       if (OpenMaybeClearSignedFile(ReleaseFile, Rel) == false)
 368          return false;
 369
 370       if (_error->PendingError() == true)
 371          return false;
 372       Parser.LoadReleaseInfo(File,Rel,Section);
 373    }
 374
 375    return true;
 376 }
 377                                                                         /*}}}*/
 378 // PackagesIndex::FindInCache - Find this index                         /*{{{*/
 379 // ---------------------------------------------------------------------
 380 /* */
 381 pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const
 382 {
 383    string FileName = IndexFile("Packages");
 384    pkgCache::PkgFileIterator File = Cache.FileBegin();
 385    for (; File.end() == false; ++File)
 386    {
 387        if (File.FileName() == NULL || FileName != File.FileName())
 388          continue;
 389
 390       struct stat St;
 391       if (stat(File.FileName(),&St) != 0)
 392       {
 393          if (_config->FindB("Debug::pkgCacheGen", false))
 394             std::clog << "PackagesIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
 395          return pkgCache::PkgFileIterator(Cache);
 396       }
 397       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 398       {
 399          if (_config->FindB("Debug::pkgCacheGen", false))
 400             std::clog << "PackagesIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
 401                         << ") or mtime (" << St.st_mtime << " <> " << File->mtime
 402                         << ") doesn't match for " << File.FileName() << std::endl;
 403          return pkgCache::PkgFileIterator(Cache);
 404       }
 405       return File;
 406    }
 407
 408    return File;
 409 }
 410                                                                         /*}}}*/
 411
 412 // TranslationsIndex::debTranslationsIndex - Contructor                 /*{{{*/
 413 // ---------------------------------------------------------------------
 414 /* */
 415 debTranslationsIndex::debTranslationsIndex(string URI,string Dist,string Section,
 416                                                 char const * const Translation) :
 417                         pkgIndexFile(true), URI(URI), Dist(Dist), Section(Section),
 418                                 Language(Translation)
 419 {}
 420                                                                         /*}}}*/
 421 // TranslationIndex::Trans* - Return the URI to the translation files   /*{{{*/
 422 // ---------------------------------------------------------------------
 423 /* */
 424 string debTranslationsIndex::IndexFile(const char *Type) const
 425 {
 426    string s =_config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
 427
 428    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 429    for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 430    {
 431       string p = s + '.' + *t;
 432       if (FileExists(p))
 433          return p;
 434    }
 435    return s;
 436 }
 437 string debTranslationsIndex::IndexURI(const char *Type) const
 438 {
 439    string Res;
 440    if (Dist[Dist.size() - 1] == '/')
 441    {
 442       if (Dist != "/")
 443          Res = URI + Dist;
 444       else
 445          Res = URI;
 446    }
 447    else
 448       Res = URI + "dists/" + Dist + '/' + Section +
 449       "/i18n/Translation-";
 450
 451    Res += Type;
 452    return Res;
 453 }
 454                                                                         /*}}}*/
 455 // TranslationsIndex::Describe - Give a descriptive path to the index   /*{{{*/
 456 // ---------------------------------------------------------------------
 457 /* This should help the user find the index in the sources.list and
 458    in the filesystem for problem solving */
 459 string debTranslationsIndex::Describe(bool Short) const
 460 {
 461    char S[300];
 462    if (Short == true)
 463       snprintf(S,sizeof(S),"%s",Info(TranslationFile().c_str()).c_str());
 464    else
 465       snprintf(S,sizeof(S),"%s (%s)",Info(TranslationFile().c_str()).c_str(),
 466                IndexFile(Language).c_str());
 467    return S;
 468 }
 469                                                                         /*}}}*/
 470 // TranslationsIndex::Info - One liner describing the index URI         /*{{{*/
 471 // ---------------------------------------------------------------------
 472 /* */
 473 string debTranslationsIndex::Info(const char *Type) const
 474 {
 475    string Info = ::URI::NoUserPassword(URI) + ' ';
 476    if (Dist[Dist.size() - 1] == '/')
 477    {
 478       if (Dist != "/")
 479          Info += Dist;
 480    }
 481    else
 482       Info += Dist + '/' + Section;
 483    Info += " ";
 484    Info += Type;
 485    return Info;
 486 }
 487                                                                         /*}}}*/
 488 bool debTranslationsIndex::HasPackages() const                          /*{{{*/
 489 {
 490    return FileExists(IndexFile(Language));
 491 }
 492                                                                         /*}}}*/
 493 // TranslationsIndex::Exists - Check if the index is available          /*{{{*/
 494 // ---------------------------------------------------------------------
 495 /* */
 496 bool debTranslationsIndex::Exists() const
 497 {
 498    return FileExists(IndexFile(Language));
 499 }
 500                                                                         /*}}}*/
 501 // TranslationsIndex::Size - Return the size of the index               /*{{{*/
 502 // ---------------------------------------------------------------------
 503 /* This is really only used for progress reporting. */
 504 unsigned long debTranslationsIndex::Size() const
 505 {
 506    unsigned long size = 0;
 507
 508    /* we need to ignore errors here; if the lists are absent, just return 0 */
 509    _error->PushToStack();
 510
 511    FileFd f(IndexFile(Language), FileFd::ReadOnly, FileFd::Extension);
 512    if (!f.Failed())
 513       size = f.Size();
 514
 515    if (_error->PendingError() == true)
 516        size = 0;
 517    _error->RevertToStack();
 518
 519    return size;
 520 }
 521                                                                         /*}}}*/
 522 // TranslationsIndex::Merge - Load the index file into a cache          /*{{{*/
 523 // ---------------------------------------------------------------------
 524 /* */
 525 bool debTranslationsIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
 526 {
 527    // Check the translation file, if in use
 528    string TranslationFile = IndexFile(Language);
 529    if (FileExists(TranslationFile))
 530    {
 531      FileFd Trans(TranslationFile,FileFd::ReadOnly, FileFd::Extension);
 532      debTranslationsParser TransParser(&Trans);
 533      if (_error->PendingError() == true)
 534        return false;
 535
 536      if (Prog != NULL)
 537         Prog->SubProgress(0, Info(TranslationFile.c_str()));
 538      if (Gen.SelectFile(TranslationFile,string(),*this) == false)
 539        return _error->Error("Problem with SelectFile %s",TranslationFile.c_str());
 540
 541      // Store the IMS information
 542      pkgCache::PkgFileIterator TransFile = Gen.GetCurFile();
 543      TransFile->Size = Trans.FileSize();
 544      TransFile->mtime = Trans.ModificationTime();
 545
 546      if (Gen.MergeList(TransParser) == false)
 547        return _error->Error("Problem with MergeList %s",TranslationFile.c_str());
 548    }
 549
 550    return true;
 551 }
 552                                                                         /*}}}*/
 553 // TranslationsIndex::FindInCache - Find this index                             /*{{{*/
 554 // ---------------------------------------------------------------------
 555 /* */
 556 pkgCache::PkgFileIterator debTranslationsIndex::FindInCache(pkgCache &Cache) const
 557 {
 558    string FileName = IndexFile(Language);
 559
 560    pkgCache::PkgFileIterator File = Cache.FileBegin();
 561    for (; File.end() == false; ++File)
 562    {
 563       if (FileName != File.FileName())
 564          continue;
 565
 566       struct stat St;
 567       if (stat(File.FileName(),&St) != 0)
 568       {
 569          if (_config->FindB("Debug::pkgCacheGen", false))
 570             std::clog << "TranslationIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
 571          return pkgCache::PkgFileIterator(Cache);
 572       }
 573       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 574       {
 575          if (_config->FindB("Debug::pkgCacheGen", false))
 576             std::clog << "TranslationIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
 577                         << ") or mtime (" << St.st_mtime << " <> " << File->mtime
 578                         << ") doesn't match for " << File.FileName() << std::endl;
 579          return pkgCache::PkgFileIterator(Cache);
 580       }
 581       return File;
 582    }
 583    return File;
 584 }
 585                                                                         /*}}}*/
 586 // StatusIndex::debStatusIndex - Constructor                            /*{{{*/
 587 // ---------------------------------------------------------------------
 588 /* */
 589 debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), File(File)
 590 {
 591 }
 592                                                                         /*}}}*/
 593 // StatusIndex::Size - Return the size of the index                     /*{{{*/
 594 // ---------------------------------------------------------------------
 595 /* */
 596 unsigned long debStatusIndex::Size() const
 597 {
 598    struct stat S;
 599    if (stat(File.c_str(),&S) != 0)
 600       return 0;
 601    return S.st_size;
 602 }
 603                                                                         /*}}}*/
 604 // StatusIndex::Merge - Load the index file into a cache                /*{{{*/
 605 // ---------------------------------------------------------------------
 606 /* */
 607 bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
 608 {
 609    FileFd Pkg(File,FileFd::ReadOnly, FileFd::Extension);
 610    if (_error->PendingError() == true)
 611       return false;
 612    debListParser Parser(&Pkg);
 613    if (_error->PendingError() == true)
 614       return false;
 615
 616    if (Prog != NULL)
 617       Prog->SubProgress(0,File);
 618    if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false)
 619       return _error->Error("Problem with SelectFile %s",File.c_str());
 620
 621    // Store the IMS information
 622    pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
 623    CFile->Size = Pkg.FileSize();
 624    CFile->mtime = Pkg.ModificationTime();
 625    map_stringitem_t const storage = Gen.StoreString(pkgCacheGenerator::MIXED, "now");
 626    CFile->Archive = storage;
 627
 628    if (Gen.MergeList(Parser) == false)
 629       return _error->Error("Problem with MergeList %s",File.c_str());
 630    return true;
 631 }
 632                                                                         /*}}}*/
 633 // StatusIndex::FindInCache - Find this index                           /*{{{*/
 634 // ---------------------------------------------------------------------
 635 /* */
 636 pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
 637 {
 638    pkgCache::PkgFileIterator File = Cache.FileBegin();
 639    for (; File.end() == false; ++File)
 640    {
 641       if (this->File != File.FileName())
 642          continue;
 643
 644       struct stat St;
 645       if (stat(File.FileName(),&St) != 0)
 646       {
 647          if (_config->FindB("Debug::pkgCacheGen", false))
 648             std::clog << "StatusIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
 649          return pkgCache::PkgFileIterator(Cache);
 650       }
 651       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 652       {
 653          if (_config->FindB("Debug::pkgCacheGen", false))
 654             std::clog << "StatusIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
 655                         << ") or mtime (" << St.st_mtime << " <> " << File->mtime
 656                         << ") doesn't match for " << File.FileName() << std::endl;
 657          return pkgCache::PkgFileIterator(Cache);
 658       }
 659       return File;
 660    }
 661    return File;
 662 }
 663                                                                         /*}}}*/
 664 // StatusIndex::Exists - Check if the index is available                /*{{{*/
 665 // ---------------------------------------------------------------------
 666 /* */
 667 APT_CONST bool debStatusIndex::Exists() const
 668 {
 669    // Abort if the file does not exist.
 670    return true;
 671 }
 672                                                                         /*}}}*/
 673
 674 // debDebPkgFile - Single .deb file                                     /*{{{*/
 675 // ---------------------------------------------------------------------
 676 debDebPkgFileIndex::debDebPkgFileIndex(std::string DebFile)
 677    : pkgIndexFile(true), DebFile(DebFile)
 678 {
 679    DebFileFullPath = flAbsPath(DebFile);
 680 }
 681
 682 std::string debDebPkgFileIndex::ArchiveURI(std::string /*File*/) const
 683 {
 684    return "file:" + DebFileFullPath;
 685 }
 686
 687 bool debDebPkgFileIndex::Exists() const
 688 {
 689    return FileExists(DebFile);
 690 }
 691 bool debDebPkgFileIndex::Merge(pkgCacheGenerator& Gen, OpProgress* Prog) const
 692 {
 693    if(Prog)
 694       Prog->SubProgress(0, "Reading deb file");
 695
 696    // get the control data out of the deb file vid dpkg -I
 697    // ... can I haz libdpkg?
 698    Configuration::Item const *Opts = _config->Tree("DPkg::Options");
 699    std::string dpkg = _config->Find("Dir::Bin::dpkg","dpkg");
 700    std::vector<const char *> Args;
 701    Args.push_back(dpkg.c_str());
 702    if (Opts != 0)
 703    {
 704       Opts = Opts->Child;
 705       for (; Opts != 0; Opts = Opts->Next)
 706       {
 707          if (Opts->Value.empty() == true)
 708             continue;
 709          Args.push_back(Opts->Value.c_str());
 710       }
 711    }
 712    Args.push_back("-I");
 713    Args.push_back(DebFile.c_str());
 714    Args.push_back("control");
 715    Args.push_back(NULL);
 716    FileFd PipeFd;
 717    pid_t Child;
 718    if(Popen((const char**)&Args[0], PipeFd, Child, FileFd::ReadOnly) == false)
 719       return _error->Error("Popen failed");
 720    // FIXME: static buffer
 721    char buf[8*1024];
 722    unsigned long long n = 0;
 723    if(PipeFd.Read(buf, sizeof(buf)-1, &n) == false)
 724       return _error->Errno("read", "Failed to read dpkg pipe");
 725    ExecWait(Child, "Popen");
 726
 727    // now write the control data to a tempfile
 728    SPtr<FileFd> DebControl = GetTempFile("deb-file-" + flNotDir(DebFile));
 729    if(DebControl == NULL)
 730       return false;
 731    DebControl->Write(buf, n);
 732    // append size of the file
 733    FileFd Fd(DebFile, FileFd::ReadOnly);
 734    string Size;
 735    strprintf(Size, "Size: %llu\n", Fd.Size());
 736    DebControl->Write(Size.c_str(), Size.size());
 737    // and rewind for the listparser
 738    DebControl->Seek(0);
 739
 740    // and give it to the list parser
 741    debDebFileParser Parser(DebControl, DebFile);
 742    if(Gen.SelectFile(DebFile, "local", *this) == false)
 743       return _error->Error("Problem with SelectFile %s", DebFile.c_str());
 744
 745    pkgCache::PkgFileIterator File = Gen.GetCurFile();
 746    File->Size = DebControl->Size();
 747    File->mtime = DebControl->ModificationTime();
 748
 749    if (Gen.MergeList(Parser) == false)
 750       return _error->Error("Problem with MergeLister for %s", DebFile.c_str());
 751
 752    return true;
 753 }
 754 pkgCache::PkgFileIterator debDebPkgFileIndex::FindInCache(pkgCache &Cache) const
 755 {
 756    pkgCache::PkgFileIterator File = Cache.FileBegin();
 757    for (; File.end() == false; ++File)
 758    {
 759        if (File.FileName() == NULL || DebFile != File.FileName())
 760          continue;
 761
 762        return File;
 763    }
 764
 765    return File;
 766 }
 767 unsigned long debDebPkgFileIndex::Size() const
 768 {
 769    struct stat buf;
 770    if(stat(DebFile.c_str(), &buf) != 0)
 771       return 0;
 772    return buf.st_size;
 773 }
 774                                                                         /*}}}*/
 775
 776 // debDscFileIndex stuff
 777 debDscFileIndex::debDscFileIndex(std::string &DscFile)
 778    : pkgIndexFile(true), DscFile(DscFile)
 779 {
 780 }
 781
 782 bool debDscFileIndex::Exists() const
 783 {
 784    return FileExists(DscFile);
 785 }
 786
 787 unsigned long debDscFileIndex::Size() const
 788 {
 789    struct stat buf;
 790    if(stat(DscFile.c_str(), &buf) == 0)
 791       return buf.st_size;
 792    return 0;
 793 }
 794
 795 // DscFileIndex::CreateSrcParser - Get a parser for the .dsc file       /*{{{*/
 796 pkgSrcRecords::Parser *debDscFileIndex::CreateSrcParser() const
 797 {
 798    if (!FileExists(DscFile))
 799       return NULL;
 800
 801    return new debDscRecordParser(DscFile,this);
 802 }
 803                                                                         /*}}}*/
 804 // Index File types for Debian                                          /*{{{*/
 805 class debIFTypeSrc : public pkgIndexFile::Type
 806 {
 807    public:
 808
 809    debIFTypeSrc() {Label = "Debian Source Index";};
 810 };
 811 class debIFTypePkg : public pkgIndexFile::Type
 812 {
 813    public:
 814
 815    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 816    {
 817       return new debRecordParser(File.FileName(),*File.Cache());
 818    };
 819    debIFTypePkg() {Label = "Debian Package Index";};
 820 };
 821 class debIFTypeTrans : public debIFTypePkg
 822 {
 823    public:
 824    debIFTypeTrans() {Label = "Debian Translation Index";};
 825 };
 826 class debIFTypeStatus : public pkgIndexFile::Type
 827 {
 828    public:
 829
 830    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 831    {
 832       return new debRecordParser(File.FileName(),*File.Cache());
 833    };
 834    debIFTypeStatus() {Label = "Debian dpkg status file";};
 835 };
 836 class debIFTypeDebPkgFile : public pkgIndexFile::Type
 837 {
 838    public:
 839    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 840    {
 841       return new debDebFileRecordParser(File.FileName(),*File.Cache());
 842    };
 843    debIFTypeDebPkgFile() {Label = "deb Package file";};
 844 };
 845 class debIFTypeDscFile : public pkgIndexFile::Type
 846 {
 847    public:
 848    virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string DscFile) const
 849    {
 850       return new debDscRecordParser(DscFile, NULL);
 851    };
 852    debIFTypeDscFile() {Label = "dsc File Source Index";};
 853 };
 854 class debIFTypeDebianSourceDir : public pkgIndexFile::Type
 855 {
 856    public:
 857    virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string SourceDir) const
 858    {
 859       return new debDscRecordParser(SourceDir + string("/debian/control"), NULL);
 860    };
 861    debIFTypeDebianSourceDir() {Label = "debian/control File Source Index";};
 862 };
 863
 864 static debIFTypeSrc _apt_Src;
 865 static debIFTypePkg _apt_Pkg;
 866 static debIFTypeTrans _apt_Trans;
 867 static debIFTypeStatus _apt_Status;
 868 static debIFTypeDebPkgFile _apt_DebPkgFile;
 869 // file based pseudo indexes
 870 static debIFTypeDscFile _apt_DscFile;
 871 static debIFTypeDebianSourceDir _apt_DebianSourceDir;
 872
 873 const pkgIndexFile::Type *debSourcesIndex::GetType() const
 874 {
 875    return &_apt_Src;
 876 }
 877 const pkgIndexFile::Type *debPackagesIndex::GetType() const
 878 {
 879    return &_apt_Pkg;
 880 }
 881 const pkgIndexFile::Type *debTranslationsIndex::GetType() const
 882 {
 883    return &_apt_Trans;
 884 }
 885 const pkgIndexFile::Type *debStatusIndex::GetType() const
 886 {
 887    return &_apt_Status;
 888 }
 889 const pkgIndexFile::Type *debDebPkgFileIndex::GetType() const
 890 {
 891    return &_apt_DebPkgFile;
 892 }
 893 const pkgIndexFile::Type *debDscFileIndex::GetType() const
 894 {
 895    return &_apt_DscFile;
 896 }
 897 const pkgIndexFile::Type *debDebianSourceDirIndex::GetType() const
 898 {
 899    return &_apt_DebianSourceDir;
 900 }
 901                                                                         /*}}}*/
 902
 903 debStatusIndex::~debStatusIndex() {}
 904 debPackagesIndex::~debPackagesIndex() {}
 905 debTranslationsIndex::~debTranslationsIndex() {}
 906 debSourcesIndex::~debSourcesIndex() {}
 907
 908 debDebPkgFileIndex::~debDebPkgFileIndex() {}