[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 <apt-pkg/debindexfile.h>
#include <apt-pkg/debsrcrecords.h>
#include <apt-pkg/deblistparser.h>
#include <apt-pkg/debrecords.h>
#include <apt-pkg/sourcelist.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/error.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/acquire-item.h>
#include <apt-pkg/debmetaindex.h>

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

// SourcesIndex::debSourcesIndex - Constructor				/*{{{*/
// ---------------------------------------------------------------------
/* */
debSourcesIndex::debSourcesIndex(string URI,string Dist,string Section,bool Trusted) :
     pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section)
{
}
									/*}}}*/
// SourcesIndex::SourceInfo - Short 1 liner describing a source		/*{{{*/
// ---------------------------------------------------------------------
/* The result looks like:
     http://foo/ stable/main src 1.1.1 (dsc) */
string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
				   pkgSrcRecords::File const &File) const
{
   string Res;
   Res = ::URI::SiteOnly(URI) + ' ';
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
	 Res += Dist;
   }      
   else
      Res += Dist + '/' + Section;
   
   Res += " ";
   Res += Record.Package();
   Res += " ";
   Res += Record.Version();
   if (File.Type.empty() == false)
      Res += " (" + File.Type + ")";
   return Res;
}
									/*}}}*/
// SourcesIndex::CreateSrcParser - Get a parser for the source files	/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
{
   string SourcesURI = URItoFileName(IndexURI("Sources"));
   return new debSrcRecordParser(_config->FindDir("Dir::State::lists") +
				 SourcesURI,this);
}
									/*}}}*/
// SourcesIndex::Describe - Give a descriptive path to the index	/*{{{*/
// ---------------------------------------------------------------------
/* */
string debSourcesIndex::Describe(bool Short) const
{
   char S[300];
   if (Short == true)
      snprintf(S,sizeof(S),"%s",Info("Sources").c_str());
   else
      snprintf(S,sizeof(S),"%s (%s)",Info("Sources").c_str(),
	       IndexFile("Sources").c_str());
   
   return S;
}
									/*}}}*/
// SourcesIndex::Info - One liner describing the index URI		/*{{{*/
// ---------------------------------------------------------------------
/* */
string debSourcesIndex::Info(const char *Type) const
{
   string Info = ::URI::SiteOnly(URI) + ' ';
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
	 Info += Dist;
   }
   else
      Info += Dist + '/' + Section;   
   Info += " ";
   Info += Type;
   return Info;
}
									/*}}}*/
// SourcesIndex::Index* - Return the URI to the index files		/*{{{*/
// ---------------------------------------------------------------------
/* */
inline string debSourcesIndex::IndexFile(const char *Type) const
{
   return URItoFileName(IndexURI(Type));
}
string debSourcesIndex::IndexURI(const char *Type) const
{
   string Res;
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
	 Res = URI + Dist;
      else 
	 Res = URI;
   }
   else
      Res = URI + "dists/" + Dist + '/' + Section +
      "/source/";
   
   Res += Type;
   return Res;
}
									/*}}}*/
// SourcesIndex::Exists - Check if the index is available		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debSourcesIndex::Exists() const
{
   return FileExists(IndexFile("Sources"));
}
									/*}}}*/
// SourcesIndex::Size - Return the size of the index			/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long debSourcesIndex::Size() const
{
   struct stat S;
   if (stat(IndexFile("Sources").c_str(),&S) != 0)
      return 0;
   return S.st_size;
}
									/*}}}*/

// PackagesIndex::debPackagesIndex - Contructor				/*{{{*/
// ---------------------------------------------------------------------
/* */
debPackagesIndex::debPackagesIndex(string URI,string Dist,string Section,bool Trusted) : 
                  pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section)
{
}
									/*}}}*/
