[apt.git] / apt-pkg / indexfile.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: indexfile.cc,v 1.2.2.1 2003/12/24 23:09:17 mdz Exp $
/* ######################################################################

   Index File - Abstraction for an index of archive/souce file.
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include<config.h>

#include <apt-pkg/configuration.h>
#include <apt-pkg/indexfile.h>
#include <apt-pkg/error.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/pkgcachegen.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/srcrecords.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/macros.h>

#include <apt-pkg/deblistparser.h>

#include <sys/stat.h>

#include <string>
#include <vector>
#include <clocale>
#include <cstring>
#include <memory>
									/*}}}*/

// Global list of Item supported
static  pkgIndexFile::Type *ItmList[10];
pkgIndexFile::Type **pkgIndexFile::Type::GlobalList = ItmList;
unsigned long pkgIndexFile::Type::GlobalListLen = 0;

// Type::Type - Constructor						/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgIndexFile::Type::Type()
{
   ItmList[GlobalListLen] = this;
   GlobalListLen++;
   Label = NULL;
}
									/*}}}*/
// Type::GetType - Locate the type by name				/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgIndexFile::Type *pkgIndexFile::Type::GetType(const char *Type)
{
   for (unsigned I = 0; I != GlobalListLen; I++)
      if (strcmp(GlobalList[I]->Label,Type) == 0)
	 return GlobalList[I];
   return 0;
}
									/*}}}*/
pkgIndexFile::pkgIndexFile(bool const Trusted) :			/*{{{*/
   d(NULL), Trusted(Trusted)
{
}
									/*}}}*/
// IndexFile::ArchiveInfo - Stub					/*{{{*/
std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator const &/*Ver*/) const
{
   return std::string();
}
									/*}}}*/
// IndexFile::FindInCache - Stub					/*{{{*/
pkgCache::PkgFileIterator pkgIndexFile::FindInCache(pkgCache &Cache) const
{
   return pkgCache::PkgFileIterator(Cache);
}
									/*}}}*/
// IndexFile::SourceIndex - Stub					/*{{{*/
std::string pkgIndexFile::SourceInfo(pkgSrcRecords::Parser const &/*Record*/,
				pkgSrcRecords::File const &/*File*/) const
{
   return std::string();
}
									/*}}}*/
// IndexFile::TranslationsAvailable - Check if will use Translation	/*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgIndexFile::TranslationsAvailable() {
	return (APT::Configuration::getLanguages().empty() != true);
}
									/*}}}*/
// IndexFile::CheckLanguageCode - Check the Language Code		/*{{{*/
// ---------------------------------------------------------------------
/* No intern need for this method anymore as the check for correctness
   is already done in getLanguages(). Note also that this check is
   rather bad (doesn't take three character like ast into account).
   TODO: Remove method with next API break */
APT_DEPRECATED bool pkgIndexFile::CheckLanguageCode(const char * const Lang)
{
  if (strlen(Lang) == 2 || (strlen(Lang) == 5 && Lang[2] == '_'))
    return true;

  if (strcmp(Lang,"C") != 0)
    _error->Warning("Wrong language code %s", Lang);

  return false;
}
									/*}}}*/
// IndexFile::LanguageCode - Return the Language Code			/*{{{*/
// ---------------------------------------------------------------------
/* As we have now possibly more than one LanguageCode this method is
   supersided by a) private classmembers or b) getLanguages().
   TODO: Remove method with next API break */
APT_DEPRECATED std::string pkgIndexFile::LanguageCode() {
	if (TranslationsAvailable() == false)
		return "";
	return APT::Configuration::getLanguages()[0];
}
									/*}}}*/

// IndexTarget - Constructor						/*{{{*/
IndexTarget::IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
      std::string const &LongDesc, std::string const &URI, bool const IsOptional,
      bool const KeepCompressed, std::map<std::string, std::string> const &Options) :
   URI(URI), Description(LongDesc), ShortDesc(ShortDesc), MetaKey(MetaKey),
   IsOptional(IsOptional), KeepCompressed(KeepCompressed), Options(Options)
{
}
									/*}}}*/
