[apt.git] / apt-pkg / deb / debmetaindex.cc

// ijones, walters

#include <apt-pkg/debmetaindex.h>
#include <apt-pkg/debindexfile.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/acquire-item.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/error.h>

using namespace std;

string debReleaseIndex::Info(const char *Type, const string Section) const
{
   string Info = ::URI::SiteOnly(URI) + ' ';
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
         Info += Dist;
   }
   else
      Info += Dist + '/' + Section;   
   Info += " ";
   Info += Type;
   return Info;
}

string debReleaseIndex::MetaIndexInfo(const char *Type) const
{
   string Info = ::URI::SiteOnly(URI) + ' ';
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
	 Info += Dist;
   }
   else
      Info += Dist;
   Info += " ";
   Info += Type;
   return Info;
}

string debReleaseIndex::MetaIndexFile(const char *Type) const
{
   return _config->FindDir("Dir::State::lists") +
      URItoFileName(MetaIndexURI(Type));
}

string debReleaseIndex::MetaIndexURI(const char *Type) const
{
   string Res;

   if (Dist == "/")
      Res = URI;
   else if (Dist[Dist.size()-1] == '/')
      Res = URI + Dist;
   else
      Res = URI + "dists/" + Dist + "/";
   
   Res += Type;
   return Res;
}

string debReleaseIndex::IndexURISuffix(const char *Type, const string Section) const
{
   string Res ="";
   if (Dist[Dist.size() - 1] != '/')
      Res += Section + "/binary-" + _config->Find("APT::Architecture") + '/';
   return Res + Type;
}
   

string debReleaseIndex::IndexURI(const char *Type, const string Section) const
{
   if (Dist[Dist.size() - 1] == '/')
   {
      string Res;
      if (Dist != "/")
         Res = URI + Dist;
      else 
         Res = URI;
      return Res + Type;
   }
   else
      return URI + "dists/" + Dist + '/' + IndexURISuffix(Type, Section);
 }

string debReleaseIndex::SourceIndexURISuffix(const char *Type, const string Section) const
{
   string Res ="";
   if (Dist[Dist.size() - 1] != '/')
      Res += Section + "/source/";
   return Res + Type;
}

string debReleaseIndex::SourceIndexURI(const char *Type, const string Section) const
{
   string Res;
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
         Res = URI + Dist;
      else 
         Res = URI;
      return Res + Type;
   }
   else
      return URI + "dists/" + Dist + "/" + SourceIndexURISuffix(Type, Section);
}

debReleaseIndex::debReleaseIndex(string URI,string Dist)
{
   this->URI = URI;
   this->Dist = Dist;
   this->Indexes = NULL;
   this->Type = "deb";
}

debReleaseIndex::~debReleaseIndex()
{
   for (vector<const debSectionEntry *>::const_iterator I = SectionEntries.begin();
	I != SectionEntries.end(); I++)
      delete *I;
}

vector <struct IndexTarget *>* debReleaseIndex::ComputeIndexTargets() const
{
   vector <struct IndexTarget *>* IndexTargets = new vector <IndexTarget *>;
   for (vector <const debSectionEntry *>::const_iterator I = SectionEntries.begin();
	I != SectionEntries.end();
	I++)
   {
      IndexTarget * Target = new IndexTarget();
      Target->ShortDesc = (*I)->IsSrc ? "Sources" : "Packages";
      Target->MetaKey
	= (*I)->IsSrc ? SourceIndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section)
	              : IndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section);
      Target->URI 
	= (*I)->IsSrc ? SourceIndexURI(Target->ShortDesc.c_str(), (*I)->Section)
	              : IndexURI(Target->ShortDesc.c_str(), (*I)->Section);
      
      Target->Description = Info (Target->ShortDesc.c_str(), (*I)->Section);
      IndexTargets->push_back (Target);
   }
   return IndexTargets;
}
									/*}}}*/
bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool GetAll) const
{
   // special case for --print-uris
   if (GetAll) {
      vector <struct IndexTarget *> *targets = ComputeIndexTargets();
      for (vector <struct IndexTarget*>::const_iterator Target = targets->begin(); Target != targets->end(); Target++) {
	 new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
			 (*Target)->ShortDesc, HashString());
      }
      // this is normally created in pkgAcqMetaSig, but if we run
      // in --print-uris mode, we add it here
      new pkgAcqMetaIndex(Owner, MetaIndexURI("Release"),
		     MetaIndexInfo("Release"), "Release",
		     MetaIndexURI("Release.gpg"), 
		     ComputeIndexTargets(),
		     new indexRecords (Dist));

   }

   new pkgAcqMetaSig(Owner, MetaIndexURI("Release.gpg"),
		     MetaIndexInfo("Release.gpg"), "Release.gpg",
		     MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release",
		     ComputeIndexTargets(),
		     new indexRecords (Dist));

   // Queue the translations
   std::vector<std::string> const lang = APT::Configuration::getLanguages(true);
   for (vector<const debSectionEntry *>::const_iterator I = SectionEntries.begin(); 
	I != SectionEntries.end(); I++) {

      if((*I)->IsSrc)
	 continue;

      for (vector<string>::const_iterator l = lang.begin();
		l != lang.end(); l++)
      {
	if (*l == "none") continue;
	debTranslationsIndex i = debTranslationsIndex(URI,Dist,(*I)->Section,(*l).c_str());
	i.GetIndexes(Owner);
      }
   }

   return true;
}

bool debReleaseIndex::IsTrusted() const
{
   string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
      URItoFileName(MetaIndexURI("Release")) + ".gpg";
   
   if(_config->FindB("APT::Authentication::TrustCDROM", false))
      if(URI.substr(0,strlen("cdrom:")) == "cdrom:")
	 return true;
   
   if (FileExists(VerifiedSigFile))
      return true;
   return false;
}

vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles()
{
   if (Indexes != NULL)
      return Indexes;

   Indexes = new vector <pkgIndexFile*>;
   std::vector<std::string> const lang = APT::Configuration::getLanguages(true);
   for (vector<const debSectionEntry *>::const_iterator I = SectionEntries.begin(); 
	I != SectionEntries.end(); I++) {
      if ((*I)->IsSrc)
         Indexes->push_back(new debSourcesIndex (URI, Dist, (*I)->Section, IsTrusted()));
      else 
      {
         Indexes->push_back(new debPackagesIndex (URI, Dist, (*I)->Section, IsTrusted()));

	 for (vector<string>::const_iterator l = lang.begin();
		l != lang.end(); l++) {
	    if (*l == "none") continue;
	    Indexes->push_back(new debTranslationsIndex(URI,Dist,(*I)->Section,(*l).c_str()));
	 }
      }
   }

   return Indexes;
}

void debReleaseIndex::PushSectionEntry(const debSectionEntry *Entry)
{
   SectionEntries.push_back(Entry);
}

debReleaseIndex::debSectionEntry::debSectionEntry (string Section, bool IsSrc): Section(Section)
{
   this->IsSrc = IsSrc;
}

class debSLTypeDebian : public pkgSourceList::Type
{
   protected:

   bool CreateItemInternal(vector<metaIndex *> &List,string URI,
			   string Dist,string Section,
			   bool IsSrc) const
   {
      for (vector<metaIndex *>::const_iterator I = List.begin(); 
	   I != List.end(); I++)
      {
	 // This check insures that there will be only one Release file
	 // queued for all the Packages files and Sources files it
	 // corresponds to.
		if (strcmp((*I)->GetType(), "deb") == 0)
	 {
	    debReleaseIndex *Deb = (debReleaseIndex *) (*I);
	    // This check insures that there will be only one Release file
	    // queued for all the Packages files and Sources files it
	    // corresponds to.
	    if (Deb->GetURI() == URI && Deb->GetDist() == Dist)
	    {
	       Deb->PushSectionEntry(new debReleaseIndex::debSectionEntry(Section, IsSrc));
	       return true;
	    }
	 }
      }
      // No currently created Release file indexes this entry, so we create a new one.
      // XXX determine whether this release is trusted or not
      debReleaseIndex *Deb = new debReleaseIndex(URI,Dist);
      Deb->PushSectionEntry (new debReleaseIndex::debSectionEntry(Section, IsSrc));
      List.push_back(Deb);
      return true;
   }
};

class debSLTypeDeb : public debSLTypeDebian
{
   public:

   bool CreateItem(vector<metaIndex *> &List,string URI,
		   string Dist,string Section) const
   {
      return CreateItemInternal(List, URI, Dist, Section, false);
   }

   debSLTypeDeb()
   {
      Name = "deb";
      Label = "Standard Debian binary tree";
   }   
};

class debSLTypeDebSrc : public debSLTypeDebian
{
   public:

   bool CreateItem(vector<metaIndex *> &List,string URI,
		   string Dist,string Section) const 
   {
      return CreateItemInternal(List, URI, Dist, Section, true);
   }
   
   debSLTypeDebSrc()
   {
      Name = "deb-src";
      Label = "Standard Debian source tree";
   }   
};

debSLTypeDeb _apt_DebType;
debSLTypeDebSrc _apt_DebSrcType;
Commit	Line	Data
7db98ffc MZ	1	// ijones, walters
7db98ffc MZ	2
7db98ffc MZ	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>
45df0ad2	8	#include <apt-pkg/aptconfiguration.h>
7db98ffc MZ	9	#include <apt-pkg/error.h>
	10
	11	using namespace std;
	12
	13	string debReleaseIndex::Info(const char *Type, const string Section) const
	14	{
	15	string Info = ::URI::SiteOnly(URI) + ' ';
	16	if (Dist[Dist.size() - 1] == '/')
	17	{
	18	if (Dist != "/")
	19	Info += Dist;
	20	}
	21	else
	22	Info += Dist + '/' + Section;
	23	Info += " ";
	24	Info += Type;
	25	return Info;
	26	}
	27
	28	string debReleaseIndex::MetaIndexInfo(const char *Type) const
	29	{
	30	string Info = ::URI::SiteOnly(URI) + ' ';
	31	if (Dist[Dist.size() - 1] == '/')
	32	{
	33	if (Dist != "/")
	34	Info += Dist;
	35	}
	36	else
	37	Info += Dist;
	38	Info += " ";
	39	Info += Type;
	40	return Info;
	41	}
	42
	43	string debReleaseIndex::MetaIndexFile(const char *Type) const
	44	{
	45	return _config->FindDir("Dir::State::lists") +
	46	URItoFileName(MetaIndexURI(Type));
	47	}
	48
	49	string debReleaseIndex::MetaIndexURI(const char *Type) const
	50	{
	51	string Res;
	52
	53	if (Dist == "/")
	54	Res = URI;
	55	else if (Dist[Dist.size()-1] == '/')
	56	Res = URI + Dist;
	57	else
	58	Res = URI + "dists/" + Dist + "/";
	59
	60	Res += Type;
	61	return Res;
	62	}
	63
	64	string debReleaseIndex::IndexURISuffix(const char *Type, const string Section) const
	65	{
	66	string Res ="";
	67	if (Dist[Dist.size() - 1] != '/')
	68	Res += Section + "/binary-" + _config->Find("APT::Architecture") + '/';
	69	return Res + Type;
	70	}
	71
	72
73	string debReleaseIndex::IndexURI(const char *Type, const string Section) const
74	{
75	if (Dist[Dist.size() - 1] == '/')
76	{
77	string Res;
78	if (Dist != "/")
79	Res = URI + Dist;
80	else
81	Res = URI;
82	return Res + Type;
83	}
84	else
85	return URI + "dists/" + Dist + '/' + IndexURISuffix(Type, Section);
86	}
87
88	string debReleaseIndex::SourceIndexURISuffix(const char *Type, const string Section) const
89	{
90	string Res ="";
91	if (Dist[Dist.size() - 1] != '/')
92	Res += Section + "/source/";
93	return Res + Type;
94	}
95
96	string debReleaseIndex::SourceIndexURI(const char *Type, const string Section) const
97	{
98	string Res;
99	if (Dist[Dist.size() - 1] == '/')
100	{
101	if (Dist != "/")
102	Res = URI + Dist;
103	else
104	Res = URI;
105	return Res + Type;
106	}
107	else
108	return URI + "dists/" + Dist + "/" + SourceIndexURISuffix(Type, Section);
109	}
110
111	debReleaseIndex::debReleaseIndex(string URI,string Dist)
112	{
113	this->URI = URI;
114	this->Dist = Dist;
115	this->Indexes = NULL;
116	this->Type = "deb";
117	}
118
7a9f09bd MV	119	debReleaseIndex::~debReleaseIndex()
	120	{
	121	for (vector<const debSectionEntry *>::const_iterator I = SectionEntries.begin();
	122	I != SectionEntries.end(); I++)
	123	delete *I;
	124	}
	125
