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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: debindexfile.cc,v 1.5.2.3 2004/01/04 19:11:00 mdz Exp $
/* ######################################################################

   Debian Specific sources.list types and the three sorts of Debian
   index files.
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <config.h>

#include <apt-pkg/debindexfile.h>
#include <apt-pkg/debsrcrecords.h>
#include <apt-pkg/deblistparser.h>
#include <apt-pkg/debrecords.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/error.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/indexfile.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/pkgrecords.h>
#include <apt-pkg/srcrecords.h>

#include <stdio.h>
#include <iostream>
#include <string>
#include <sstream>

#include <sys/stat.h>
									/*}}}*/

// Sources Index							/*{{{*/
debSourcesIndex::debSourcesIndex(IndexTarget const &Target,bool const Trusted) :
     pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
{
}
std::string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
				   pkgSrcRecords::File const &File) const
{
   // The result looks like: http://foo/debian/ stable/main src 1.1.1 (dsc)
   std::string Res = Target.Description;
   Res.erase(Target.Description.rfind(' '));

   Res += " ";
   Res += Record.Package();
   Res += " ";
   Res += Record.Version();
   if (File.Type.empty() == false)
      Res += " (" + File.Type + ")";
   return Res;
}
pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
{
   std::string const SourcesURI = IndexFileName();
   if (FileExists(SourcesURI))
      return new debSrcRecordParser(SourcesURI, this);
   return NULL;
}
bool debSourcesIndex::OpenListFile(FileFd &, std::string const &)
{
   return true;
}
pkgCacheListParser * debSourcesIndex::CreateListParser(FileFd &)
{
   return NULL;
}
uint8_t debSourcesIndex::GetIndexFlags() const
{
   return 0;
}
									/*}}}*/
// Packages Index							/*{{{*/
debPackagesIndex::debPackagesIndex(IndexTarget const &Target, bool const Trusted) :
                  pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
{
}
std::string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator const &Ver) const
{
   std::string Res = Target.Description;
   Res.erase(Target.Description.rfind(' '));

   Res += " ";
   Res += Ver.ParentPkg().Name();
   Res += " ";
   std::string const Dist = Target.Option(IndexTarget::RELEASE);
   if (Dist.empty() == false && Dist[Dist.size() - 1] != '/')
      Res.append(Ver.Arch()).append(" ");
   Res += Ver.VerStr();
   return Res;
}
uint8_t debPackagesIndex::GetIndexFlags() const
{
   return 0;
}
									/*}}}*/
// Translation-* Index							/*{{{*/
debTranslationsIndex::debTranslationsIndex(IndexTarget const &Target) :
			pkgDebianIndexTargetFile(Target, true), d(NULL)
{}
bool debTranslationsIndex::HasPackages() const
{
   return Exists();
}
bool debTranslationsIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
{
   if (FileExists(FileName))
      return pkgDebianIndexTargetFile::OpenListFile(Pkg, FileName);
   return true;
}
uint8_t debTranslationsIndex::GetIndexFlags() const
{
   return pkgCache::Flag::NotSource | pkgCache::Flag::NoPackages;
}
std::string debTranslationsIndex::GetArchitecture() const
{
   return std::string();
}
pkgCacheListParser * debTranslationsIndex::CreateListParser(FileFd &Pkg)
{
   if (Pkg.IsOpen() == false)
      return NULL;
   _error->PushToStack();
   pkgCacheListParser * const Parser = new debTranslationsParser(&Pkg);
   bool const newError = _error->PendingError();
   _error->MergeWithStack();
   return newError ? NULL : Parser;
}
									/*}}}*/
// dpkg/status Index							/*{{{*/
debStatusIndex::debStatusIndex(std::string const &File) : pkgDebianIndexRealFile(File, true), d(NULL)
{
}
std::string debStatusIndex::GetArchitecture() const
{
   return std::string();
}
std::string debStatusIndex::GetComponent() const
{
   return "now";
}
uint8_t debStatusIndex::GetIndexFlags() const
{
   return pkgCache::Flag::NotSource;
}