std::string IndexTarget::Option(OptionKeys const EnumKey) const		/*{{{*/
{
   std::string Key;
   switch (EnumKey)
   {
#define APT_CASE(X) case X: Key = #X; break
      APT_CASE(SITE);
      APT_CASE(RELEASE);
      APT_CASE(COMPONENT);
      APT_CASE(LANGUAGE);
      APT_CASE(ARCHITECTURE);
      APT_CASE(BASE_URI);
      APT_CASE(REPO_URI);
      APT_CASE(TARGET_OF);
      APT_CASE(CREATED_BY);
      APT_CASE(PDIFFS);
#undef APT_CASE
      case FILENAME: return _config->FindDir("Dir::State::lists") + URItoFileName(URI);
      case EXISTING_FILENAME:
	 std::string const filename = Option(FILENAME);
	 std::vector<std::string> const types = APT::Configuration::getCompressionTypes();
	 for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
	 {
	    if (t->empty())
	       continue;
	    std::string const file = (*t == "uncompressed") ? filename : (filename + "." + *t);
	    if (FileExists(file))
	       return file;
	 }
	 return "";
   }
   std::map<std::string,std::string>::const_iterator const M = Options.find(Key);
   if (M == Options.end())
      return "";
   return M->second;
}
									/*}}}*/
bool IndexTarget::OptionBool(OptionKeys const EnumKey) const		/*{{{*/
{
   return StringToBool(Option(EnumKey));
}
									/*}}}*/
std::string IndexTarget::Format(std::string format) const		/*{{{*/
{
   for (std::map<std::string, std::string>::const_iterator O = Options.begin(); O != Options.end(); ++O)
   {
      format = SubstVar(format, std::string("$(") + O->first + ")", O->second);
   }
   format = SubstVar(format, "$(METAKEY)", MetaKey);
   format = SubstVar(format, "$(SHORTDESC)", ShortDesc);
   format = SubstVar(format, "$(DESCRIPTION)", Description);
   format = SubstVar(format, "$(URI)", URI);
   format = SubstVar(format, "$(FILENAME)", Option(IndexTarget::FILENAME));
   return format;
}
									/*}}}*/

pkgDebianIndexTargetFile::pkgDebianIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/*{{{*/
   pkgDebianIndexFile(Trusted), d(NULL), Target(Target)
{
}
									/*}}}*/
std::string pkgDebianIndexTargetFile::ArchiveURI(std::string const &File) const/*{{{*/
{
   return Target.Option(IndexTarget::REPO_URI) + File;
}
									/*}}}*/
std::string pkgDebianIndexTargetFile::Describe(bool const Short) const	/*{{{*/
{
   if (Short)
      return Target.Description;
   return Target.Description + " (" + IndexFileName() + ")";
}
									/*}}}*/
std::string pkgDebianIndexTargetFile::IndexFileName() const			/*{{{*/
{
   std::string const s = Target.Option(IndexTarget::FILENAME);
   if (FileExists(s))
      return s;

   std::vector<std::string> types = APT::Configuration::getCompressionTypes();
   for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
   {
      std::string p = s + '.' + *t;
      if (FileExists(p))
         return p;
   }
   return s;
}
									/*}}}*/
unsigned long pkgDebianIndexTargetFile::Size() const				/*{{{*/
{
   unsigned long size = 0;

   /* we need to ignore errors here; if the lists are absent, just return 0 */
   _error->PushToStack();

   FileFd f(IndexFileName(), FileFd::ReadOnly, FileFd::Extension);
   if (!f.Failed())
      size = f.Size();

   if (_error->PendingError() == true)
       size = 0;
   _error->RevertToStack();

   return size;
}
									/*}}}*/
bool pkgDebianIndexTargetFile::Exists() const					/*{{{*/
{
   return FileExists(IndexFileName());
}
									/*}}}*/
std::string pkgDebianIndexTargetFile::GetArchitecture() const			/*{{{*/
{
   return Target.Option(IndexTarget::ARCHITECTURE);
}
									/*}}}*/
std::string pkgDebianIndexTargetFile::GetComponent() const			/*{{{*/
{
   return Target.Option(IndexTarget::COMPONENT);
}
									/*}}}*/
bool pkgDebianIndexTargetFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/*{{{*/
{
   if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::Extension) == false)
      return _error->Error("Problem opening %s",FileName.c_str());
   return true;
}
									/*}}}*/
std::string pkgDebianIndexTargetFile::GetProgressDescription() const
{
   return Target.Description;
}

pkgDebianIndexRealFile::pkgDebianIndexRealFile(std::string const &File, bool const Trusted) :/*{{{*/
   pkgDebianIndexFile(Trusted), d(NULL), File(flAbsPath(File))
{
}
									/*}}}*/