// PackagesIndex::ArchiveInfo - Short version of the archive url	/*{{{*/
// ---------------------------------------------------------------------
/* This is a shorter version that is designed to be < 60 chars or so */
string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const
{
   string Res = ::URI::SiteOnly(URI) + ' ';
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
	 Res += Dist;
   }
   else
      Res += Dist + '/' + Section;
   
   Res += " ";
   Res += Ver.ParentPkg().Name();
   Res += " ";
   Res += Ver.VerStr();
   return Res;
}
									/*}}}*/
// PackagesIndex::Describe - Give a descriptive path to the index	/*{{{*/
// ---------------------------------------------------------------------
/* This should help the user find the index in the sources.list and
   in the filesystem for problem solving */
string debPackagesIndex::Describe(bool Short) const
{   
   char S[300];
   if (Short == true)
      snprintf(S,sizeof(S),"%s",Info("Packages").c_str());
   else
      snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(),
	       IndexFile("Packages").c_str());
   return S;
}
									/*}}}*/
// PackagesIndex::Info - One liner describing the index URI		/*{{{*/
// ---------------------------------------------------------------------
/* */
string debPackagesIndex::Info(const char *Type) const 
{
   string Info = ::URI::SiteOnly(URI) + ' ';
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
	 Info += Dist;
   }
   else
      Info += Dist + '/' + Section;   
   Info += " ";
   Info += Type;
   return Info;
}
									/*}}}*/
// PackagesIndex::Index* - Return the URI to the index files		/*{{{*/
// ---------------------------------------------------------------------
/* */
inline string debPackagesIndex::IndexFile(const char *Type) const
{
   return _config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
}
string debPackagesIndex::IndexURI(const char *Type) const
{
   string Res;
   if (Dist[Dist.size() - 1] == '/')
   {
      if (Dist != "/")
	 Res = URI + Dist;
      else 
	 Res = URI;
   }
   else
      Res = URI + "dists/" + Dist + '/' + Section +
      "/binary-" + _config->Find("APT::Architecture") + '/';
   
   Res += Type;
   return Res;
}
									/*}}}*/
// PackagesIndex::Exists - Check if the index is available		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debPackagesIndex::Exists() const
{
   return FileExists(IndexFile("Packages"));
}
									/*}}}*/
// PackagesIndex::Size - Return the size of the index			/*{{{*/
// ---------------------------------------------------------------------
/* This is really only used for progress reporting. */
unsigned long debPackagesIndex::Size() const
{
   struct stat S;
   if (stat(IndexFile("Packages").c_str(),&S) != 0)
      return 0;
   return S.st_size;
}
									/*}}}*/
// PackagesIndex::Merge - Load the index file into a cache		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
{
   string PackageFile = IndexFile("Packages");
   FileFd Pkg(PackageFile,FileFd::ReadOnly);
   debListParser Parser(&Pkg);
   if (_error->PendingError() == true)
      return _error->Error("Problem opening %s",PackageFile.c_str());
   
   Prog.SubProgress(0,Info("Packages"));
   ::URI Tmp(URI);
   if (Gen.SelectFile(PackageFile,Tmp.Host,*this) == false)
      return _error->Error("Problem with SelectFile %s",PackageFile.c_str());

   // Store the IMS information
   pkgCache::PkgFileIterator File = Gen.GetCurFile();
   struct stat St;
   if (fstat(Pkg.Fd(),&St) != 0)
      return _error->Errno("fstat","Failed to stat");
   File->Size = St.st_size;
   File->mtime = St.st_mtime;
   
   if (Gen.MergeList(Parser) == false)
      return _error->Error("Problem with MergeList %s",PackageFile.c_str());

   // Check the release file
   string ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("Release");
   if (FileExists(ReleaseFile) == true)
   {
      FileFd Rel(ReleaseFile,FileFd::ReadOnly);
      if (_error->PendingError() == true)
	 return false;
      Parser.LoadReleaseInfo(File,Rel,Section);
   }
   
   return true;
}
									/*}}}*/