pkgCacheListParser * debStatusIndex::CreateListParser(FileFd &Pkg)
{
   if (Pkg.IsOpen() == false)
      return NULL;
   _error->PushToStack();
   pkgCacheListParser * const Parser = new debStatusListParser(&Pkg);
   bool const newError = _error->PendingError();
   _error->MergeWithStack();
   return newError ? NULL : Parser;
}
									/*}}}*/
// DebPkgFile Index - a single .deb file as an index			/*{{{*/
debDebPkgFileIndex::debDebPkgFileIndex(std::string const &DebFile)
   : pkgDebianIndexRealFile(DebFile, true), d(NULL), DebFile(DebFile)
{
}
bool debDebPkgFileIndex::GetContent(std::ostream &content, std::string const &debfile)
{
   struct stat Buf;
   if (stat(debfile.c_str(), &Buf) != 0)
      return false;

   // get the control data out of the deb file via dpkg-deb -I
   std::string dpkg = _config->Find("Dir::Bin::dpkg","dpkg-deb");
   std::vector<const char *> Args;
   Args.push_back(dpkg.c_str());
   Args.push_back("-I");
   Args.push_back(debfile.c_str());
   Args.push_back("control");
   Args.push_back(NULL);
   FileFd PipeFd;
   pid_t Child;
   if(Popen((const char**)&Args[0], PipeFd, Child, FileFd::ReadOnly) == false)
      return _error->Error("Popen failed");

   content << "Filename: " << debfile << "\n";
   content << "Size: " << Buf.st_size << "\n";
   bool first_line_seen = false;
   char buffer[1024];
   do {
      unsigned long long actual = 0;
      if (PipeFd.Read(buffer, sizeof(buffer)-1, &actual) == false)
	 return _error->Errno("read", "Failed to read dpkg pipe");
      if (actual == 0)
	 break;
      buffer[actual] = '\0';
      char const * b = buffer;
      if (first_line_seen == false)
      {
	 for (; *b != '\0' && (*b == '\n' || *b == '\r'); ++b)
	    /* skip over leading newlines */;
	 if (*b == '\0')
	    continue;
	 first_line_seen = true;
      }
      content << b;
   } while(true);
   ExecWait(Child, "Popen");

   return true;
}
bool debDebPkgFileIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
{
   // write the control data to a tempfile
   if (GetTempFile("deb-file-" + flNotDir(FileName), true, &Pkg) == NULL)
      return false;
   std::ostringstream content;
   if (GetContent(content, FileName) == false)
      return false;
   std::string const contentstr = content.str();
   if (contentstr.empty())
      return true;
   if (Pkg.Write(contentstr.c_str(), contentstr.length()) == false || Pkg.Seek(0) == false)
      return false;
   return true;
}
pkgCacheListParser * debDebPkgFileIndex::CreateListParser(FileFd &Pkg)
{
   if (Pkg.IsOpen() == false)
      return NULL;
   _error->PushToStack();
   pkgCacheListParser * const Parser = new debDebFileParser(&Pkg, DebFile);
   bool const newError = _error->PendingError();
   _error->MergeWithStack();
   return newError ? NULL : Parser;
}
uint8_t debDebPkgFileIndex::GetIndexFlags() const
{
   return pkgCache::Flag::LocalSource;
}
std::string debDebPkgFileIndex::GetArchitecture() const
{
   return std::string();
}
std::string debDebPkgFileIndex::GetComponent() const
{
   return "local-deb";
}
pkgCache::PkgFileIterator debDebPkgFileIndex::FindInCache(pkgCache &Cache) const
{
   std::string const FileName = IndexFileName();
   pkgCache::PkgFileIterator File = Cache.FileBegin();
   for (; File.end() == false; ++File)
   {
       if (File.FileName() == NULL || FileName != File.FileName())
	 continue;
      // we can't do size checks here as file size != content size
      return File;
   }

   return File;
}
std::string debDebPkgFileIndex::ArchiveInfo_impl(pkgCache::VerIterator const &Ver) const
{
   std::string Res = IndexFileName() + " ";
   Res.append(Ver.ParentPkg().Name()).append(" ");
   Res.append(Ver.Arch()).append(" ");
   Res.append(Ver.VerStr());
   return Res;
}
									/*}}}*/