// IndexRealFile::Size - Return the size of the index			/*{{{*/
unsigned long pkgDebianIndexRealFile::Size() const
{
   struct stat S;
   if (stat(File.c_str(),&S) != 0)
      return 0;
   return S.st_size;
}
									/*}}}*/
bool pkgDebianIndexRealFile::Exists() const					/*{{{*/
{
   return FileExists(File);
}
									/*}}}*/
std::string pkgDebianIndexRealFile::Describe(bool const /*Short*/) const/*{{{*/
{
   return File;
}
									/*}}}*/
std::string pkgDebianIndexRealFile::ArchiveURI(std::string const &/*File*/) const/*{{{*/
{
   return "file:" + File;
}
									/*}}}*/
std::string pkgDebianIndexRealFile::IndexFileName() const			/*{{{*/
{
   return File;
}
									/*}}}*/
std::string pkgDebianIndexRealFile::GetProgressDescription() const
{
   return File;
}
bool pkgDebianIndexRealFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/*{{{*/
{
   if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::None) == false)
      return _error->Error("Problem opening %s",FileName.c_str());
   return true;
}
									/*}}}*/

pkgDebianIndexFile::pkgDebianIndexFile(bool const Trusted) : pkgIndexFile(Trusted)
{
}
pkgDebianIndexFile::~pkgDebianIndexFile()
{
}
pkgCacheListParser * pkgDebianIndexFile::CreateListParser(FileFd &Pkg)
{
   if (Pkg.IsOpen() == false)
      return NULL;
   _error->PushToStack();
   pkgCacheListParser * const Parser = new debListParser(&Pkg);
   bool const newError = _error->PendingError();
   _error->MergeWithStack();
   return newError ? NULL : Parser;
}
bool pkgDebianIndexFile::Merge(pkgCacheGenerator &Gen,OpProgress * const Prog)
{
   std::string const PackageFile = IndexFileName();
   FileFd Pkg;
   if (OpenListFile(Pkg, PackageFile) == false)
      return false;
   _error->PushToStack();
   std::unique_ptr<pkgCacheListParser> Parser(CreateListParser(Pkg));
   bool const newError = _error->PendingError();
   if (newError == false && Parser == nullptr)
      return true;
   if (Parser == NULL)
      return false;

   if (Prog != NULL)
      Prog->SubProgress(0, GetProgressDescription());

   if (Gen.SelectFile(PackageFile, *this, GetArchitecture(), GetComponent(), GetIndexFlags()) == false)
      return _error->Error("Problem with SelectFile %s",PackageFile.c_str());

   // Store the IMS information
   pkgCache::PkgFileIterator File = Gen.GetCurFile();
   pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
   File->Size = Pkg.FileSize();
   File->mtime = Pkg.ModificationTime();

   if (Gen.MergeList(*Parser) == false)
      return _error->Error("Problem with MergeList %s",PackageFile.c_str());
   return true;
}
pkgCache::PkgFileIterator pkgDebianIndexFile::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;

      struct stat St;
      if (stat(File.FileName(),&St) != 0)
      {
         if (_config->FindB("Debug::pkgCacheGen", false))
	    std::clog << "DebianIndexFile::FindInCache - stat failed on " << File.FileName() << std::endl;
	 return pkgCache::PkgFileIterator(Cache);
      }
      if ((map_filesize_t)St.st_size != File->Size || St.st_mtime != File->mtime)
      {
         if (_config->FindB("Debug::pkgCacheGen", false))
	    std::clog << "DebianIndexFile::FindInCache - size (" << St.st_size << " <> " << File->Size
			<< ") or mtime (" << St.st_mtime << " <> " << File->mtime
			<< ") doesn't match for " << File.FileName() << std::endl;
	 return pkgCache::PkgFileIterator(Cache);
      }
      return File;
   }

   return File;
}

APT_CONST pkgIndexFile::~pkgIndexFile() {}
APT_CONST pkgDebianIndexTargetFile::~pkgDebianIndexTargetFile() {}
APT_CONST pkgDebianIndexRealFile::~pkgDebianIndexRealFile() {}
Commit	Line	Data
b2e465d6 AL	1	// -- mode: cpp; mode: fold --
b2e465d6 AL	2	// Description /{{{/
7db98ffc	3	// $Id: indexfile.cc,v 1.2.2.1 2003/12/24 23:09:17 mdz Exp $
b2e465d6 AL	4	/* ######################################################################
	5
	6	Index File - Abstraction for an index of archive/souce file.
	7
	8	##################################################################### */
	9	/}}}/
	10	// Include Files /{{{/