7db98ffc MZ	126	vector <struct IndexTarget > debReleaseIndex::ComputeIndexTargets() const
	127	{
	128	vector <struct IndexTarget > IndexTargets = new vector <IndexTarget *>;
	129	for (vector <const debSectionEntry *>::const_iterator I = SectionEntries.begin();
	130	I != SectionEntries.end();
	131	I++)
	132	{
	133	IndexTarget * Target = new IndexTarget();
	134	Target->ShortDesc = (*I)->IsSrc ? "Sources" : "Packages";
	135	Target->MetaKey
	136	= (I)->IsSrc ? SourceIndexURISuffix(Target->ShortDesc.c_str(), (I)->Section)
	137	: IndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section);
	138	Target->URI
	139	= (I)->IsSrc ? SourceIndexURI(Target->ShortDesc.c_str(), (I)->Section)
	140	: IndexURI(Target->ShortDesc.c_str(), (*I)->Section);
	141
	142	Target->Description = Info (Target->ShortDesc.c_str(), (*I)->Section);
	143	IndexTargets->push_back (Target);
	144	}
	145	return IndexTargets;
	146	}
	147	/}}}/
	148	bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool GetAll) const
	149	{
	150	// special case for --print-uris
	151	if (GetAll) {
	152	vector <struct IndexTarget > targets = ComputeIndexTargets();
	153	for (vector <struct IndexTarget*>::const_iterator Target = targets->begin(); Target != targets->end(); Target++) {
	154	new pkgAcqIndex(Owner, (Target)->URI, (Target)->Description,
495e5cb2	155	(*Target)->ShortDesc, HashString());
7db98ffc	156	}
8f9b141f MV	157	// this is normally created in pkgAcqMetaSig, but if we run
	158	// in --print-uris mode, we add it here
	159	new pkgAcqMetaIndex(Owner, MetaIndexURI("Release"),
	160	MetaIndexInfo("Release"), "Release",
	161	MetaIndexURI("Release.gpg"),
	162	ComputeIndexTargets(),
	163	new indexRecords (Dist));
	164
7db98ffc	165	}
8f9b141f	166
7db98ffc MZ	167	new pkgAcqMetaSig(Owner, MetaIndexURI("Release.gpg"),
	168	MetaIndexInfo("Release.gpg"), "Release.gpg",
	169	MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release",
	170	ComputeIndexTargets(),
	171	new indexRecords (Dist));
	172
97234432	173	// Queue the translations
45df0ad2	174	std::vector<std::string> const lang = APT::Configuration::getLanguages(true);
97234432 MV	175	for (vector<const debSectionEntry *>::const_iterator I = SectionEntries.begin();
	176	I != SectionEntries.end(); I++) {
	177
fb603534 MV	178	if((*I)->IsSrc)
fb603534 MV	179	continue;
45df0ad2 DK	180
	181	for (vector<string>::const_iterator l = lang.begin();
	182	l != lang.end(); l++)
	183	{
3f2d77b5	184	if (*l == "none") continue;
45df0ad2 DK	185	debTranslationsIndex i = debTranslationsIndex(URI,Dist,(I)->Section,(l).c_str());
	186	i.GetIndexes(Owner);
	187	}
97234432 MV	188	}
97234432 MV	189
7db98ffc MZ	190	return true;
	191	}
	192
	193	bool debReleaseIndex::IsTrusted() const
	194	{
	195	string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
	196	URItoFileName(MetaIndexURI("Release")) + ".gpg";
	197
4e0ad446	198	if(_config->FindB("APT::Authentication::TrustCDROM", false))
e8cdc56a MV	199	if(URI.substr(0,strlen("cdrom:")) == "cdrom:")
	200	return true;
	201
7db98ffc MZ	202	if (FileExists(VerifiedSigFile))
	203	return true;
	204	return false;
	205	}
	206
	207	vector <pkgIndexFile > debReleaseIndex::GetIndexFiles()
	208	{
	209	if (Indexes != NULL)
	210	return Indexes;
	211
	212	Indexes = new vector <pkgIndexFile*>;
45df0ad2	213	std::vector<std::string> const lang = APT::Configuration::getLanguages(true);
7db98ffc	214	for (vector<const debSectionEntry *>::const_iterator I = SectionEntries.begin();
a7a5b0d9	215	I != SectionEntries.end(); I++) {
7db98ffc MZ	216	if ((*I)->IsSrc)
	217	Indexes->push_back(new debSourcesIndex (URI, Dist, (*I)->Section, IsTrusted()));
	218	else
770c32ec	219	{
7db98ffc	220	Indexes->push_back(new debPackagesIndex (URI, Dist, (*I)->Section, IsTrusted()));
45df0ad2 DK	221
45df0ad2 DK	222	for (vector<string>::const_iterator l = lang.begin();
3f2d77b5 DK	223	l != lang.end(); l++) {
3f2d77b5 DK	224	if (*l == "none") continue;
45df0ad2	225	Indexes->push_back(new debTranslationsIndex(URI,Dist,(I)->Section,(l).c_str()));
3f2d77b5	226	}
770c32ec	227	}
a7a5b0d9 OS	228	}
a7a5b0d9 OS	229
7db98ffc MZ	230	return Indexes;
	231	}
	232
	233	void debReleaseIndex::PushSectionEntry(const debSectionEntry *Entry)
	234	{
	235	SectionEntries.push_back(Entry);
	236	}
	237
	238	debReleaseIndex::debSectionEntry::debSectionEntry (string Section, bool IsSrc): Section(Section)
	239	{
	240	this->IsSrc = IsSrc;
	241	}
	242
	243	class debSLTypeDebian : public pkgSourceList::Type
	244	{
	245	protected:
	246
	247	bool CreateItemInternal(vector<metaIndex *> &List,string URI,
	248	string Dist,string Section,
	249	bool IsSrc) const
	250	{
	251	for (vector<metaIndex *>::const_iterator I = List.begin();
	252	I != List.end(); I++)
	253	{
	254	// This check insures that there will be only one Release file
	255	// queued for all the Packages files and Sources files it
	256	// corresponds to.
a491fe60	257	if (strcmp((*I)->GetType(), "deb") == 0)
7db98ffc MZ	258	{
	259	debReleaseIndex Deb = (debReleaseIndex ) (*I);
	260	// This check insures that there will be only one Release file
	261	// queued for all the Packages files and Sources files it
	262	// corresponds to.
	263	if (Deb->GetURI() == URI && Deb->GetDist() == Dist)
	264	{
	265	Deb->PushSectionEntry(new debReleaseIndex::debSectionEntry(Section, IsSrc));
	266	return true;
	267	}
	268	}
	269	}
	270	// No currently created Release file indexes this entry, so we create a new one.
	271	// XXX determine whether this release is trusted or not
	272	debReleaseIndex *Deb = new debReleaseIndex(URI,Dist);
	273	Deb->PushSectionEntry (new debReleaseIndex::debSectionEntry(Section, IsSrc));
	274	List.push_back(Deb);
	275	return true;
	276	}
	277	};
	278
	279	class debSLTypeDeb : public debSLTypeDebian
	280	{
	281	public:
	282
	283	bool CreateItem(vector<metaIndex *> &List,string URI,
	284	string Dist,string Section) const
	285	{
	286	return CreateItemInternal(List, URI, Dist, Section, false);
	287	}
	288
	289	debSLTypeDeb()
	290	{
	291	Name = "deb";
	292	Label = "Standard Debian binary tree";
	293	}
	294	};
	295
	296	class debSLTypeDebSrc : public debSLTypeDebian
	297	{
	298	public:
	299
	300	bool CreateItem(vector<metaIndex *> &List,string URI,
	301	string Dist,string Section) const
	302	{
	303	return CreateItemInternal(List, URI, Dist, Section, true);
	304	}
	305
	306	debSLTypeDebSrc()
	307	{
	308	Name = "deb-src";
	309	Label = "Standard Debian source tree";
	310	}
	311	};
	312
	313	debSLTypeDeb _apt_DebType;
	314	debSLTypeDebSrc _apt_DebSrcType;