// DscFile Index - a single .dsc file as an index			/*{{{*/
debDscFileIndex::debDscFileIndex(std::string const &DscFile)
   : pkgDebianIndexRealFile(DscFile, true), d(NULL)
{
}
pkgSrcRecords::Parser *debDscFileIndex::CreateSrcParser() const
{
   if (Exists() == false)
      return NULL;
   return new debDscRecordParser(File, this);
}
									/*}}}*/

// Index File types for Debian						/*{{{*/
class APT_HIDDEN debIFTypeSrc : public pkgIndexFile::Type
{
   public:
   debIFTypeSrc() {Label = "Debian Source Index";};
};
class APT_HIDDEN debIFTypePkg : public pkgIndexFile::Type
{
   public:
   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
   {
      return new debRecordParser(File.FileName(),*File.Cache());
   };
   debIFTypePkg() {Label = "Debian Package Index";};
};
class APT_HIDDEN debIFTypeTrans : public debIFTypePkg
{
   public:
   debIFTypeTrans() {Label = "Debian Translation Index";};
};
class APT_HIDDEN debIFTypeStatus : public pkgIndexFile::Type
{
   public:
   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
   {
      return new debRecordParser(File.FileName(),*File.Cache());
   };
   debIFTypeStatus() {Label = "Debian dpkg status file";};
};
class APT_HIDDEN debIFTypeDebPkgFile : public pkgIndexFile::Type
{
   public:
   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
   {
      return new debDebFileRecordParser(File.FileName());
   };
   debIFTypeDebPkgFile() {Label = "Debian deb file";};
};
class APT_HIDDEN debIFTypeDscFile : public pkgIndexFile::Type
{
   public:
   virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &DscFile) const APT_OVERRIDE
   {
      return new debDscRecordParser(DscFile, NULL);
   };
   debIFTypeDscFile() {Label = "Debian dsc file";};
};
class APT_HIDDEN debIFTypeDebianSourceDir : public pkgIndexFile::Type
{
   public:
   virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &SourceDir) const APT_OVERRIDE
   {
      return new debDscRecordParser(SourceDir + std::string("/debian/control"), NULL);
   };
   debIFTypeDebianSourceDir() {Label = "Debian control file";};
};

APT_HIDDEN debIFTypeSrc _apt_Src;
APT_HIDDEN debIFTypePkg _apt_Pkg;
APT_HIDDEN debIFTypeTrans _apt_Trans;
APT_HIDDEN debIFTypeStatus _apt_Status;
APT_HIDDEN debIFTypeDebPkgFile _apt_DebPkgFile;
// file based pseudo indexes
APT_HIDDEN debIFTypeDscFile _apt_DscFile;
APT_HIDDEN debIFTypeDebianSourceDir _apt_DebianSourceDir;

const pkgIndexFile::Type *debSourcesIndex::GetType() const
{
   return &_apt_Src;
}
const pkgIndexFile::Type *debPackagesIndex::GetType() const
{
   return &_apt_Pkg;
}
const pkgIndexFile::Type *debTranslationsIndex::GetType() const
{
   return &_apt_Trans;
}
const pkgIndexFile::Type *debStatusIndex::GetType() const
{
   return &_apt_Status;
}
const pkgIndexFile::Type *debDebPkgFileIndex::GetType() const
{
   return &_apt_DebPkgFile;
}
const pkgIndexFile::Type *debDscFileIndex::GetType() const
{
   return &_apt_DscFile;
}
const pkgIndexFile::Type *debDebianSourceDirIndex::GetType() const
{
   return &_apt_DebianSourceDir;
}
									/*}}}*/