// PackagesIndex::FindInCache - Find this index				/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const
{
   string FileName = IndexFile("Packages");
   pkgCache::PkgFileIterator File = Cache.FileBegin();
   for (; File.end() == false; File++)
   {
      if (FileName != File.FileName())
	 continue;
      
      struct stat St;
      if (stat(File.FileName(),&St) != 0)
	 return pkgCache::PkgFileIterator(Cache);
      if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
	 return pkgCache::PkgFileIterator(Cache);
      return File;
   }
   
   return File;
}
									/*}}}*/

// StatusIndex::debStatusIndex - Constructor				/*{{{*/
// ---------------------------------------------------------------------
/* */
debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), File(File)
{
}
									/*}}}*/
// StatusIndex::Size - Return the size of the index			/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long debStatusIndex::Size() const
{
   struct stat S;
   if (stat(File.c_str(),&S) != 0)
      return 0;
   return S.st_size;
}
									/*}}}*/
// StatusIndex::Merge - Load the index file into a cache		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
{
   FileFd Pkg(File,FileFd::ReadOnly);
   if (_error->PendingError() == true)
      return false;
   debListParser Parser(&Pkg);
   if (_error->PendingError() == true)
      return false;
   
   Prog.SubProgress(0,File);
   if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false)
      return _error->Error("Problem with SelectFile %s",File.c_str());

   // Store the IMS information
   pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
   struct stat St;
   if (fstat(Pkg.Fd(),&St) != 0)
      return _error->Errno("fstat","Failed to stat");
   CFile->Size = St.st_size;
   CFile->mtime = St.st_mtime;
   CFile->Archive = Gen.WriteUniqString("now");
   
   if (Gen.MergeList(Parser) == false)
      return _error->Error("Problem with MergeList %s",File.c_str());   
   return true;
}
									/*}}}*/
// StatusIndex::FindInCache - Find this index				/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
{
   pkgCache::PkgFileIterator File = Cache.FileBegin();
   for (; File.end() == false; File++)
   {
      if (this->File != File.FileName())
	 continue;
      
      struct stat St;
      if (stat(File.FileName(),&St) != 0)
	 return pkgCache::PkgFileIterator(Cache);
      if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
	 return pkgCache::PkgFileIterator(Cache);
      return File;
   }   
   return File;
}
									/*}}}*/
// StatusIndex::Exists - Check if the index is available		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debStatusIndex::Exists() const
{
   // Abort if the file does not exist.
   return true;
}
									/*}}}*/

// Index File types for Debian						/*{{{*/
class debIFTypeSrc : public pkgIndexFile::Type
{
   public:
   
   debIFTypeSrc() {Label = "Debian Source Index";};
};
class debIFTypePkg : public pkgIndexFile::Type
{
   public:
   
   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const 
   {
      return new debRecordParser(File.FileName(),*File.Cache());
   };
   debIFTypePkg() {Label = "Debian Package Index";};
};
class debIFTypeStatus : public pkgIndexFile::Type
{
   public:
   
   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const 
   {
      return new debRecordParser(File.FileName(),*File.Cache());
   };
   debIFTypeStatus() {Label = "Debian dpkg status file";};
};
static debIFTypeSrc _apt_Src;
static debIFTypePkg _apt_Pkg;
static debIFTypeStatus _apt_Status;

const pkgIndexFile::Type *debSourcesIndex::GetType() const
{
   return &_apt_Src;
}
const pkgIndexFile::Type *debPackagesIndex::GetType() const
{
   return &_apt_Pkg;
}
const pkgIndexFile::Type *debStatusIndex::GetType() const
{
   return &_apt_Status;
}

									/*}}}*/