ea542140 DK	11	#include<config.h>
ea542140 DK	12
e3c1cfc7	13	#include <apt-pkg/configuration.h>
b2e465d6 AL	14	#include <apt-pkg/indexfile.h>
b2e465d6 AL	15	#include <apt-pkg/error.h>
e3c1cfc7	16	#include <apt-pkg/fileutl.h>
45df0ad2	17	#include <apt-pkg/aptconfiguration.h>
453b82a3	18	#include <apt-pkg/pkgcache.h>
c9443c01	19	#include <apt-pkg/pkgcachegen.h>
453b82a3 DK	20	#include <apt-pkg/cacheiterators.h>
453b82a3 DK	21	#include <apt-pkg/srcrecords.h>
c9443c01	22	#include <apt-pkg/progress.h>
453b82a3	23	#include <apt-pkg/macros.h>
a52f938b	24
c9443c01 DK	25	#include <apt-pkg/deblistparser.h>
c9443c01 DK	26
c9443c01	27	#include <sys/stat.h>
c9443c01	28
453b82a3 DK	29	#include <string>
453b82a3 DK	30	#include <vector>
a52f938b	31	#include <clocale>
4f333a8b	32	#include <cstring>
c9443c01	33	#include <memory>
b2e465d6 AL	34	/}}}/
	35
	36	// Global list of Item supported
	37	static pkgIndexFile::Type *ItmList[10];
	38	pkgIndexFile::Type **pkgIndexFile::Type::GlobalList = ItmList;
	39	unsigned long pkgIndexFile::Type::GlobalListLen = 0;
	40
	41	// Type::Type - Constructor /{{{/
	42	// ---------------------------------------------------------------------
	43	/* */
	44	pkgIndexFile::Type::Type()
	45	{
	46	ItmList[GlobalListLen] = this;
dd688285 DK	47	GlobalListLen++;
dd688285 DK	48	Label = NULL;
b2e465d6 AL	49	}
	50	/}}}/
	51	// Type::GetType - Locate the type by name /{{{/
	52	// ---------------------------------------------------------------------
	53	/* */
	54	pkgIndexFile::Type pkgIndexFile::Type::GetType(const char Type)
	55	{
	56	for (unsigned I = 0; I != GlobalListLen; I++)
	57	if (strcmp(GlobalList[I]->Label,Type) == 0)
	58	return GlobalList[I];
	59	return 0;
e3c1cfc7 DK	60	}
e3c1cfc7 DK	61	/}}}/
c9443c01	62	pkgIndexFile::pkgIndexFile(bool const Trusted) : /{{{/
6c55f07a	63	d(NULL), Trusted(Trusted)
e3c1cfc7	64	{
b2e465d6 AL	65	}
b2e465d6 AL	66	/}}}/
b2e465d6	67	// IndexFile::ArchiveInfo - Stub /{{{/
c9443c01	68	std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator const &/Ver/) const
b2e465d6	69	{
8f3ba4e8	70	return std::string();
b2e465d6 AL	71	}
	72	/}}}/
	73	// IndexFile::FindInCache - Stub /{{{/
b2e465d6 AL	74	pkgCache::PkgFileIterator pkgIndexFile::FindInCache(pkgCache &Cache) const
	75	{
	76	return pkgCache::PkgFileIterator(Cache);
	77	}
	78	/}}}/
	79	// IndexFile::SourceIndex - Stub /{{{/
65512241 DK	80	std::string pkgIndexFile::SourceInfo(pkgSrcRecords::Parser const &/Record/,
65512241 DK	81	pkgSrcRecords::File const &/File/) const
b2e465d6	82	{
8f3ba4e8	83	return std::string();
b2e465d6 AL	84	}
b2e465d6 AL	85	/}}}/
45df0ad2	86	// IndexFile::TranslationsAvailable - Check if will use Translation /{{{/
a52f938b OS	87	// ---------------------------------------------------------------------
a52f938b OS	88	/* */
45df0ad2 DK	89	bool pkgIndexFile::TranslationsAvailable() {
45df0ad2 DK	90	return (APT::Configuration::getLanguages().empty() != true);
a52f938b OS	91	}
a52f938b OS	92	/}}}/
45df0ad2	93	// IndexFile::CheckLanguageCode - Check the Language Code /{{{/
a52f938b	94	// ---------------------------------------------------------------------
45df0ad2 DK	95	/* No intern need for this method anymore as the check for correctness
	96	is already done in getLanguages(). Note also that this check is
	97	rather bad (doesn't take three character like ast into account).
	98	TODO: Remove method with next API break */