debStatusIndex::~debStatusIndex() {}
debPackagesIndex::~debPackagesIndex() {}
debTranslationsIndex::~debTranslationsIndex() {}
debSourcesIndex::~debSourcesIndex() {}

debDebPkgFileIndex::~debDebPkgFileIndex() {}
debDscFileIndex::~debDscFileIndex() {}
Commit	Line	Data
b2e465d6 AL	1	// -- mode: cpp; mode: fold --
b2e465d6 AL	2	// Description /{{{/
7db98ffc	3	// $Id: debindexfile.cc,v 1.5.2.3 2004/01/04 19:11:00 mdz Exp $
b2e465d6 AL	4	/* ######################################################################
	5
	6	Debian Specific sources.list types and the three sorts of Debian
	7	index files.
	8
	9	##################################################################### */
	10	/}}}/
	11	// Include Files /{{{/
ea542140 DK	12	#include <config.h>
ea542140 DK	13
b2e465d6 AL	14	#include <apt-pkg/debindexfile.h>
	15	#include <apt-pkg/debsrcrecords.h>
	16	#include <apt-pkg/deblistparser.h>
	17	#include <apt-pkg/debrecords.h>
b2e465d6	18	#include <apt-pkg/configuration.h>
b2e465d6	19	#include <apt-pkg/error.h>
453b82a3 DK	20	#include <apt-pkg/fileutl.h>
453b82a3 DK	21	#include <apt-pkg/indexfile.h>
453b82a3 DK	22	#include <apt-pkg/pkgcache.h>
453b82a3 DK	23	#include <apt-pkg/cacheiterators.h>
453b82a3 DK	24	#include <apt-pkg/pkgrecords.h>
453b82a3 DK	25	#include <apt-pkg/srcrecords.h>
e011829d	26
453b82a3 DK	27	#include <stdio.h>
	28	#include <iostream>
	29	#include <string>
ac7f8f79	30	#include <sstream>
88a8975f	31
b2e465d6 AL	32	#include <sys/stat.h>
	33	/}}}/
	34
c9443c01	35	// Sources Index /{{{/
e3c1cfc7	36	debSourcesIndex::debSourcesIndex(IndexTarget const &Target,bool const Trusted) :
c9443c01	37	pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
b2e465d6 AL	38	{
b2e465d6 AL	39	}
c9443c01	40	std::string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
b2e465d6 AL	41	pkgSrcRecords::File const &File) const
b2e465d6 AL	42	{
c9443c01 DK	43	// The result looks like: http://foo/debian/ stable/main src 1.1.1 (dsc)
c9443c01 DK	44	std::string Res = Target.Description;
e3c1cfc7 DK	45	Res.erase(Target.Description.rfind(' '));
e3c1cfc7 DK	46
b2e465d6 AL	47	Res += " ";
	48	Res += Record.Package();
	49	Res += " ";
	50	Res += Record.Version();
	51	if (File.Type.empty() == false)
	52	Res += " (" + File.Type + ")";
	53	return Res;
	54	}