Commit	Line	Data
b2e465d6 AL	1	// -- mode: cpp; mode: fold --
b2e465d6 AL	2	// Description /{{{/
b3d44315	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 /{{{/
b2e465d6 AL	12	#include <apt-pkg/debindexfile.h>
	13	#include <apt-pkg/debsrcrecords.h>
	14	#include <apt-pkg/deblistparser.h>
	15	#include <apt-pkg/debrecords.h>
	16	#include <apt-pkg/sourcelist.h>
	17	#include <apt-pkg/configuration.h>
	18	#include <apt-pkg/progress.h>
	19	#include <apt-pkg/error.h>
	20	#include <apt-pkg/strutl.h>
	21	#include <apt-pkg/acquire-item.h>
b3d44315	22	#include <apt-pkg/debmetaindex.h>
f2152f03	23
b2e465d6 AL	24	#include <sys/stat.h>
	25	/}}}/
	26
	27	// SourcesIndex::debSourcesIndex - Constructor /{{{/
	28	// ---------------------------------------------------------------------
	29	/* */
b3d44315 MV	30	debSourcesIndex::debSourcesIndex(string URI,string Dist,string Section,bool Trusted) :
b3d44315 MV	31	pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section)
b2e465d6 AL	32	{
	33	}
	34	/}}}/
	35	// SourcesIndex::SourceInfo - Short 1 liner describing a source /{{{/
	36	// ---------------------------------------------------------------------
	37	/* The result looks like:
	38	http://foo/ stable/main src 1.1.1 (dsc) */
	39	string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
	40	pkgSrcRecords::File const &File) const
	41	{
	42	string Res;
	43	Res = ::URI::SiteOnly(URI) + ' ';
	44	if (Dist[Dist.size() - 1] == '/')
	45	{
	46	if (Dist != "/")
	47	Res += Dist;
	48	}
	49	else
	50	Res += Dist + '/' + Section;
	51
	52	Res += " ";
	53	Res += Record.Package();
	54	Res += " ";
	55	Res += Record.Version();
	56	if (File.Type.empty() == false)
	57	Res += " (" + File.Type + ")";
	58	return Res;
	59	}
	60	/}}}/
	61	// SourcesIndex::CreateSrcParser - Get a parser for the source files /{{{/
	62	// ---------------------------------------------------------------------
	63	/* */
	64	pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
	65	{
0e72dd52	66	string SourcesURI = URItoFileName(IndexURI("Sources"));
b2e465d6 AL	67	return new debSrcRecordParser(_config->FindDir("Dir::State::lists") +
	68	SourcesURI,this);
	69	}
	70	/}}}/
	71	// SourcesIndex::Describe - Give a descriptive path to the index /{{{/
	72	// ---------------------------------------------------------------------
	73	/* */
af87ab54	74	string debSourcesIndex::Describe(bool Short) const
b2e465d6 AL	75	{
b2e465d6 AL	76	char S[300];
af87ab54	77	if (Short == true)
cc742108	78	snprintf(S,sizeof(S),"%s",Info("Sources").c_str());
af87ab54	79	else
cc742108	80	snprintf(S,sizeof(S),"%s (%s)",Info("Sources").c_str(),
af87ab54 AL	81	IndexFile("Sources").c_str());
af87ab54 AL	82
b2e465d6 AL	83	return S;
	84	}
	85	/}}}/
	86	// SourcesIndex::Info - One liner describing the index URI /{{{/
	87	// ---------------------------------------------------------------------
	88	/* */
	89	string debSourcesIndex::Info(const char *Type) const
	90	{
	91	string Info = ::URI::SiteOnly(URI) + ' ';
	92	if (Dist[Dist.size() - 1] == '/')
	93	{
	94	if (Dist != "/")
	95	Info += Dist;
	96	}
	97	else
	98	Info += Dist + '/' + Section;
	99	Info += " ";
	100	Info += Type;
	101	return Info;
	102	}
	103	/}}}/
	104	// SourcesIndex::Index* - Return the URI to the index files /{{{/
	105	// ---------------------------------------------------------------------
	106	/* */
	107	inline string debSourcesIndex::IndexFile(const char *Type) const
	108	{
	109	return URItoFileName(IndexURI(Type));
	110	}
	111	string debSourcesIndex::IndexURI(const char *Type) const
	112	{
	113	string Res;
	114	if (Dist[Dist.size() - 1] == '/')
	115	{
	116	if (Dist != "/")
	117	Res = URI + Dist;
	118	else
	119	Res = URI;
	120	}
	121	else
	122	Res = URI + "dists/" + Dist + '/' + Section +
	123	"/source/";
	124
	125	Res += Type;
	126	return Res;
	127	}
	128	/}}}/