c9443c01	99	APT_DEPRECATED bool pkgIndexFile::CheckLanguageCode(const char * const Lang)
a52f938b OS	100	{
	101	if (strlen(Lang) == 2 \|\| (strlen(Lang) == 5 && Lang[2] == '_'))
	102	return true;
	103
	104	if (strcmp(Lang,"C") != 0)
	105	_error->Warning("Wrong language code %s", Lang);
	106
	107	return false;
	108	}
	109	/}}}/
45df0ad2	110	// IndexFile::LanguageCode - Return the Language Code /{{{/
a52f938b	111	// ---------------------------------------------------------------------
45df0ad2 DK	112	/* As we have now possibly more than one LanguageCode this method is
	113	supersided by a) private classmembers or b) getLanguages().
	114	TODO: Remove method with next API break */
453b82a3	115	APT_DEPRECATED std::string pkgIndexFile::LanguageCode() {
45df0ad2 DK	116	if (TranslationsAvailable() == false)
	117	return "";
	118	return APT::Configuration::getLanguages()[0];
a52f938b OS	119	}
a52f938b OS	120	/}}}/
e3c1cfc7 DK	121
	122	// IndexTarget - Constructor /{{{/
	123	IndexTarget::IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
	124	std::string const &LongDesc, std::string const &URI, bool const IsOptional,
653ef26c DK	125	bool const KeepCompressed, std::map<std::string, std::string> const &Options) :
	126	URI(URI), Description(LongDesc), ShortDesc(ShortDesc), MetaKey(MetaKey),
	127	IsOptional(IsOptional), KeepCompressed(KeepCompressed), Options(Options)
e3c1cfc7 DK	128	{
	129	}
	130	/}}}/
001c76fe	131	std::string IndexTarget::Option(OptionKeys const EnumKey) const /{{{/
e3c1cfc7	132	{
001c76fe DK	133	std::string Key;
	134	switch (EnumKey)
	135	{
	136	#define APT_CASE(X) case X: Key = #X; break
	137	APT_CASE(SITE);
	138	APT_CASE(RELEASE);
	139	APT_CASE(COMPONENT);
	140	APT_CASE(LANGUAGE);
	141	APT_CASE(ARCHITECTURE);
	142	APT_CASE(BASE_URI);
	143	APT_CASE(REPO_URI);
8881b11e	144	APT_CASE(TARGET_OF);
001c76fe	145	APT_CASE(CREATED_BY);
1a3a14ac	146	APT_CASE(PDIFFS);
001c76fe	147	#undef APT_CASE
8881b11e	148	case FILENAME: return _config->FindDir("Dir::State::lists") + URItoFileName(URI);
3fd89e62 DK	149	case EXISTING_FILENAME:
	150	std::string const filename = Option(FILENAME);
	151	std::vector<std::string> const types = APT::Configuration::getCompressionTypes();
	152	for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
	153	{
	154	if (t->empty())
	155	continue;
	156	std::string const file = (t == "uncompressed") ? filename : (filename + "." + t);
	157	if (FileExists(file))
	158	return file;
	159	}
	160	return "";
001c76fe	161	}
e3c1cfc7 DK	162	std::map<std::string,std::string>::const_iterator const M = Options.find(Key);
	163	if (M == Options.end())
	164	return "";
	165	return M->second;
	166	}
	167	/}}}/
1a3a14ac DK	168	bool IndexTarget::OptionBool(OptionKeys const EnumKey) const /{{{/
	169	{
	170	return StringToBool(Option(EnumKey));
	171	}
	172	/}}}/
8881b11e DK	173	std::string IndexTarget::Format(std::string format) const /{{{/
	174	{
	175	for (std::map<std::string, std::string>::const_iterator O = Options.begin(); O != Options.end(); ++O)
	176	{
	177	format = SubstVar(format, std::string("$(") + O->first + ")", O->second);
	178	}
	179	format = SubstVar(format, "$(METAKEY)", MetaKey);
	180	format = SubstVar(format, "$(SHORTDESC)", ShortDesc);
	181	format = SubstVar(format, "$(DESCRIPTION)", Description);
	182	format = SubstVar(format, "$(URI)", URI);
	183	format = SubstVar(format, "$(FILENAME)", Option(IndexTarget::FILENAME));
	184	return format;
	185	}
	186	/}}}/