b2e465d6 AL	55	pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
b2e465d6 AL	56	{
c9443c01	57	std::string const SourcesURI = IndexFileName();
b0f4b486 MV	58	if (FileExists(SourcesURI))
	59	return new debSrcRecordParser(SourcesURI, this);
	60	return NULL;
c9443c01 DK	61	}
	62	bool debSourcesIndex::OpenListFile(FileFd &, std::string const &)
	63	{
	64	return true;
	65	}
	66	pkgCacheListParser * debSourcesIndex::CreateListParser(FileFd &)
	67	{
	68	return NULL;
	69	}
	70	uint8_t debSourcesIndex::GetIndexFlags() const
	71	{
	72	return 0;
b2e465d6 AL	73	}
b2e465d6 AL	74	/}}}/
c9443c01	75	// Packages Index /{{{/
e3c1cfc7	76	debPackagesIndex::debPackagesIndex(IndexTarget const &Target, bool const Trusted) :
c9443c01	77	pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
b2e465d6 AL	78	{
b2e465d6 AL	79	}
c9443c01	80	std::string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator const &Ver) const
b2e465d6	81	{
c9443c01 DK	82	std::string Res = Target.Description;
c9443c01 DK	83	Res.erase(Target.Description.rfind(' '));
e3c1cfc7	84
b2e465d6 AL	85	Res += " ";
	86	Res += Ver.ParentPkg().Name();
	87	Res += " ";
c9443c01	88	std::string const Dist = Target.Option(IndexTarget::RELEASE);
e3c1cfc7	89	if (Dist.empty() == false && Dist[Dist.size() - 1] != '/')
dd13742e	90	Res.append(Ver.Arch()).append(" ");
b2e465d6 AL	91	Res += Ver.VerStr();
	92	return Res;
	93	}
c9443c01	94	uint8_t debPackagesIndex::GetIndexFlags() const
b2e465d6	95	{
c9443c01	96	return 0;
b2e465d6 AL	97	}
b2e465d6 AL	98	/}}}/
c9443c01	99	// Translation-* Index /{{{/
e3c1cfc7	100	debTranslationsIndex::debTranslationsIndex(IndexTarget const &Target) :
c9443c01	101	pkgDebianIndexTargetFile(Target, true), d(NULL)
45df0ad2	102	{}
c9443c01	103	bool debTranslationsIndex::HasPackages() const
11680bfd	104	{
e3c1cfc7	105	return Exists();
a52f938b	106	}
c9443c01 DK	107	bool debTranslationsIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
	108	{
	109	if (FileExists(FileName))
	110	return pkgDebianIndexTargetFile::OpenListFile(Pkg, FileName);
a52f938b OS	111	return true;
a52f938b OS	112	}
c9443c01	113	uint8_t debTranslationsIndex::GetIndexFlags() const
c51c6f08	114	{
c9443c01	115	return pkgCache::Flag::NotSource \| pkgCache::Flag::NoPackages;
c51c6f08	116	}
c9443c01	117	std::string debTranslationsIndex::GetArchitecture() const
b2e465d6	118	{
c9443c01	119	return std::string();
b2e465d6	120	}
c9443c01	121	pkgCacheListParser * debTranslationsIndex::CreateListParser(FileFd &Pkg)
b2e465d6	122	{
c9443c01 DK	123	if (Pkg.IsOpen() == false)
	124	return NULL;
	125	_error->PushToStack();
	126	pkgCacheListParser * const Parser = new debTranslationsParser(&Pkg);
	127	bool const newError = _error->PendingError();
	128	_error->MergeWithStack();
	129	return newError ? NULL : Parser;
b2e465d6 AL	130	}
b2e465d6 AL	131	/}}}/
c9443c01 DK	132	// dpkg/status Index /{{{/
c9443c01 DK	133	debStatusIndex::debStatusIndex(std::string const &File) : pkgDebianIndexRealFile(File, true), d(NULL)
b2e465d6	134	{
b2e465d6	135	}
c9443c01	136	std::string debStatusIndex::GetArchitecture() const
b2e465d6	137	{
c9443c01	138	return std::string();
b2e465d6	139	}
c9443c01	140	std::string debStatusIndex::GetComponent() const
0d29b9d4	141	{
c9443c01	142	return "now";
0d29b9d4	143	}
c9443c01	144	uint8_t debStatusIndex::GetIndexFlags() const
0d29b9d4	145	{
c9443c01	146	return pkgCache::Flag::NotSource;
0d29b9d4	147	}
1c73b0fc JAK	148
	149	pkgCacheListParser * debStatusIndex::CreateListParser(FileFd &Pkg)
	150	{
	151	if (Pkg.IsOpen() == false)
	152	return NULL;
	153	_error->PushToStack();
	154	pkgCacheListParser * const Parser = new debStatusListParser(&Pkg);
	155	bool const newError = _error->PendingError();
	156	_error->MergeWithStack();
	157	return newError ? NULL : Parser;
	158	}