b2e465d6 AL	129	// SourcesIndex::Exists - Check if the index is available /{{{/
	130	// ---------------------------------------------------------------------
	131	/* */
	132	bool debSourcesIndex::Exists() const
	133	{
	134	return FileExists(IndexFile("Sources"));
	135	}
	136	/}}}/
	137	// SourcesIndex::Size - Return the size of the index /{{{/
	138	// ---------------------------------------------------------------------
	139	/* */
	140	unsigned long debSourcesIndex::Size() const
	141	{
	142	struct stat S;
	143	if (stat(IndexFile("Sources").c_str(),&S) != 0)
	144	return 0;
	145	return S.st_size;
	146	}
	147	/}}}/
	148
	149	// PackagesIndex::debPackagesIndex - Contructor /{{{/
	150	// ---------------------------------------------------------------------
	151	/* */
b3d44315 MV	152	debPackagesIndex::debPackagesIndex(string URI,string Dist,string Section,bool Trusted) :
b3d44315 MV	153	pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section)
b2e465d6 AL	154	{
	155	}
	156	/}}}/
	157	// PackagesIndex::ArchiveInfo - Short version of the archive url /{{{/
	158	// ---------------------------------------------------------------------
	159	/* This is a shorter version that is designed to be < 60 chars or so */
	160	string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const
	161	{
	162	string Res = ::URI::SiteOnly(URI) + ' ';
	163	if (Dist[Dist.size() - 1] == '/')
	164	{
	165	if (Dist != "/")
	166	Res += Dist;
	167	}
	168	else
	169	Res += Dist + '/' + Section;
	170
	171	Res += " ";
	172	Res += Ver.ParentPkg().Name();
	173	Res += " ";
	174	Res += Ver.VerStr();
	175	return Res;
	176	}
	177	/}}}/
	178	// PackagesIndex::Describe - Give a descriptive path to the index /{{{/
	179	// ---------------------------------------------------------------------
	180	/* This should help the user find the index in the sources.list and
	181	in the filesystem for problem solving */
af87ab54	182	string debPackagesIndex::Describe(bool Short) const
b2e465d6 AL	183	{
b2e465d6 AL	184	char S[300];
af87ab54 AL	185	if (Short == true)
	186	snprintf(S,sizeof(S),"%s",Info("Packages").c_str());
	187	else
	188	snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(),
	189	IndexFile("Packages").c_str());
b2e465d6 AL	190	return S;
	191	}
	192	/}}}/
	193	// PackagesIndex::Info - One liner describing the index URI /{{{/
	194	// ---------------------------------------------------------------------
	195	/* */
	196	string debPackagesIndex::Info(const char *Type) const
	197	{
	198	string Info = ::URI::SiteOnly(URI) + ' ';
	199	if (Dist[Dist.size() - 1] == '/')
	200	{
	201	if (Dist != "/")
	202	Info += Dist;
	203	}
	204	else
	205	Info += Dist + '/' + Section;
	206	Info += " ";
	207	Info += Type;
	208	return Info;
	209	}
	210	/}}}/
	211	// PackagesIndex::Index* - Return the URI to the index files /{{{/
	212	// ---------------------------------------------------------------------
	213	/* */
	214	inline string debPackagesIndex::IndexFile(const char *Type) const
	215	{
	216	return _config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
	217	}
	218	string debPackagesIndex::IndexURI(const char *Type) const
	219	{
	220	string Res;
	221	if (Dist[Dist.size() - 1] == '/')
	222	{
	223	if (Dist != "/")
	224	Res = URI + Dist;
	225	else
	226	Res = URI;
	227	}
	228	else
	229	Res = URI + "dists/" + Dist + '/' + Section +
	230	"/binary-" + _config->Find("APT::Architecture") + '/';
	231
	232	Res += Type;
	233	return Res;
	234	}
	235	/}}}/
