apt-pkg/deb/debmetaindex.cc

   1 #include <config.h>
   2
   3 #include <apt-pkg/debmetaindex.h>
   4 #include <apt-pkg/debindexfile.h>
   5 #include <apt-pkg/strutl.h>
   6 #include <apt-pkg/fileutl.h>
   7 #include <apt-pkg/acquire-item.h>
   8 #include <apt-pkg/configuration.h>
   9 #include <apt-pkg/aptconfiguration.h>
  10 #include <apt-pkg/indexrecords.h>
  11 #include <apt-pkg/sourcelist.h>
  12 #include <apt-pkg/hashes.h>
  13 #include <apt-pkg/macros.h>
  14 #include <apt-pkg/metaindex.h>
  15
  16 #include <string.h>
  17 #include <map>
  18 #include <string>
  19 #include <utility>
  20 #include <vector>
  21 #include <set>
  22 #include <algorithm>
  23
  24 using namespace std;
  25
  26 string debReleaseIndex::Info(const char *Type, string const &Section, string const &Arch) const
  27 {
  28    string Info = ::URI::SiteOnly(URI) + ' ';
  29    if (Dist[Dist.size() - 1] == '/')
  30    {
  31       if (Dist != "/")
  32          Info += Dist;
  33    }
  34    else
  35    {
  36       Info += Dist + '/' + Section;
  37       if (Arch.empty() != true)
  38          Info += " " + Arch;
  39    }
  40    Info += " ";
  41    Info += Type;
  42    return Info;
  43 }
  44
  45 string debReleaseIndex::MetaIndexInfo(const char *Type) const
  46 {
  47    string Info = ::URI::SiteOnly(URI) + ' ';
  48    if (Dist[Dist.size() - 1] == '/')
  49    {
  50       if (Dist != "/")
  51          Info += Dist;
  52    }
  53    else
  54       Info += Dist;
  55    Info += " ";
  56    Info += Type;
  57    return Info;
  58 }
  59
  60 string debReleaseIndex::MetaIndexFile(const char *Type) const
  61 {
  62    return _config->FindDir("Dir::State::lists") +
  63       URItoFileName(MetaIndexURI(Type));
  64 }
  65
  66 string debReleaseIndex::MetaIndexURI(const char *Type) const
  67 {
  68    string Res;
  69
  70    if (Dist == "/")
  71       Res = URI;
  72    else if (Dist[Dist.size()-1] == '/')
  73       Res = URI + Dist;
  74    else
  75       Res = URI + "dists/" + Dist + "/";
  76
  77    Res += Type;
  78    return Res;
  79 }
  80
  81 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
  82 std::string debReleaseIndex::LocalFileName() const
  83 {
  84    // see if we have a InRelease file
  85    std::string PathInRelease =  MetaIndexFile("InRelease");
  86    if (FileExists(PathInRelease))
  87       return PathInRelease;
  88
  89    // and if not return the normal one
  90    if (FileExists(PathInRelease))
  91       return MetaIndexFile("Release");
  92
  93    return "";
  94 }
  95 #endif
  96
  97 string debReleaseIndex::IndexURISuffix(const char *Type, string const &Section, string const &Arch) const
  98 {
  99    string Res ="";
 100    if (Dist[Dist.size() - 1] != '/')
 101    {
 102       if (Arch == "native")
 103          Res += Section + "/binary-" + _config->Find("APT::Architecture") + '/';
 104       else
 105          Res += Section + "/binary-" + Arch + '/';
 106    }
 107    return Res + Type;
 108 }
 109
 110
 111 string debReleaseIndex::IndexURI(const char *Type, string const &Section, string const &Arch) const
 112 {
 113    if (Dist[Dist.size() - 1] == '/')
 114    {
 115       string Res;
 116       if (Dist != "/")
 117          Res = URI + Dist;
 118       else
 119          Res = URI;
 120       return Res + Type;
 121    }
 122    else
 123       return URI + "dists/" + Dist + '/' + IndexURISuffix(Type, Section, Arch);
 124  }
 125
 126 string debReleaseIndex::SourceIndexURISuffix(const char *Type, const string &Section) const
 127 {
 128    string Res ="";
 129    if (Dist[Dist.size() - 1] != '/')
 130       Res += Section + "/source/";
 131    return Res + Type;
 132 }
 133
 134 string debReleaseIndex::SourceIndexURI(const char *Type, const string &Section) const
 135 {
 136    string Res;
 137    if (Dist[Dist.size() - 1] == '/')
 138    {
 139       if (Dist != "/")
 140          Res = URI + Dist;
 141       else
 142          Res = URI;
 143       return Res + Type;
 144    }
 145    else
 146       return URI + "dists/" + Dist + "/" + SourceIndexURISuffix(Type, Section);
 147 }
 148
 149 string debReleaseIndex::TranslationIndexURISuffix(const char *Type, const string &Section) const
 150 {
 151    string Res ="";
 152    if (Dist[Dist.size() - 1] != '/')
 153       Res += Section + "/i18n/Translation-";
 154    return Res + Type;
 155 }
 156
 157 string debReleaseIndex::TranslationIndexURI(const char *Type, const string &Section) const
 158 {
 159    string Res;
 160    if (Dist[Dist.size() - 1] == '/')
 161    {
 162       if (Dist != "/")
 163          Res = URI + Dist;
 164       else
 165          Res = URI;
 166       return Res + Type;
 167    }
 168    else
 169       return URI + "dists/" + Dist + "/" + TranslationIndexURISuffix(Type, Section);
 170 }
 171
 172 debReleaseIndex::debReleaseIndex(string const &URI, string const &Dist) :
 173                                         metaIndex(URI, Dist, "deb"), Trusted(CHECK_TRUST)
 174 {}
 175
 176 debReleaseIndex::debReleaseIndex(string const &URI, string const &Dist, bool const Trusted) :
 177                                         metaIndex(URI, Dist, "deb") {
 178         SetTrusted(Trusted);
 179 }
 180
 181 debReleaseIndex::~debReleaseIndex() {
 182         for (map<string, vector<debSectionEntry const*> >::const_iterator A = ArchEntries.begin();
 183              A != ArchEntries.end(); ++A)
 184                 for (vector<const debSectionEntry *>::const_iterator S = A->second.begin();
 185                      S != A->second.end(); ++S)
 186                         delete *S;
 187 }
 188
 189 vector <IndexTarget *>* debReleaseIndex::ComputeIndexTargets() const {
 190         vector <IndexTarget *>* IndexTargets = new vector <IndexTarget *>;
 191
 192         map<string, vector<debSectionEntry const*> >::const_iterator const src = ArchEntries.find("source");
 193         if (src != ArchEntries.end()) {
 194                 vector<debSectionEntry const*> const SectionEntries = src->second;
 195                 for (vector<debSectionEntry const*>::const_iterator I = SectionEntries.begin();
 196                      I != SectionEntries.end(); ++I) {
 197                         IndexTarget * Target = new IndexTarget();
 198                         Target->ShortDesc = "Sources";
 199                         Target->MetaKey = SourceIndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section);
 200                         Target->URI = SourceIndexURI(Target->ShortDesc.c_str(), (*I)->Section);
 201                         Target->Description = Info (Target->ShortDesc.c_str(), (*I)->Section);
 202                         IndexTargets->push_back (Target);
 203                 }
 204         }
 205
 206         // Only source release
 207         if (IndexTargets->empty() == false && ArchEntries.size() == 1)
 208                 return IndexTargets;
 209
 210         std::set<std::string> sections;
 211         for (map<string, vector<debSectionEntry const*> >::const_iterator a = ArchEntries.begin();
 212              a != ArchEntries.end(); ++a) {
 213                 if (a->first == "source")
 214                         continue;
 215                 for (vector <const debSectionEntry *>::const_iterator I = a->second.begin();
 216                      I != a->second.end(); ++I) {
 217                         IndexTarget * Target = new IndexTarget();
 218                         Target->ShortDesc = "Packages";
 219                         Target->MetaKey = IndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section, a->first);
 220                         Target->URI = IndexURI(Target->ShortDesc.c_str(), (*I)->Section, a->first);
 221                         Target->Description = Info (Target->ShortDesc.c_str(), (*I)->Section, a->first);
 222                         IndexTargets->push_back (Target);
 223                         sections.insert((*I)->Section);
 224                 }
 225         }
 226
 227         std::vector<std::string> lang = APT::Configuration::getLanguages(true);
 228         std::vector<std::string>::iterator lend = std::remove(lang.begin(), lang.end(), "none");
 229         if (lend != lang.end())
 230                 lang.erase(lend);
 231
 232         if (lang.empty() == true)
 233                 return IndexTargets;
 234
 235         // get the Translation-* files, later we will skip download of non-existent if we have an index
 236         for (std::set<std::string>::const_iterator s = sections.begin();
 237              s != sections.end(); ++s) {
 238                 for (std::vector<std::string>::const_iterator l = lang.begin();
 239                      l != lang.end(); ++l) {
 240                         IndexTarget * Target = new OptionalIndexTarget();
 241                         Target->ShortDesc = "Translation-" + *l;
 242                         Target->MetaKey = TranslationIndexURISuffix(l->c_str(), *s);
 243                         Target->URI = TranslationIndexURI(l->c_str(), *s);
 244                         Target->Description = Info (Target->ShortDesc.c_str(), *s);
 245                         IndexTargets->push_back(Target);
 246                 }
 247         }
 248
 249         return IndexTargets;
 250 }
 251                                                                         /*}}}*/
 252 bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool const &GetAll) const
 253 {
 254    bool const tryInRelease = _config->FindB("Acquire::TryInRelease", true);
 255
 256    // special case for --print-uris
 257    if (GetAll) {
 258       vector <IndexTarget *> *targets = ComputeIndexTargets();
 259       for (vector <IndexTarget*>::const_iterator Target = targets->begin(); Target != targets->end(); ++Target) {
 260          new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
 261                          (*Target)->ShortDesc, HashStringList());
 262       }
 263       delete targets;
 264
 265       // this is normally created in pkgAcqMetaSig, but if we run
 266       // in --print-uris mode, we add it here
 267       if (tryInRelease == false)
 268          new pkgAcqMetaIndex(Owner, 0,
 269                              MetaIndexURI("Release"),
 270                              MetaIndexInfo("Release"), "Release",
 271                              MetaIndexURI("Release.gpg"), MetaIndexInfo("Release.gpg"), "Release.gpg",
 272                              ComputeIndexTargets(),
 273                              new indexRecords (Dist));
 274    }
 275
 276    if (tryInRelease == true)
 277       new pkgAcqMetaClearSig(Owner,
 278             MetaIndexURI("InRelease"), MetaIndexInfo("InRelease"), "InRelease",
 279             MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release",
 280             MetaIndexURI("Release.gpg"), MetaIndexInfo("Release.gpg"), "Release.gpg",
 281             ComputeIndexTargets(),
 282             new indexRecords (Dist));
 283    else
 284       new pkgAcqMetaIndex(Owner, 0,
 285           MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release",
 286           MetaIndexURI("Release.gpg"), MetaIndexInfo("Release.gpg"), "Release.gpg",
 287           ComputeIndexTargets(),
 288           new indexRecords (Dist));
 289
 290    return true;
 291 }
 292
 293 void debReleaseIndex::SetTrusted(bool const Trusted)
 294 {
 295         if (Trusted == true)
 296                 this->Trusted = ALWAYS_TRUSTED;
 297         else
 298                 this->Trusted = NEVER_TRUSTED;
 299 }
 300
 301 bool debReleaseIndex::IsTrusted() const
 302 {
 303    if (Trusted == ALWAYS_TRUSTED)
 304       return true;
 305    else if (Trusted == NEVER_TRUSTED)
 306       return false;
 307
 308
 309    if(_config->FindB("APT::Authentication::TrustCDROM", false))
 310       if(URI.substr(0,strlen("cdrom:")) == "cdrom:")
 311          return true;
 312
 313    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
 314       URItoFileName(MetaIndexURI("Release")) + ".gpg";
 315
 316    if (FileExists(VerifiedSigFile))
 317       return true;
 318
 319    VerifiedSigFile = _config->FindDir("Dir::State::lists") +
 320       URItoFileName(MetaIndexURI("InRelease"));
 321
 322    return FileExists(VerifiedSigFile);
 323 }
 324
 325 vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles() {
 326         if (Indexes != NULL)
 327                 return Indexes;
 328
 329         Indexes = new vector <pkgIndexFile*>;
 330         map<string, vector<debSectionEntry const*> >::const_iterator const src = ArchEntries.find("source");
 331         if (src != ArchEntries.end()) {
 332                 vector<debSectionEntry const*> const SectionEntries = src->second;
 333                 for (vector<debSectionEntry const*>::const_iterator I = SectionEntries.begin();
 334                      I != SectionEntries.end(); ++I)
 335                         Indexes->push_back(new debSourcesIndex (URI, Dist, (*I)->Section, IsTrusted()));
 336         }
 337
 338         // Only source release
 339         if (Indexes->empty() == false && ArchEntries.size() == 1)
 340                 return Indexes;
 341
 342         std::vector<std::string> const lang = APT::Configuration::getLanguages(true);
 343         map<string, set<string> > sections;
 344         for (map<string, vector<debSectionEntry const*> >::const_iterator a = ArchEntries.begin();
 345              a != ArchEntries.end(); ++a) {
 346                 if (a->first == "source")
 347                         continue;
 348                 for (vector<debSectionEntry const*>::const_iterator I = a->second.begin();
 349                      I != a->second.end(); ++I) {
 350                         Indexes->push_back(new debPackagesIndex (URI, Dist, (*I)->Section, IsTrusted(), a->first));
 351                         sections[(*I)->Section].insert(lang.begin(), lang.end());
 352                 }
 353         }
 354
 355         for (map<string, set<string> >::const_iterator s = sections.begin();
 356              s != sections.end(); ++s)
 357                 for (set<string>::const_iterator l = s->second.begin();
 358                      l != s->second.end(); ++l) {
 359                         if (*l == "none") continue;
 360                         Indexes->push_back(new debTranslationsIndex(URI,Dist,s->first,(*l).c_str()));
 361                 }
 362
 363         return Indexes;
 364 }
 365
 366 void debReleaseIndex::PushSectionEntry(vector<string> const &Archs, const debSectionEntry *Entry) {
 367         for (vector<string>::const_iterator a = Archs.begin();
 368              a != Archs.end(); ++a)
 369                 ArchEntries[*a].push_back(new debSectionEntry(Entry->Section, Entry->IsSrc));
 370         delete Entry;
 371 }
 372
 373 void debReleaseIndex::PushSectionEntry(string const &Arch, const debSectionEntry *Entry) {
 374         ArchEntries[Arch].push_back(Entry);
 375 }
 376
 377 void debReleaseIndex::PushSectionEntry(const debSectionEntry *Entry) {
 378         if (Entry->IsSrc == true)
 379                 PushSectionEntry("source", Entry);
 380         else {
 381                 for (map<string, vector<const debSectionEntry *> >::iterator a = ArchEntries.begin();
 382                      a != ArchEntries.end(); ++a) {
 383                         a->second.push_back(Entry);
 384                 }
 385         }
 386 }
 387
 388 debReleaseIndex::debSectionEntry::debSectionEntry (string const &Section,
 389                 bool const &IsSrc): Section(Section), IsSrc(IsSrc)
 390 {}
 391
 392 class debSLTypeDebian : public pkgSourceList::Type
 393 {
 394    protected:
 395
 396    bool CreateItemInternal(vector<metaIndex *> &List, string const &URI,
 397                            string const &Dist, string const &Section,
 398                            bool const &IsSrc, map<string, string> const &Options) const
 399    {
 400       // parse arch=, arch+= and arch-= settings
 401       map<string, string>::const_iterator arch = Options.find("arch");
 402       vector<string> Archs =
 403                 (arch != Options.end()) ? VectorizeString(arch->second, ',') :
 404                                 APT::Configuration::getArchitectures();
 405       if ((arch = Options.find("arch+")) != Options.end())
 406       {
 407          std::vector<std::string> const plusArch = VectorizeString(arch->second, ',');
 408          for (std::vector<std::string>::const_iterator plus = plusArch.begin(); plus != plusArch.end(); ++plus)
 409             if (std::find(Archs.begin(), Archs.end(), *plus) == Archs.end())
 410                Archs.push_back(*plus);
 411       }
 412       if ((arch = Options.find("arch-")) != Options.end())
 413       {
 414          std::vector<std::string> const minusArch = VectorizeString(arch->second, ',');
 415          for (std::vector<std::string>::const_iterator minus = minusArch.begin(); minus != minusArch.end(); ++minus)
 416          {
 417             std::vector<std::string>::iterator kill = std::find(Archs.begin(), Archs.end(), *minus);
 418             if (kill != Archs.end())
 419                Archs.erase(kill);
 420          }
 421       }
 422
 423       map<string, string>::const_iterator const trusted = Options.find("trusted");
 424
 425       for (vector<metaIndex *>::const_iterator I = List.begin();
 426            I != List.end(); ++I)
 427       {
 428          // We only worry about debian entries here
 429          if (strcmp((*I)->GetType(), "deb") != 0)
 430             continue;
 431
 432          debReleaseIndex *Deb = (debReleaseIndex *) (*I);
 433          if (trusted != Options.end())
 434             Deb->SetTrusted(StringToBool(trusted->second, false));
 435
 436          /* This check insures that there will be only one Release file
 437             queued for all the Packages files and Sources files it
 438             corresponds to. */
 439          if (Deb->GetURI() == URI && Deb->GetDist() == Dist)
 440          {
 441             if (IsSrc == true)
 442                Deb->PushSectionEntry("source", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 443             else
 444             {
 445                if (Dist[Dist.size() - 1] == '/')
 446                   Deb->PushSectionEntry("any", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 447                else
 448                   Deb->PushSectionEntry(Archs, new debReleaseIndex::debSectionEntry(Section, IsSrc));
 449             }
 450             return true;
 451          }
 452       }
 453
 454       // No currently created Release file indexes this entry, so we create a new one.
 455       debReleaseIndex *Deb;
 456       if (trusted != Options.end())
 457          Deb = new debReleaseIndex(URI, Dist, StringToBool(trusted->second, false));
 458       else
 459          Deb = new debReleaseIndex(URI, Dist);
 460
 461       if (IsSrc == true)
 462          Deb->PushSectionEntry ("source", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 463       else
 464       {
 465          if (Dist[Dist.size() - 1] == '/')
 466             Deb->PushSectionEntry ("any", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 467          else
 468             Deb->PushSectionEntry (Archs, new debReleaseIndex::debSectionEntry(Section, IsSrc));
 469       }
 470       List.push_back(Deb);
 471       return true;
 472    }
 473 };
 474
 475 debDebFileMetaIndex::debDebFileMetaIndex(std::string const &DebFile)
 476    : metaIndex(DebFile, "local-uri", "deb-dist"), DebFile(DebFile)
 477 {
 478    DebIndex = new debDebPkgFileIndex(DebFile);
 479    Indexes = new vector<pkgIndexFile *>();
 480    Indexes->push_back(DebIndex);
 481 }
 482
 483
 484 class debSLTypeDeb : public debSLTypeDebian
 485 {
 486    public:
 487
 488    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 489                    string const &Dist, string const &Section,
 490                    std::map<string, string> const &Options) const
 491    {
 492       return CreateItemInternal(List, URI, Dist, Section, false, Options);
 493    }
 494
 495    debSLTypeDeb()
 496    {
 497       Name = "deb";
 498       Label = "Standard Debian binary tree";
 499    }
 500 };
 501
 502 class debSLTypeDebSrc : public debSLTypeDebian
 503 {
 504    public:
 505
 506    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 507                    string const &Dist, string const &Section,
 508                    std::map<string, string> const &Options) const
 509    {
 510       return CreateItemInternal(List, URI, Dist, Section, true, Options);
 511    }
 512
 513    debSLTypeDebSrc()
 514    {
 515       Name = "deb-src";
 516       Label = "Standard Debian source tree";
 517    }
 518 };
 519
 520 class debSLTypeDebFile : public pkgSourceList::Type
 521 {
 522    public:
 523
 524    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 525                    string const &/*Dist*/, string const &/*Section*/,
 526                    std::map<string, string> const &/*Options*/) const
 527    {
 528       metaIndex *mi = new debDebFileMetaIndex(URI);
 529       List.push_back(mi);
 530       return true;
 531    }
 532
 533    debSLTypeDebFile()
 534    {
 535       Name = "deb-file";
 536       Label = "Debian Deb File";
 537    }
 538 };
 539 debSLTypeDeb _apt_DebType;
 540 debSLTypeDebSrc _apt_DebSrcType;
 541 debSLTypeDebFile _apt_DebFileType;