c9443c01 DK	159	/}}}/
	160	// DebPkgFile Index - a single .deb file as an index /{{{/
	161	debDebPkgFileIndex::debDebPkgFileIndex(std::string const &DebFile)
	162	: pkgDebianIndexRealFile(DebFile, true), d(NULL), DebFile(DebFile)
0d29b9d4	163	{
0d29b9d4	164	}
2f6a2fbb	165	bool debDebPkgFileIndex::GetContent(std::ostream &content, std::string const &debfile)
0d29b9d4	166	{
c9443c01 DK	167	struct stat Buf;
	168	if (stat(debfile.c_str(), &Buf) != 0)
	169	return false;
	170
2f6a2fbb DK	171	// get the control data out of the deb file via dpkg-deb -I
2f6a2fbb DK	172	std::string dpkg = _config->Find("Dir::Bin::dpkg","dpkg-deb");
fdff5b03 MV	173	std::vector<const char *> Args;
fdff5b03 MV	174	Args.push_back(dpkg.c_str());
fdff5b03	175	Args.push_back("-I");
2f6a2fbb	176	Args.push_back(debfile.c_str());
fdff5b03 MV	177	Args.push_back("control");
fdff5b03 MV	178	Args.push_back(NULL);
a9d990a2 MV	179	FileFd PipeFd;
a9d990a2 MV	180	pid_t Child;
fdff5b03	181	if(Popen((const char**)&Args[0], PipeFd, Child, FileFd::ReadOnly) == false)
a9d990a2	182	return _error->Error("Popen failed");
2f6a2fbb	183
2f91076d DK	184	content << "Filename: " << debfile << "\n";
	185	content << "Size: " << Buf.st_size << "\n";
	186	bool first_line_seen = false;
2f6a2fbb DK	187	char buffer[1024];
	188	do {
	189	unsigned long long actual = 0;
	190	if (PipeFd.Read(buffer, sizeof(buffer)-1, &actual) == false)
	191	return _error->Errno("read", "Failed to read dpkg pipe");
	192	if (actual == 0)
	193	break;
	194	buffer[actual] = '\0';
2f91076d DK	195	char const * b = buffer;
	196	if (first_line_seen == false)
	197	{
	198	for (; b != '\0' && (b == '\n' \|\| *b == '\r'); ++b)
	199	/* skip over leading newlines */;
	200	if (*b == '\0')
	201	continue;
	202	first_line_seen = true;
	203	}
	204	content << b;
2f6a2fbb	205	} while(true);
a9d990a2	206	ExecWait(Child, "Popen");
0d29b9d4	207
2f6a2fbb DK	208	return true;
2f6a2fbb DK	209	}
c9443c01	210	bool debDebPkgFileIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
2f6a2fbb	211	{
2f6a2fbb	212	// write the control data to a tempfile
c9443c01	213	if (GetTempFile("deb-file-" + flNotDir(FileName), true, &Pkg) == NULL)
0d29b9d4	214	return false;
2f6a2fbb	215	std::ostringstream content;
c9443c01	216	if (GetContent(content, FileName) == false)
2f6a2fbb DK	217	return false;
2f6a2fbb DK	218	std::string const contentstr = content.str();
5465192b DK	219	if (contentstr.empty())
5465192b DK	220	return true;
c9443c01 DK	221	if (Pkg.Write(contentstr.c_str(), contentstr.length()) == false \|\| Pkg.Seek(0) == false)
c9443c01 DK	222	return false;
0d29b9d4 MV	223	return true;
0d29b9d4 MV	224	}
c9443c01 DK	225	pkgCacheListParser * debDebPkgFileIndex::CreateListParser(FileFd &Pkg)
	226	{
	227	if (Pkg.IsOpen() == false)
	228	return NULL;
	229	_error->PushToStack();
	230	pkgCacheListParser * const Parser = new debDebFileParser(&Pkg, DebFile);
	231	bool const newError = _error->PendingError();
	232	_error->MergeWithStack();
	233	return newError ? NULL : Parser;
	234	}
	235	uint8_t debDebPkgFileIndex::GetIndexFlags() const
	236	{
	237	return pkgCache::Flag::LocalSource;
	238	}
	239	std::string debDebPkgFileIndex::GetArchitecture() const
	240	{
	241	return std::string();
	242	}
	243	std::string debDebPkgFileIndex::GetComponent() const
	244	{
	245	return "local-deb";
	246	}