e3c1cfc7	187
c9443c01 DK	188	pkgDebianIndexTargetFile::pkgDebianIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/{{{/
c9443c01 DK	189	pkgDebianIndexFile(Trusted), d(NULL), Target(Target)
e3c1cfc7 DK	190	{
	191	}
	192	/}}}/
c9443c01	193	std::string pkgDebianIndexTargetFile::ArchiveURI(std::string const &File) const/{{{/
e3c1cfc7	194	{
001c76fe	195	return Target.Option(IndexTarget::REPO_URI) + File;
e3c1cfc7 DK	196	}
e3c1cfc7 DK	197	/}}}/
c9443c01	198	std::string pkgDebianIndexTargetFile::Describe(bool const Short) const /{{{/
e3c1cfc7 DK	199	{
	200	if (Short)
	201	return Target.Description;
	202	return Target.Description + " (" + IndexFileName() + ")";
	203	}
	204	/}}}/
c9443c01	205	std::string pkgDebianIndexTargetFile::IndexFileName() const /{{{/
e3c1cfc7	206	{
8881b11e	207	std::string const s = Target.Option(IndexTarget::FILENAME);
e3c1cfc7 DK	208	if (FileExists(s))
	209	return s;
	210
	211	std::vector<std::string> types = APT::Configuration::getCompressionTypes();
	212	for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
	213	{
	214	std::string p = s + '.' + *t;
	215	if (FileExists(p))
	216	return p;
	217	}
	218	return s;
	219	}
	220	/}}}/
c9443c01	221	unsigned long pkgDebianIndexTargetFile::Size() const /{{{/
e3c1cfc7 DK	222	{
	223	unsigned long size = 0;
	224
	225	/* we need to ignore errors here; if the lists are absent, just return 0 */
	226	_error->PushToStack();
	227
	228	FileFd f(IndexFileName(), FileFd::ReadOnly, FileFd::Extension);
	229	if (!f.Failed())
	230	size = f.Size();
	231
	232	if (_error->PendingError() == true)
	233	size = 0;
	234	_error->RevertToStack();
	235
	236	return size;
	237	}
	238	/}}}/
c9443c01	239	bool pkgDebianIndexTargetFile::Exists() const /{{{/
e3c1cfc7 DK	240	{
	241	return FileExists(IndexFileName());
	242	}
	243	/}}}/