b2e465d6 AL	236	// PackagesIndex::Exists - Check if the index is available /{{{/
	237	// ---------------------------------------------------------------------
	238	/* */
	239	bool debPackagesIndex::Exists() const
	240	{
	241	return FileExists(IndexFile("Packages"));
	242	}
	243	/}}}/
	244	// PackagesIndex::Size - Return the size of the index /{{{/
	245	// ---------------------------------------------------------------------
	246	/* This is really only used for progress reporting. */
	247	unsigned long debPackagesIndex::Size() const
	248	{
	249	struct stat S;
	250	if (stat(IndexFile("Packages").c_str(),&S) != 0)
	251	return 0;
	252	return S.st_size;
	253	}
	254	/}}}/
	255	// PackagesIndex::Merge - Load the index file into a cache /{{{/
	256	// ---------------------------------------------------------------------
	257	/* */
	258	bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
	259	{
	260	string PackageFile = IndexFile("Packages");
	261	FileFd Pkg(PackageFile,FileFd::ReadOnly);
	262	debListParser Parser(&Pkg);
	263	if (_error->PendingError() == true)
	264	return _error->Error("Problem opening %s",PackageFile.c_str());
	265
	266	Prog.SubProgress(0,Info("Packages"));
	267	::URI Tmp(URI);
	268	if (Gen.SelectFile(PackageFile,Tmp.Host,*this) == false)
	269	return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
	270
	271	// Store the IMS information
	272	pkgCache::PkgFileIterator File = Gen.GetCurFile();
	273	struct stat St;
	274	if (fstat(Pkg.Fd(),&St) != 0)
	275	return _error->Errno("fstat","Failed to stat");
	276	File->Size = St.st_size;
	277	File->mtime = St.st_mtime;
	278
	279	if (Gen.MergeList(Parser) == false)
	280	return _error->Error("Problem with MergeList %s",PackageFile.c_str());
	281
	282	// Check the release file
b3d44315	283	string ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("Release");
b2e465d6 AL	284	if (FileExists(ReleaseFile) == true)
	285	{
	286	FileFd Rel(ReleaseFile,FileFd::ReadOnly);
	287	if (_error->PendingError() == true)
	288	return false;
f2152f03	289	Parser.LoadReleaseInfo(File,Rel,Section);
b2e465d6 AL	290	}
	291
	292	return true;
	293	}
	294	/}}}/
	295	// PackagesIndex::FindInCache - Find this index /{{{/
	296	// ---------------------------------------------------------------------
	297	/* */
	298	pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const
	299	{
	300	string FileName = IndexFile("Packages");
	301	pkgCache::PkgFileIterator File = Cache.FileBegin();
	302	for (; File.end() == false; File++)
	303	{
	304	if (FileName != File.FileName())
	305	continue;
	306
	307	struct stat St;
	308	if (stat(File.FileName(),&St) != 0)
	309	return pkgCache::PkgFileIterator(Cache);
	310	if ((unsigned)St.st_size != File->Size \|\| St.st_mtime != File->mtime)
	311	return pkgCache::PkgFileIterator(Cache);
	312	return File;
	313	}
	314
	315	return File;
	316	}
	317	/}}}/
	318
	319	// StatusIndex::debStatusIndex - Constructor /{{{/
	320	// ---------------------------------------------------------------------
	321	/* */