0d29b9d4 MV	247	pkgCache::PkgFileIterator debDebPkgFileIndex::FindInCache(pkgCache &Cache) const
0d29b9d4 MV	248	{
c9443c01	249	std::string const FileName = IndexFileName();
0d29b9d4 MV	250	pkgCache::PkgFileIterator File = Cache.FileBegin();
	251	for (; File.end() == false; ++File)
	252	{
c9443c01	253	if (File.FileName() == NULL \|\| FileName != File.FileName())
0d29b9d4	254	continue;
c9443c01 DK	255	// we can't do size checks here as file size != content size
c9443c01 DK	256	return File;
0d29b9d4	257	}
5465192b	258
0d29b9d4 MV	259	return File;
0d29b9d4 MV	260	}
64b66a46 DK	261	std::string debDebPkgFileIndex::ArchiveInfo_impl(pkgCache::VerIterator const &Ver) const
	262	{
	263	std::string Res = IndexFileName() + " ";
	264	Res.append(Ver.ParentPkg().Name()).append(" ");
	265	Res.append(Ver.Arch()).append(" ");
	266	Res.append(Ver.VerStr());
	267	return Res;
	268	}
c9443c01 DK	269	/}}}/
c9443c01 DK	270	// DscFile Index - a single .dsc file as an index /{{{/
5465192b	271	debDscFileIndex::debDscFileIndex(std::string const &DscFile)
c9443c01	272	: pkgDebianIndexRealFile(DscFile, true), d(NULL)
a49e7948 MV	273	{
a49e7948 MV	274	}
a49e7948 MV	275	pkgSrcRecords::Parser *debDscFileIndex::CreateSrcParser() const
a49e7948 MV	276	{
c9443c01	277	if (Exists() == false)
a49e7948	278	return NULL;
c9443c01	279	return new debDscRecordParser(File, this);
a49e7948 MV	280	}
a49e7948 MV	281	/}}}/
5465192b	282
b2e465d6	283	// Index File types for Debian /{{{/
dce45dbe	284	class APT_HIDDEN debIFTypeSrc : public pkgIndexFile::Type
b2e465d6 AL	285	{
b2e465d6 AL	286	public:
b2e465d6 AL	287	debIFTypeSrc() {Label = "Debian Source Index";};
b2e465d6 AL	288	};
dce45dbe	289	class APT_HIDDEN debIFTypePkg : public pkgIndexFile::Type
b2e465d6 AL	290	{
b2e465d6 AL	291	public:
c9443c01	292	virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
b2e465d6 AL	293	{
	294	return new debRecordParser(File.FileName(),*File.Cache());
	295	};
	296	debIFTypePkg() {Label = "Debian Package Index";};
	297	};
dce45dbe	298	class APT_HIDDEN debIFTypeTrans : public debIFTypePkg
97234432 MV	299	{
	300	public:
	301	debIFTypeTrans() {Label = "Debian Translation Index";};
	302	};
dce45dbe	303	class APT_HIDDEN debIFTypeStatus : public pkgIndexFile::Type
b2e465d6 AL	304	{
b2e465d6 AL	305	public:
c9443c01	306	virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
b2e465d6 AL	307	{
	308	return new debRecordParser(File.FileName(),*File.Cache());
	309	};
	310	debIFTypeStatus() {Label = "Debian dpkg status file";};
	311	};