c9443c01 DK	244	std::string pkgDebianIndexTargetFile::GetArchitecture() const /{{{/
	245	{
	246	return Target.Option(IndexTarget::ARCHITECTURE);
	247	}
	248	/}}}/
	249	std::string pkgDebianIndexTargetFile::GetComponent() const /{{{/
	250	{
	251	return Target.Option(IndexTarget::COMPONENT);
	252	}
	253	/}}}/
	254	bool pkgDebianIndexTargetFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/{{{/
	255	{
	256	if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::Extension) == false)
	257	return _error->Error("Problem opening %s",FileName.c_str());
	258	return true;
	259	}
	260	/}}}/
	261	std::string pkgDebianIndexTargetFile::GetProgressDescription() const
	262	{
	263	return Target.Description;
	264	}
	265
	266	pkgDebianIndexRealFile::pkgDebianIndexRealFile(std::string const &File, bool const Trusted) :/{{{/
	267	pkgDebianIndexFile(Trusted), d(NULL), File(flAbsPath(File))
	268	{
	269	}
	270	/}}}/
	271	// IndexRealFile::Size - Return the size of the index /{{{/
	272	unsigned long pkgDebianIndexRealFile::Size() const
	273	{
	274	struct stat S;
	275	if (stat(File.c_str(),&S) != 0)
	276	return 0;
	277	return S.st_size;
	278	}
	279	/}}}/
	280	bool pkgDebianIndexRealFile::Exists() const /{{{/
	281	{
	282	return FileExists(File);
	283	}
	284	/}}}/
	285	std::string pkgDebianIndexRealFile::Describe(bool const /Short/) const/{{{/
	286	{
	287	return File;
	288	}
	289	/}}}/
	290	std::string pkgDebianIndexRealFile::ArchiveURI(std::string const &/File/) const/{{{/
	291	{
	292	return "file:" + File;
	293	}
	294	/}}}/
	295	std::string pkgDebianIndexRealFile::IndexFileName() const /{{{/
	296	{
	297	return File;
	298	}
	299	/}}}/
	300	std::string pkgDebianIndexRealFile::GetProgressDescription() const
	301	{
	302	return File;
	303	}
	304	bool pkgDebianIndexRealFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/{{{/
	305	{
	306	if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::None) == false)
	307	return _error->Error("Problem opening %s",FileName.c_str());
308	return true;
309	}
310	/}}}/
311
312	pkgDebianIndexFile::pkgDebianIndexFile(bool const Trusted) : pkgIndexFile(Trusted)
313	{
314	}
315	pkgDebianIndexFile::~pkgDebianIndexFile()
316	{
317	}
318	pkgCacheListParser * pkgDebianIndexFile::CreateListParser(FileFd &Pkg)
319	{
320	if (Pkg.IsOpen() == false)
321	return NULL;
322	_error->PushToStack();
7f8c0eed	323	pkgCacheListParser * const Parser = new debListParser(&Pkg);
c9443c01 DK	324	bool const newError = _error->PendingError();
	325	_error->MergeWithStack();
	326	return newError ? NULL : Parser;
	327	}
	328	bool pkgDebianIndexFile::Merge(pkgCacheGenerator &Gen,OpProgress * const Prog)
	329	{
	330	std::string const PackageFile = IndexFileName();
	331	FileFd Pkg;
	332	if (OpenListFile(Pkg, PackageFile) == false)
	333	return false;
	334	_error->PushToStack();
	335	std::unique_ptr<pkgCacheListParser> Parser(CreateListParser(Pkg));
	336	bool const newError = _error->PendingError();
	337	if (newError == false && Parser == nullptr)
	338	return true;
	339	if (Parser == NULL)
	340	return false;
	341
	342	if (Prog != NULL)
	343	Prog->SubProgress(0, GetProgressDescription());
	344
	345	if (Gen.SelectFile(PackageFile, *this, GetArchitecture(), GetComponent(), GetIndexFlags()) == false)
	346	return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
	347
	348	// Store the IMS information
	349	pkgCache::PkgFileIterator File = Gen.GetCurFile();
	350	pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
	351	File->Size = Pkg.FileSize();
	352	File->mtime = Pkg.ModificationTime();
	353
	354	if (Gen.MergeList(*Parser) == false)
	355	return _error->Error("Problem with MergeList %s",PackageFile.c_str());
	356	return true;
	357	}
	358	pkgCache::PkgFileIterator pkgDebianIndexFile::FindInCache(pkgCache &Cache) const
	359	{
	360	std::string const FileName = IndexFileName();
	361	pkgCache::PkgFileIterator File = Cache.FileBegin();
	362	for (; File.end() == false; ++File)
	363	{
	364	if (File.FileName() == NULL \|\| FileName != File.FileName())
	365	continue;
	366
	367	struct stat St;
	368	if (stat(File.FileName(),&St) != 0)
	369	{
	370	if (_config->FindB("Debug::pkgCacheGen", false))
	371	std::clog << "DebianIndexFile::FindInCache - stat failed on " << File.FileName() << std::endl;
	372	return pkgCache::PkgFileIterator(Cache);
	373	}
	374	if ((map_filesize_t)St.st_size != File->Size \|\| St.st_mtime != File->mtime)
	375	{
	376	if (_config->FindB("Debug::pkgCacheGen", false))
	377	std::clog << "DebianIndexFile::FindInCache - size (" << St.st_size << " <> " << File->Size
	378	<< ") or mtime (" << St.st_mtime << " <> " << File->mtime
	379	<< ") doesn't match for " << File.FileName() << std::endl;
	380	return pkgCache::PkgFileIterator(Cache);
	381	}
	382	return File;
	383	}
	384
	385	return File;
	386	}
c8a4ce6c DK	387
c8a4ce6c DK	388	APT_CONST pkgIndexFile::~pkgIndexFile() {}
c9443c01 DK	389	APT_CONST pkgDebianIndexTargetFile::~pkgDebianIndexTargetFile() {}
c9443c01 DK	390	APT_CONST pkgDebianIndexRealFile::~pkgDebianIndexRealFile() {}