b3d44315	322	debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), File(File)
b2e465d6 AL	323	{
	324	}
	325	/}}}/
	326	// StatusIndex::Size - Return the size of the index /{{{/
	327	// ---------------------------------------------------------------------
	328	/* */
	329	unsigned long debStatusIndex::Size() const
	330	{
	331	struct stat S;
	332	if (stat(File.c_str(),&S) != 0)
	333	return 0;
	334	return S.st_size;
	335	}
	336	/}}}/
	337	// StatusIndex::Merge - Load the index file into a cache /{{{/
	338	// ---------------------------------------------------------------------
	339	/* */
	340	bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress &Prog) const
	341	{
	342	FileFd Pkg(File,FileFd::ReadOnly);
	343	if (_error->PendingError() == true)
	344	return false;
	345	debListParser Parser(&Pkg);
	346	if (_error->PendingError() == true)
	347	return false;
	348
	349	Prog.SubProgress(0,File);
	350	if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false)
	351	return _error->Error("Problem with SelectFile %s",File.c_str());
	352
	353	// Store the IMS information
	354	pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
	355	struct stat St;
	356	if (fstat(Pkg.Fd(),&St) != 0)
	357	return _error->Errno("fstat","Failed to stat");
	358	CFile->Size = St.st_size;
	359	CFile->mtime = St.st_mtime;
	360	CFile->Archive = Gen.WriteUniqString("now");
	361
	362	if (Gen.MergeList(Parser) == false)
	363	return _error->Error("Problem with MergeList %s",File.c_str());
	364	return true;
	365	}
	366	/}}}/
	367	// StatusIndex::FindInCache - Find this index /{{{/
	368	// ---------------------------------------------------------------------
	369	/* */
	370	pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
	371	{
	372	pkgCache::PkgFileIterator File = Cache.FileBegin();
	373	for (; File.end() == false; File++)
	374	{
	375	if (this->File != File.FileName())
	376	continue;
	377
	378	struct stat St;
	379	if (stat(File.FileName(),&St) != 0)
	380	return pkgCache::PkgFileIterator(Cache);
	381	if ((unsigned)St.st_size != File->Size \|\| St.st_mtime != File->mtime)
	382	return pkgCache::PkgFileIterator(Cache);
	383	return File;
	384	}
	385	return File;
	386	}
387	/}}}/
388	// StatusIndex::Exists - Check if the index is available /{{{/
389	// ---------------------------------------------------------------------
390	/* */
391	bool debStatusIndex::Exists() const
392	{
393	// Abort if the file does not exist.
394	return true;
395	}
396	/}}}/
397
b2e465d6 AL	398	// Index File types for Debian /{{{/
	399	class debIFTypeSrc : public pkgIndexFile::Type
	400	{
	401	public:
	402
	403	debIFTypeSrc() {Label = "Debian Source Index";};
	404	};
	405	class debIFTypePkg : public pkgIndexFile::Type
	406	{
	407	public:
	408
	409	virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
	410	{
	411	return new debRecordParser(File.FileName(),*File.Cache());
	412	};
	413	debIFTypePkg() {Label = "Debian Package Index";};
	414	};
	415	class debIFTypeStatus : public pkgIndexFile::Type
	416	{
	417	public:
	418
	419	virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
	420	{
	421	return new debRecordParser(File.FileName(),*File.Cache());
	422	};
	423	debIFTypeStatus() {Label = "Debian dpkg status file";};
	424	};
	425	static debIFTypeSrc _apt_Src;
	426	static debIFTypePkg _apt_Pkg;
	427	static debIFTypeStatus _apt_Status;
	428
	429	const pkgIndexFile::Type *debSourcesIndex::GetType() const
	430	{
	431	return &_apt_Src;
	432	}
	433	const pkgIndexFile::Type *debPackagesIndex::GetType() const
	434	{
	435	return &_apt_Pkg;
	436	}
	437	const pkgIndexFile::Type *debStatusIndex::GetType() const
	438	{
	439	return &_apt_Status;
	440	}
	441
	442	/}}}/