dce45dbe	312	class APT_HIDDEN debIFTypeDebPkgFile : public pkgIndexFile::Type
0d29b9d4 MV	313	{
0d29b9d4 MV	314	public:
c9443c01	315	virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
0d29b9d4	316	{
2f6a2fbb	317	return new debDebFileRecordParser(File.FileName());
0d29b9d4	318	};
463c8d80	319	debIFTypeDebPkgFile() {Label = "Debian deb file";};
0d29b9d4	320	};
dce45dbe	321	class APT_HIDDEN debIFTypeDscFile : public pkgIndexFile::Type
a49e7948 MV	322	{
a49e7948 MV	323	public:
c9443c01	324	virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &DscFile) const APT_OVERRIDE
a49e7948 MV	325	{
	326	return new debDscRecordParser(DscFile, NULL);
	327	};
463c8d80	328	debIFTypeDscFile() {Label = "Debian dsc file";};
a49e7948	329	};
dce45dbe	330	class APT_HIDDEN debIFTypeDebianSourceDir : public pkgIndexFile::Type
77da39b9 MV	331	{
77da39b9 MV	332	public:
c9443c01	333	virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &SourceDir) const APT_OVERRIDE
77da39b9	334	{
c9443c01	335	return new debDscRecordParser(SourceDir + std::string("/debian/control"), NULL);
77da39b9	336	};
463c8d80	337	debIFTypeDebianSourceDir() {Label = "Debian control file";};
77da39b9	338	};
a49e7948	339
dce45dbe DK	340	APT_HIDDEN debIFTypeSrc _apt_Src;
	341	APT_HIDDEN debIFTypePkg _apt_Pkg;
	342	APT_HIDDEN debIFTypeTrans _apt_Trans;
	343	APT_HIDDEN debIFTypeStatus _apt_Status;
	344	APT_HIDDEN debIFTypeDebPkgFile _apt_DebPkgFile;
a49e7948	345	// file based pseudo indexes
dce45dbe DK	346	APT_HIDDEN debIFTypeDscFile _apt_DscFile;
dce45dbe DK	347	APT_HIDDEN debIFTypeDebianSourceDir _apt_DebianSourceDir;
b2e465d6 AL	348
	349	const pkgIndexFile::Type *debSourcesIndex::GetType() const
	350	{
	351	return &_apt_Src;
	352	}
	353	const pkgIndexFile::Type *debPackagesIndex::GetType() const
	354	{
	355	return &_apt_Pkg;
	356	}
a52f938b OS	357	const pkgIndexFile::Type *debTranslationsIndex::GetType() const
a52f938b OS	358	{
97234432	359	return &_apt_Trans;
a52f938b	360	}
b2e465d6 AL	361	const pkgIndexFile::Type *debStatusIndex::GetType() const
	362	{
	363	return &_apt_Status;
	364	}
0d29b9d4 MV	365	const pkgIndexFile::Type *debDebPkgFileIndex::GetType() const
	366	{
	367	return &_apt_DebPkgFile;
070536e6	368	}
a49e7948 MV	369	const pkgIndexFile::Type *debDscFileIndex::GetType() const
	370	{
	371	return &_apt_DscFile;
	372	}
77da39b9 MV	373	const pkgIndexFile::Type *debDebianSourceDirIndex::GetType() const
	374	{
	375	return &_apt_DebianSourceDir;
0d29b9d4	376	}
b2e465d6	377	/}}}/
862bafea DK	378
	379	debStatusIndex::~debStatusIndex() {}
	380	debPackagesIndex::~debPackagesIndex() {}
	381	debTranslationsIndex::~debTranslationsIndex() {}
	382	debSourcesIndex::~debSourcesIndex() {}
	383
	384	debDebPkgFileIndex::~debDebPkgFileIndex() {}
c8a4ce6c	385	debDscFileIndex::~debDscFileIndex() {}