apt-pkg/deb/debmetaindex.cc

   1 // ijones, walters
   2
   3 #include <apt-pkg/debmetaindex.h>
   4 #include <apt-pkg/debindexfile.h>
   5 #include <apt-pkg/strutl.h>
   6 #include <apt-pkg/acquire-item.h>
   7 #include <apt-pkg/configuration.h>
   8 #include <apt-pkg/aptconfiguration.h>
   9 #include <apt-pkg/error.h>
  10
  11 #include <set>
  12
  13 using namespace std;
  14
  15 string debReleaseIndex::Info(const char *Type, string const &Section, string const &Arch) const
  16 {
  17    string Info = ::URI::SiteOnly(URI) + ' ';
  18    if (Dist[Dist.size() - 1] == '/')
  19    {
  20       if (Dist != "/")
  21          Info += Dist;
  22    }
  23    else
  24    {
  25       Info += Dist + '/' + Section;
  26       if (Arch.empty() == true)
  27          Info += " " + Arch;
  28    }
  29    Info += " ";
  30    Info += Type;
  31    return Info;
  32 }
  33
  34 string debReleaseIndex::MetaIndexInfo(const char *Type) const
  35 {
  36    string Info = ::URI::SiteOnly(URI) + ' ';
  37    if (Dist[Dist.size() - 1] == '/')
  38    {
  39       if (Dist != "/")
  40          Info += Dist;
  41    }
  42    else
  43       Info += Dist;
  44    Info += " ";
  45    Info += Type;
  46    return Info;
  47 }
  48
  49 string debReleaseIndex::MetaIndexFile(const char *Type) const
  50 {
  51    return _config->FindDir("Dir::State::lists") +
  52       URItoFileName(MetaIndexURI(Type));
  53 }
  54
  55 string debReleaseIndex::MetaIndexURI(const char *Type) const
  56 {
  57    string Res;
  58
  59    if (Dist == "/")
  60       Res = URI;
  61    else if (Dist[Dist.size()-1] == '/')
  62       Res = URI + Dist;
  63    else
  64       Res = URI + "dists/" + Dist + "/";
  65
  66    Res += Type;
  67    return Res;
  68 }
  69
  70 string debReleaseIndex::IndexURISuffix(const char *Type, string const &Section, string const &Arch) const
  71 {
  72    string Res ="";
  73    if (Dist[Dist.size() - 1] != '/')
  74    {
  75       if (Arch == "native")
  76          Res += Section + "/binary-" + _config->Find("APT::Architecture") + '/';
  77       else
  78          Res += Section + "/binary-" + Arch + '/';
  79    }
  80    return Res + Type;
  81 }
  82
  83
  84 string debReleaseIndex::IndexURI(const char *Type, string const &Section, string const &Arch) const
  85 {
  86    if (Dist[Dist.size() - 1] == '/')
  87    {
  88       string Res;
  89       if (Dist != "/")
  90          Res = URI + Dist;
  91       else
  92          Res = URI;
  93       return Res + Type;
  94    }
  95    else
  96       return URI + "dists/" + Dist + '/' + IndexURISuffix(Type, Section, Arch);
  97  }
  98
  99 string debReleaseIndex::SourceIndexURISuffix(const char *Type, const string &Section) const
 100 {
 101    string Res ="";
 102    if (Dist[Dist.size() - 1] != '/')
 103       Res += Section + "/source/";
 104    return Res + Type;
 105 }
 106
 107 string debReleaseIndex::SourceIndexURI(const char *Type, const string &Section) const
 108 {
 109    string Res;
 110    if (Dist[Dist.size() - 1] == '/')
 111    {
 112       if (Dist != "/")
 113          Res = URI + Dist;
 114       else
 115          Res = URI;
 116       return Res + Type;
 117    }
 118    else
 119       return URI + "dists/" + Dist + "/" + SourceIndexURISuffix(Type, Section);
 120 }
 121
 122 debReleaseIndex::debReleaseIndex(string const &URI, string const &Dist) {
 123         this->URI = URI;
 124         this->Dist = Dist;
 125         this->Indexes = NULL;
 126         this->Type = "deb";
 127 }
 128
 129 debReleaseIndex::~debReleaseIndex() {
 130         for (map<string, vector<debSectionEntry const*> >::const_iterator A = ArchEntries.begin();
 131              A != ArchEntries.end(); ++A)
 132                 for (vector<const debSectionEntry *>::const_iterator S = A->second.begin();
 133                      S != A->second.end(); ++S)
 134                         delete *S;
 135 }
 136
 137 vector <struct IndexTarget *>* debReleaseIndex::ComputeIndexTargets() const {
 138         vector <struct IndexTarget *>* IndexTargets = new vector <IndexTarget *>;
 139
 140         map<string, vector<debSectionEntry const*> >::const_iterator const src = ArchEntries.find("source");
 141         if (src != ArchEntries.end()) {
 142                 vector<debSectionEntry const*> const SectionEntries = src->second;
 143                 for (vector<debSectionEntry const*>::const_iterator I = SectionEntries.begin();
 144                      I != SectionEntries.end(); ++I) {
 145                         IndexTarget * Target = new IndexTarget();
 146                         Target->ShortDesc = "Sources";
 147                         Target->MetaKey = SourceIndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section);
 148                         Target->URI = SourceIndexURI(Target->ShortDesc.c_str(), (*I)->Section);
 149                         Target->Description = Info (Target->ShortDesc.c_str(), (*I)->Section);
 150                         IndexTargets->push_back (Target);
 151                 }
 152         }
 153
 154         // Only source release
 155         if (IndexTargets->empty() == false && ArchEntries.size() == 1)
 156                 return IndexTargets;
 157
 158         for (map<string, vector<debSectionEntry const*> >::const_iterator a = ArchEntries.begin();
 159              a != ArchEntries.end(); ++a) {
 160                 if (a->first == "source")
 161                         continue;
 162                 for (vector <const debSectionEntry *>::const_iterator I = a->second.begin();
 163                      I != a->second.end(); ++I) {
 164                         IndexTarget * Target = new IndexTarget();
 165                         Target->ShortDesc = "Packages";
 166                         Target->MetaKey = IndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section, a->first);
 167                         Target->URI = IndexURI(Target->ShortDesc.c_str(), (*I)->Section, a->first);
 168                         Target->Description = Info (Target->ShortDesc.c_str(), (*I)->Section, a->first);
 169                         IndexTargets->push_back (Target);
 170                 }
 171         }
 172
 173         return IndexTargets;
 174 }
 175                                                                         /*}}}*/
 176 bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool const &GetAll) const
 177 {
 178    // special case for --print-uris
 179    if (GetAll) {
 180       vector <struct IndexTarget *> *targets = ComputeIndexTargets();
 181       for (vector <struct IndexTarget*>::const_iterator Target = targets->begin(); Target != targets->end(); Target++) {
 182          new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
 183                          (*Target)->ShortDesc, HashString());
 184       }
 185       // this is normally created in pkgAcqMetaSig, but if we run
 186       // in --print-uris mode, we add it here
 187       new pkgAcqMetaIndex(Owner, MetaIndexURI("Release"),
 188                      MetaIndexInfo("Release"), "Release",
 189                      MetaIndexURI("Release.gpg"),
 190                      ComputeIndexTargets(),
 191                      new indexRecords (Dist));
 192
 193    }
 194
 195    new pkgAcqMetaSig(Owner, MetaIndexURI("Release.gpg"),
 196                      MetaIndexInfo("Release.gpg"), "Release.gpg",
 197                      MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release",
 198                      ComputeIndexTargets(),
 199                      new indexRecords (Dist));
 200
 201         // Queue the translations
 202         std::vector<std::string> const lang = APT::Configuration::getLanguages(true);
 203         map<string, set<string> > sections;
 204         for (map<string, vector<debSectionEntry const*> >::const_iterator a = ArchEntries.begin();
 205              a != ArchEntries.end(); ++a) {
 206                 if (a->first == "source")
 207                         continue;
 208                 for (vector<debSectionEntry const*>::const_iterator I = a->second.begin();
 209                      I != a->second.end(); I++)
 210                         sections[(*I)->Section].insert(lang.begin(), lang.end());
 211         }
 212
 213         for (map<string, set<string> >::const_iterator s = sections.begin();
 214              s != sections.end(); ++s)
 215                 for (set<string>::const_iterator l = s->second.begin();
 216                      l != s->second.end(); l++) {
 217                         debTranslationsIndex i = debTranslationsIndex(URI,Dist,s->first,(*l).c_str());
 218                         i.GetIndexes(Owner);
 219                 }
 220
 221         return true;
 222 }
 223
 224 bool debReleaseIndex::IsTrusted() const
 225 {
 226    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
 227       URItoFileName(MetaIndexURI("Release")) + ".gpg";
 228
 229    if(_config->FindB("APT::Authentication::TrustCDROM", false))
 230       if(URI.substr(0,strlen("cdrom:")) == "cdrom:")
 231          return true;
 232
 233    if (FileExists(VerifiedSigFile))
 234       return true;
 235    return false;
 236 }
 237
 238 vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles() {
 239         if (Indexes != NULL)
 240                 return Indexes;
 241
 242         Indexes = new vector <pkgIndexFile*>;
 243         map<string, vector<debSectionEntry const*> >::const_iterator const src = ArchEntries.find("source");
 244         if (src != ArchEntries.end()) {
 245                 vector<debSectionEntry const*> const SectionEntries = src->second;
 246                 for (vector<debSectionEntry const*>::const_iterator I = SectionEntries.begin();
 247                      I != SectionEntries.end(); I++)
 248                         Indexes->push_back(new debSourcesIndex (URI, Dist, (*I)->Section, IsTrusted()));
 249         }
 250
 251         // Only source release
 252         if (Indexes->empty() == false && ArchEntries.size() == 1)
 253                 return Indexes;
 254
 255         std::vector<std::string> const lang = APT::Configuration::getLanguages(true);
 256         map<string, set<string> > sections;
 257         for (map<string, vector<debSectionEntry const*> >::const_iterator a = ArchEntries.begin();
 258              a != ArchEntries.end(); ++a) {
 259                 if (a->first == "source")
 260                         continue;
 261                 for (vector<debSectionEntry const*>::const_iterator I = a->second.begin();
 262                      I != a->second.end(); I++) {
 263                         Indexes->push_back(new debPackagesIndex (URI, Dist, (*I)->Section, IsTrusted(), a->first));
 264                         sections[(*I)->Section].insert(lang.begin(), lang.end());
 265                 }
 266         }
 267
 268         for (map<string, set<string> >::const_iterator s = sections.begin();
 269              s != sections.end(); ++s)
 270                 for (set<string>::const_iterator l = s->second.begin();
 271                      l != s->second.end(); l++)
 272                         Indexes->push_back(new debTranslationsIndex(URI,Dist,s->first,(*l).c_str()));
 273
 274         return Indexes;
 275 }
 276
 277 void debReleaseIndex::PushSectionEntry(vector<string> const &Archs, const debSectionEntry *Entry) {
 278         for (vector<string>::const_iterator a = Archs.begin();
 279              a != Archs.end(); ++a)
 280                 ArchEntries[*a].push_back(new debSectionEntry(Entry->Section, Entry->IsSrc));
 281         delete Entry;
 282 }
 283
 284 void debReleaseIndex::PushSectionEntry(string const &Arch, const debSectionEntry *Entry) {
 285         ArchEntries[Arch].push_back(Entry);
 286 }
 287
 288 void debReleaseIndex::PushSectionEntry(const debSectionEntry *Entry) {
 289         if (Entry->IsSrc == true)
 290                 PushSectionEntry("source", Entry);
 291         else {
 292                 for (map<string, vector<const debSectionEntry *> >::iterator a = ArchEntries.begin();
 293                      a != ArchEntries.end(); ++a) {
 294                         a->second.push_back(Entry);
 295                 }
 296         }
 297 }
 298
 299 debReleaseIndex::debSectionEntry::debSectionEntry (string const &Section,
 300                 bool const &IsSrc): Section(Section), IsSrc(IsSrc)
 301 {}
 302
 303 class debSLTypeDebian : public pkgSourceList::Type
 304 {
 305    protected:
 306
 307    bool CreateItemInternal(vector<metaIndex *> &List, string const &URI,
 308                            string const &Dist, string const &Section,
 309                            bool const &IsSrc, map<string, string> const &Options) const
 310    {
 311       map<string, string>::const_iterator const arch = Options.find("arch");
 312       vector<string> const Archs =
 313                 (arch != Options.end()) ? ExplodeString(arch->second) :
 314                                 APT::Configuration::getArchitectures();
 315
 316       for (vector<metaIndex *>::const_iterator I = List.begin();
 317            I != List.end(); I++)
 318       {
 319          // We only worry about debian entries here
 320          if (strcmp((*I)->GetType(), "deb") != 0)
 321             continue;
 322
 323          debReleaseIndex *Deb = (debReleaseIndex *) (*I);
 324          /* This check insures that there will be only one Release file
 325             queued for all the Packages files and Sources files it
 326             corresponds to. */
 327          if (Deb->GetURI() == URI && Deb->GetDist() == Dist)
 328          {
 329             if (IsSrc == true)
 330                Deb->PushSectionEntry("source", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 331             else
 332                Deb->PushSectionEntry(Archs, new debReleaseIndex::debSectionEntry(Section, IsSrc));
 333             return true;
 334          }
 335       }
 336       // No currently created Release file indexes this entry, so we create a new one.
 337       // XXX determine whether this release is trusted or not
 338       debReleaseIndex *Deb = new debReleaseIndex(URI, Dist);
 339       if (IsSrc == true)
 340          Deb->PushSectionEntry ("source", new debReleaseIndex::debSectionEntry(Section, IsSrc));
 341       else
 342          Deb->PushSectionEntry (Archs, new debReleaseIndex::debSectionEntry(Section, IsSrc));
 343       List.push_back(Deb);
 344       return true;
 345    }
 346 };
 347
 348 class debSLTypeDeb : public debSLTypeDebian
 349 {
 350    public:
 351
 352    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 353                    string const &Dist, string const &Section,
 354                    std::map<string, string> const &Options) const
 355    {
 356       return CreateItemInternal(List, URI, Dist, Section, false, Options);
 357    }
 358
 359    debSLTypeDeb()
 360    {
 361       Name = "deb";
 362       Label = "Standard Debian binary tree";
 363    }
 364 };
 365
 366 class debSLTypeDebSrc : public debSLTypeDebian
 367 {
 368    public:
 369
 370    bool CreateItem(vector<metaIndex *> &List, string const &URI,
 371                    string const &Dist, string const &Section,
 372                    std::map<string, string> const &Options) const
 373    {
 374       return CreateItemInternal(List, URI, Dist, Section, true, Options);
 375    }
 376
 377    debSLTypeDebSrc()
 378    {
 379       Name = "deb-src";
 380       Label = "Standard Debian source tree";
 381    }
 382 };
 383
 384 debSLTypeDeb _apt_DebType;
 385 debSLTypeDebSrc _apt_DebSrcType;