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::MetaIndexInfo(const char *Type) const
  27 {
  28    string Info = ::URI::ArchiveOnly(URI) + ' ';
  29    if (Dist[Dist.size() - 1] == '/')
  30    {
  31       if (Dist != "/")
  32          Info += Dist;
  33    }
  34    else
  35       Info += Dist;
  36    Info += " ";
  37    Info += Type;
  38    return Info;
  39 }
  40
  41 string debReleaseIndex::MetaIndexFile(const char *Type) const
  42 {
  43    return _config->FindDir("Dir::State::lists") +
  44       URItoFileName(MetaIndexURI(Type));
  45 }
  46
  47 string debReleaseIndex::MetaIndexURI(const char *Type) const
  48 {
  49    string Res;
  50
  51    if (Dist == "/")
  52       Res = URI;
  53    else if (Dist[Dist.size()-1] == '/')
  54       Res = URI + Dist;
  55    else
  56       Res = URI + "dists/" + Dist + "/";
  57
  58    Res += Type;
  59    return Res;
  60 }
  61
  62 std::string debReleaseIndex::LocalFileName() const
  63 {
  64    // see if we have a InRelease file
  65    std::string PathInRelease =  MetaIndexFile("InRelease");
  66    if (FileExists(PathInRelease))
  67       return PathInRelease;
  68
  69    // and if not return the normal one
  70    if (FileExists(PathInRelease))
  71       return MetaIndexFile("Release");
  72
  73    return "";
  74 }
  75
  76 debReleaseIndex::debReleaseIndex(string const &URI, string const &Dist) :
  77                                         metaIndex(URI, Dist, "deb"), Trusted(CHECK_TRUST)
  78 {}
  79
  80 debReleaseIndex::debReleaseIndex(string const &URI, string const &Dist, bool const Trusted) :
  81                                         metaIndex(URI, Dist, "deb") {
  82         SetTrusted(Trusted);
  83 }
  84
  85 debReleaseIndex::~debReleaseIndex() {
  86         for (map<string, vector<debSectionEntry const*> >::const_iterator A = ArchEntries.begin();
  87              A != ArchEntries.end(); ++A)
  88                 for (vector<const debSectionEntry *>::const_iterator S = A->second.begin();
  89                      S != A->second.end(); ++S)
  90                         delete *S;
  91 }
  92
  93 template<typename CallC>
  94 void foreachTarget(std::string const URI, std::string const Dist,
  95       std::map<std::string, std::vector<debReleaseIndex::debSectionEntry const *> > const &ArchEntries,
  96       CallC &Call)
  97 {
  98    bool const flatArchive = (Dist[Dist.length() - 1] == '/');
  99    std::string baseURI = URI;
 100    if (flatArchive)
 101    {
 102       if (Dist != "/")
 103          baseURI += Dist;
 104    }
 105    else
 106       baseURI += "dists/" + Dist + "/";
 107    std::string const Release = (Dist == "/") ? "" : Dist;
 108    std::string const Site = ::URI::ArchiveOnly(URI);
 109    std::vector<std::string> lang = APT::Configuration::getLanguages(true);
 110    if (lang.empty())
 111       lang.push_back("none");
 112    map<string, vector<debReleaseIndex::debSectionEntry const*> >::const_iterator const src = ArchEntries.find("source");
 113    if (src != ArchEntries.end())
 114    {
 115       std::vector<std::string> const targets = _config->FindVector("APT::Acquire::Targets::deb-src", "", true);
 116       for (std::vector<std::string>::const_iterator T = targets.begin(); T != targets.end(); ++T)
 117       {
 118 #define APT_T_CONFIG(X) _config->Find(std::string("APT::Acquire::Targets::deb-src::") + *T + "::" + (X))
 119          std::string const MetaKey = APT_T_CONFIG(flatArchive ? "flatMetaKey" : "MetaKey");
 120          std::string const ShortDesc = APT_T_CONFIG("ShortDescription");
 121          std::string const LongDesc = APT_T_CONFIG(flatArchive ? "flatDescription" : "Description");
 122          bool const IsOptional = _config->FindB(std::string("APT::Acquire::Targets::deb-src::") + *T + "::Optional", true);
 123 #undef APT_T_CONFIG
 124          if (MetaKey.empty())
 125             continue;
 126
 127          vector<debReleaseIndex::debSectionEntry const*> const SectionEntries = src->second;
 128          for (vector<debReleaseIndex::debSectionEntry const*>::const_iterator I = SectionEntries.begin();
 129                I != SectionEntries.end(); ++I)
 130          {
 131             for (vector<std::string>::const_iterator l = lang.begin(); l != lang.end(); ++l)
 132             {
 133                if (*l == "none" && MetaKey.find("$(LANGUAGE)") != std::string::npos)
 134                   continue;
 135
 136                std::map<std::string, std::string> Options;
 137                Options.insert(std::make_pair("SITE", Site));
 138                Options.insert(std::make_pair("RELEASE", Release));
 139                Options.insert(std::make_pair("COMPONENT", (*I)->Section));
 140                Options.insert(std::make_pair("LANGUAGE", *l));
 141                Options.insert(std::make_pair("ARCHITECTURE", "source"));
 142                Options.insert(std::make_pair("BASE_URI", baseURI));
 143                Options.insert(std::make_pair("REPO_URI", URI));
 144                Options.insert(std::make_pair("CREATED_BY", *T));
 145                Call(MetaKey, ShortDesc, LongDesc, IsOptional, Options);
 146
 147                if (MetaKey.find("$(LANGUAGE)") == std::string::npos)
 148                   break;
 149             }
 150
 151             if (MetaKey.find("$(COMPONENT)") == std::string::npos)
 152                break;
 153          }
 154       }
 155    }
 156
 157    std::vector<std::string> const targets = _config->FindVector("APT::Acquire::Targets::deb", "", true);
 158    for (std::vector<std::string>::const_iterator T = targets.begin(); T != targets.end(); ++T)
 159    {
 160 #define APT_T_CONFIG(X) _config->Find(std::string("APT::Acquire::Targets::deb::") + *T + "::" + (X))
 161       std::string const MetaKey = APT_T_CONFIG(flatArchive ? "flatMetaKey" : "MetaKey");
 162       std::string const ShortDesc = APT_T_CONFIG("ShortDescription");
 163       std::string const LongDesc = APT_T_CONFIG(flatArchive ? "flatDescription" : "Description");
 164       bool const IsOptional = _config->FindB(std::string("APT::Acquire::Targets::deb::") + *T + "::Optional", true);
 165 #undef APT_T_CONFIG
 166       if (MetaKey.empty())
 167          continue;
 168
 169       for (map<string, vector<debReleaseIndex::debSectionEntry const*> >::const_iterator a = ArchEntries.begin();
 170             a != ArchEntries.end(); ++a)
 171       {
 172          if (a->first == "source")
 173             continue;
 174
 175          for (vector <const debReleaseIndex::debSectionEntry *>::const_iterator I = a->second.begin();
 176                I != a->second.end(); ++I) {
 177
 178             for (vector<std::string>::const_iterator l = lang.begin(); l != lang.end(); ++l)
 179             {
 180                if (*l == "none" && MetaKey.find("$(LANGUAGE)") != std::string::npos)
 181                   continue;
 182
 183                std::map<std::string, std::string> Options;
 184                Options.insert(std::make_pair("SITE", Site));
 185                Options.insert(std::make_pair("RELEASE", Release));
 186                Options.insert(std::make_pair("COMPONENT", (*I)->Section));
 187                Options.insert(std::make_pair("LANGUAGE", *l));
 188                Options.insert(std::make_pair("ARCHITECTURE", a->first));
 189                Options.insert(std::make_pair("BASE_URI", baseURI));
 190                Options.insert(std::make_pair("REPO_URI", URI));
 191                Options.insert(std::make_pair("CREATED_BY", *T));
 192                Call(MetaKey, ShortDesc, LongDesc, IsOptional, Options);
 193
 194                if (MetaKey.find("$(LANGUAGE)") == std::string::npos)
 195                   break;
 196             }
 197
 198             if (MetaKey.find("$(COMPONENT)") == std::string::npos)
 199                break;
 200          }
 201
 202          if (MetaKey.find("$(ARCHITECTURE)") == std::string::npos)
 203             break;
 204       }
 205    }
 206 }
 207
 208
 209 struct ComputeIndexTargetsClass
 210 {
 211    vector <IndexTarget> IndexTargets;
 212
 213    void operator()(std::string MetaKey, std::string ShortDesc, std::string LongDesc,
 214          bool const IsOptional, std::map<std::string, std::string> Options)
 215    {
 216       for (std::map<std::string, std::string>::const_iterator O = Options.begin(); O != Options.end(); ++O)
 217       {
 218          MetaKey = SubstVar(MetaKey, std::string("$(") + O->first + ")", O->second);
 219          ShortDesc = SubstVar(ShortDesc, std::string("$(") + O->first + ")", O->second);
 220          LongDesc = SubstVar(LongDesc, std::string("$(") + O->first + ")", O->second);
 221       }
 222       IndexTarget Target(
 223             MetaKey,
 224             ShortDesc,
 225             LongDesc,
 226             Options.find("BASE_URI")->second + MetaKey,
 227             IsOptional,
 228             Options
 229             );
 230       IndexTargets.push_back(Target);
 231    }
 232 };
 233
 234 std::vector<IndexTarget> debReleaseIndex::GetIndexTargets() const
 235 {
 236    ComputeIndexTargetsClass comp;
 237    foreachTarget(URI, Dist, ArchEntries, comp);
 238    return comp.IndexTargets;
 239 }
 240
 241
 242                                                                         /*}}}*/
 243 bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool const &GetAll) const
 244 {
 245    indexRecords * const iR = new indexRecords(Dist);
 246    if (Trusted == ALWAYS_TRUSTED)
 247       iR->SetTrusted(true);
 248    else if (Trusted == NEVER_TRUSTED)
 249       iR->SetTrusted(false);
 250
 251    // special case for --print-uris
 252    std::vector<IndexTarget> const targets = GetIndexTargets();
 253 #define APT_TARGET(X) IndexTarget("", X, MetaIndexInfo(X), MetaIndexURI(X), false, std::map<std::string,std::string>())
 254    pkgAcqMetaBase * const TransactionManager = new pkgAcqMetaClearSig(Owner,
 255          APT_TARGET("InRelease"), APT_TARGET("Release"), APT_TARGET("Release.gpg"),
 256          targets, iR);
 257 #undef APT_TARGET
 258    if (GetAll)
 259    {
 260       for (std::vector<IndexTarget>::const_iterator Target = targets.begin(); Target != targets.end(); ++Target)
 261          new pkgAcqIndex(Owner, TransactionManager, *Target);
 262    }
 263
 264    return true;
 265 }
 266
 267 void debReleaseIndex::SetTrusted(bool const Trusted)
 268 {
 269         if (Trusted == true)
 270                 this->Trusted = ALWAYS_TRUSTED;
 271         else
 272                 this->Trusted = NEVER_TRUSTED;
 273 }
 274
 275 bool debReleaseIndex::IsTrusted() const
 276 {
 277    if (Trusted == ALWAYS_TRUSTED)
 278       return true;
 279    else if (Trusted == NEVER_TRUSTED)
 280       return false;
 281
 282
 283    if(_config->FindB("APT::Authentication::TrustCDROM", false))
 284       if(URI.substr(0,strlen("cdrom:")) == "cdrom:")
 285          return true;
 286
 287    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
 288       URItoFileName(MetaIndexURI("Release")) + ".gpg";
 289
 290    if (FileExists(VerifiedSigFile))
 291       return true;
 292
 293    VerifiedSigFile = _config->FindDir("Dir::State::lists") +
 294       URItoFileName(MetaIndexURI("InRelease"));
 295
 296    return FileExists(VerifiedSigFile);
 297 }
 298
 299 std::vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles()
 300 {
 301    if (Indexes != NULL)
 302       return Indexes;
 303
 304    Indexes = new std::vector<pkgIndexFile*>();
 305    std::vector<IndexTarget> const Targets = GetIndexTargets();
 306    bool const istrusted = IsTrusted();
 307    for (std::vector<IndexTarget>::const_iterator T = Targets.begin(); T != Targets.end(); ++T)
 308    {
 309       std::string const TargetName = T->Options.find("CREATED_BY")->second;
 310       if (TargetName == "Packages")
 311          Indexes->push_back(new debPackagesIndex(*T, istrusted));
 312       else if (TargetName == "Sources")
 313          Indexes->push_back(new debSourcesIndex(*T, istrusted));
 314       else if (TargetName == "Translations")
 315          Indexes->push_back(new debTranslationsIndex(*T));
 316    }
 317    return Indexes;
 318 }
 319
 320 void debReleaseIndex::PushSectionEntry(vector<string> const &Archs, const debSectionEntry *Entry) {
 321         for (vector<string>::const_iterator a = Archs.begin();
 322              a != Archs.end(); ++a)
 323                 ArchEntries[*a].push_back(new debSectionEntry(Entry->Section, Entry->IsSrc));
 324         delete Entry;
 325 }
 326
 327 void debReleaseIndex::PushSectionEntry(string const &Arch, const debSectionEntry *Entry) {
 328         ArchEntries[Arch].push_back(Entry);
 329 }
 330
 331 debReleaseIndex::debSectionEntry::debSectionEntry (string const &Section,
 332                 bool const &IsSrc): Section(Section), IsSrc(IsSrc)
 333 {}
 334
 335 class APT_HIDDEN debSLTypeDebian : public pkgSourceList::Type
 336 {
 337    protected:
 338
 339    bool CreateItemInternal(vector<metaIndex *> &List, string const &URI,
 340                            string const &Dist, string const &Section,
 341                            bool const &IsSrc, map<string, string> const &Options) const
 342    {
 343       // parse arch=, arch+= and arch-= settings
 344       map<string, string>::const_iterator arch = Options.find("arch");
 345       vector<string> Archs;
 346       if (arch != Options.end())
 347          Archs = VectorizeString(arch->second, ',');
 348       else
 349          Archs = APT::Configuration::getArchitectures();
 350
 351       if ((arch = Options.find("arch+")) != Options.end())
 352       {
 353          std::vector<std::string> const plusArch = VectorizeString(arch->second, ',');
 354          for (std::vector<std::string>::const_iterator plus = plusArch.begin(); plus != plusArch.end(); ++plus)
 355             if (std::find(Archs.begin(), Archs.end(), *plus) == Archs.end())
 356                Archs.push_back(*plus);
 357       }
 358       if ((arch = Options.find("arch-")) != Options.end())
 359       {
 360          std::vector<std::string> const minusArch = VectorizeString(arch->second, ',');
 361          for (std::vector<std::string>::const_iterator minus = minusArch.begin(); minus != minusArch.end(); ++minus)
 362          {
 363             std::vector<std::string>::iterator kill = std::find(Archs.begin(), Archs.end(), *minus);
 364             if (kill != Archs.end())
 365                Archs.erase(kill);
 366          }
 367       }
 368
 369       map<string, string>::const_iterator const trusted = Options.find("trusted");
 370
 371       debReleaseIndex *Deb = NULL;
 372       for (vector<metaIndex *>::const_iterator I = List.begin();
 373            I != List.end(); ++I)
 374       {
 375          // We only worry about debian entries here
 376          if (strcmp((*I)->GetType(), "deb") != 0)
 377             continue;
 378
 379          /* This check insures that there will be only one Release file
 380             queued for all the Packages files and Sources files it
 381             corresponds to. */
 382          if ((*I)->GetURI() == URI && (*I)->GetDist() == Dist)
 383          {
 384             Deb = dynamic_cast<debReleaseIndex*>(*I);
 385             if (Deb != NULL)
 386                break;
 387          }
 388       }
 389
 390       // No currently created Release file indexes this entry, so we create a new one.
 391       if (Deb == NULL)
 392       {
 393          Deb = new debReleaseIndex(URI, Dist);
 394          List.push_back(Deb);
 395       }
 396
 397       if (IsSrc == true)
 398          Deb->PushSectionEntry ("source", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 399       else
 400       {
 401          if (Dist[Dist.size() - 1] == '/')
 402             Deb->PushSectionEntry ("any", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 403          else
 404             Deb->PushSectionEntry (Archs, new debReleaseIndex::debSectionEntry(Section, IsSrc));
 405       }
 406
 407       if (trusted != Options.end())
 408          Deb->SetTrusted(StringToBool(trusted->second, false));
 409
 410       return true;
 411    }
 412 };
 413
 414 debDebFileMetaIndex::debDebFileMetaIndex(std::string const &DebFile)
 415    : metaIndex(DebFile, "local-uri", "deb-dist"), DebFile(DebFile)
 416 {
 417    DebIndex = new debDebPkgFileIndex(DebFile);
 418    Indexes = new vector<pkgIndexFile *>();
 419    Indexes->push_back(DebIndex);
 420 }
 421
 422
 423 class APT_HIDDEN debSLTypeDeb : public debSLTypeDebian
 424 {
 425    public:
 426
 427    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 428                    string const &Dist, string const &Section,
 429                    std::map<string, string> const &Options) const
 430    {
 431       return CreateItemInternal(List, URI, Dist, Section, false, Options);
 432    }
 433
 434    debSLTypeDeb()
 435    {
 436       Name = "deb";
 437       Label = "Standard Debian binary tree";
 438    }
 439 };
 440
 441 class APT_HIDDEN debSLTypeDebSrc : public debSLTypeDebian
 442 {
 443    public:
 444
 445    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 446                    string const &Dist, string const &Section,
 447                    std::map<string, string> const &Options) const
 448    {
 449       return CreateItemInternal(List, URI, Dist, Section, true, Options);
 450    }
 451
 452    debSLTypeDebSrc()
 453    {
 454       Name = "deb-src";
 455       Label = "Standard Debian source tree";
 456    }
 457 };
 458
 459 class APT_HIDDEN debSLTypeDebFile : public pkgSourceList::Type
 460 {
 461    public:
 462
 463    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 464                    string const &/*Dist*/, string const &/*Section*/,
 465                    std::map<string, string> const &/*Options*/) const
 466    {
 467       metaIndex *mi = new debDebFileMetaIndex(URI);
 468       List.push_back(mi);
 469       return true;
 470    }
 471
 472    debSLTypeDebFile()
 473    {
 474       Name = "deb-file";
 475       Label = "Debian Deb File";
 476    }
 477 };
 478
 479 APT_HIDDEN debSLTypeDeb _apt_DebType;
 480 APT_HIDDEN debSLTypeDebSrc _apt_DebSrcType;
 481 APT_HIDDEN debSLTypeDebFile _apt_DebFileType;