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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: deblistparser.cc,v 1.29.2.5 2004/01/06 01:43:44 mdz Exp $
/* ######################################################################
   
   Package Cache Generator - Generator for the cache structure.
   
   This builds the cache structure from the abstract package list parser. 
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/deblistparser.h>
#include <apt-pkg/error.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/crc-16.h>

#include <ctype.h>

#include <system.h>
									/*}}}*/

static debListParser::WordList PrioList[] = {{"important",pkgCache::State::Important},
                       {"required",pkgCache::State::Required},
                       {"standard",pkgCache::State::Standard},
                       {"optional",pkgCache::State::Optional},
	               {"extra",pkgCache::State::Extra},
                       {}};

// ListParser::debListParser - Constructor				/*{{{*/
// ---------------------------------------------------------------------
/* */
debListParser::debListParser(FileFd *File) : Tags(File)
{
   Arch = _config->Find("APT::architecture");
}
									/*}}}*/
// ListParser::UniqFindTagWrite - Find the tag and write a unq string	/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long debListParser::UniqFindTagWrite(const char *Tag)
{
   const char *Start;
   const char *Stop;
   if (Section.Find(Tag,Start,Stop) == false)
      return 0;
   return WriteUniqString(Start,Stop - Start);
}
									/*}}}*/
// ListParser::Package - Return the package name			/*{{{*/
// ---------------------------------------------------------------------
/* This is to return the name of the package this section describes */
string debListParser::Package()
{
   string Result = Section.FindS("Package");
   if (Result.empty() == true)
      _error->Error("Encountered a section with no Package: header");
   return Result;
}
									/*}}}*/
// ListParser::Version - Return the version string			/*{{{*/
// ---------------------------------------------------------------------
/* This is to return the string describing the version in debian form,
   epoch:upstream-release. If this returns the blank string then the 
   entry is assumed to only describe package properties */
string debListParser::Version()
{
   return Section.FindS("Version");
}
									/*}}}*/
// ListParser::NewVersion - Fill in the version structure		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debListParser::NewVersion(pkgCache::VerIterator Ver)
{
   // Parse the section
   Ver->Section = UniqFindTagWrite("Section");
   Ver->Arch = UniqFindTagWrite("Architecture");
   
   // Archive Size
   Ver->Size = (unsigned)Section.FindI("Size");
   
   // Unpacked Size (in K)
   Ver->InstalledSize = (unsigned)Section.FindI("Installed-Size");
   Ver->InstalledSize *= 1024;

   // Priority
   const char *Start;
   const char *Stop;
   if (Section.Find("Priority",Start,Stop) == true)
   {      
      if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
	 Ver->Priority = pkgCache::State::Extra;
   }

   if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
      return false;
   if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
      return false;
   if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
      return false;
   if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
      return false;
   if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
      return false;
   if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
      return false;

   // Obsolete.
   if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
      return false;
   
   if (ParseProvides(Ver) == false)
      return false;
   
   return true;
}
									/*}}}*/
// ListParser::UsePackage - Update a package structure			/*{{{*/
// ---------------------------------------------------------------------
/* This is called to update the package with any new information 
   that might be found in the section */
bool debListParser::UsePackage(pkgCache::PkgIterator Pkg,
			       pkgCache::VerIterator Ver)
{
   if (Pkg->Section == 0)
      Pkg->Section = UniqFindTagWrite("Section");
   if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
      return false;
   if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
      return false;

   if (strcmp(Pkg.Name(),"apt") == 0)
      Pkg->Flags |= pkgCache::Flag::Important;
   
   if (ParseStatus(Pkg,Ver) == false)
      return false;
   return true;
}
									/*}}}*/
// ListParser::VersionHash - Compute a unique hash for this version	/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned short debListParser::VersionHash()
{
   const char *Sections[] ={"Installed-Size",
                            "Depends",
                            "Pre-Depends",
//                            "Suggests",
//                            "Recommends",
                            "Conflicts",
                            "Replaces",0};
   unsigned long Result = INIT_FCS;
   char S[1024];
   for (const char **I = Sections; *I != 0; I++)
   {
      const char *Start;
      const char *End;
      if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S))
	 continue;
      
      /* Strip out any spaces from the text, this undoes dpkgs reformatting
         of certain fields. dpkg also has the rather interesting notion of
         reformatting depends operators < -> <= */
      char *I = S;
      for (; Start != End; Start++)
      {
	 if (isspace(*Start) == 0)
	    *I++ = tolower(*Start);
	 if (*Start == '<' && Start[1] != '<' && Start[1] != '=')
	    *I++ = '=';
	 if (*Start == '>' && Start[1] != '>' && Start[1] != '=')
	    *I++ = '=';
      }

      Result = AddCRC16(Result,S,I - S);
   }
   
   return Result;
}
									/*}}}*/
// ListParser::ParseStatus - Parse the status field			/*{{{*/
// ---------------------------------------------------------------------
/* Status lines are of the form,
     Status: want flag status
   want = unknown, install, hold, deinstall, purge
   flag = ok, reinstreq, hold, hold-reinstreq
   status = not-installed, unpacked, half-configured,
            half-installed, config-files, post-inst-failed, 
            removal-failed, installed
   
   Some of the above are obsolete (I think?) flag = hold-* and 
   status = post-inst-failed, removal-failed at least.
 */
bool debListParser::ParseStatus(pkgCache::PkgIterator Pkg,
				pkgCache::VerIterator Ver)
{
   const char *Start;
   const char *Stop;
   if (Section.Find("Status",Start,Stop) == false)
      return true;
   
   // Isolate the first word
   const char *I = Start;
   for(; I < Stop && *I != ' '; I++);
   if (I >= Stop || *I != ' ')
      return _error->Error("Malformed Status line");

   // Process the want field
   WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
                          {"install",pkgCache::State::Install},
                          {"hold",pkgCache::State::Hold},
                          {"deinstall",pkgCache::State::DeInstall},
                          {"purge",pkgCache::State::Purge},
                          {}};
   if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
      return _error->Error("Malformed 1st word in the Status line");

   // Isloate the next word
   I++;
   Start = I;
   for(; I < Stop && *I != ' '; I++);
   if (I >= Stop || *I != ' ')
      return _error->Error("Malformed status line, no 2nd word");

   // Process the flag field
   WordList FlagList[] = {{"ok",pkgCache::State::Ok},
                          {"reinstreq",pkgCache::State::ReInstReq},
                          {"hold",pkgCache::State::HoldInst},
                          {"hold-reinstreq",pkgCache::State::HoldReInstReq},
                          {}};
   if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
      return _error->Error("Malformed 2nd word in the Status line");

   // Isloate the last word
   I++;
   Start = I;
   for(; I < Stop && *I != ' '; I++);
   if (I != Stop)
      return _error->Error("Malformed Status line, no 3rd word");

   // Process the flag field
   WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
                            {"unpacked",pkgCache::State::UnPacked},
                            {"half-configured",pkgCache::State::HalfConfigured},
                            {"installed",pkgCache::State::Installed},
                            {"half-installed",pkgCache::State::HalfInstalled},
                            {"config-files",pkgCache::State::ConfigFiles},
                            {"post-inst-failed",pkgCache::State::HalfConfigured},
                            {"removal-failed",pkgCache::State::HalfInstalled},
                            {}};
   if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
      return _error->Error("Malformed 3rd word in the Status line");

   /* A Status line marks the package as indicating the current
      version as well. Only if it is actually installed.. Otherwise
      the interesting dpkg handling of the status file creates bogus 
      entries. */
   if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
	 Pkg->CurrentState == pkgCache::State::ConfigFiles))
   {
      if (Ver.end() == true)
	 _error->Warning("Encountered status field in a non-version description");
      else
	 Pkg->CurrentVer = Ver.Index();
   }
   
   return true;
}

const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
{
   // Determine the operator
   switch (*I)
   {
      case '<':
      I++;
      if (*I == '=')
      {
	 I++;
	 Op = pkgCache::Dep::LessEq;
	 break;
      }
      
      if (*I == '<')
      {
	 I++;
	 Op = pkgCache::Dep::Less;
	 break;
      }
      
      // < is the same as <= and << is really Cs < for some reason
      Op = pkgCache::Dep::LessEq;
      break;
      
      case '>':
      I++;
      if (*I == '=')
      {
	 I++;
	 Op = pkgCache::Dep::GreaterEq;
	 break;
      }
      
      if (*I == '>')
      {
	 I++;
	 Op = pkgCache::Dep::Greater;
	 break;
      }
      
      // > is the same as >= and >> is really Cs > for some reason
      Op = pkgCache::Dep::GreaterEq;
      break;
      
      case '=':
      Op = pkgCache::Dep::Equals;
      I++;
      break;
      
      // HACK around bad package definitions
      default:
      Op = pkgCache::Dep::Equals;
      break;
   }
   return I;
}

									/*}}}*/
// ListParser::ParseDepends - Parse a dependency element		/*{{{*/
// ---------------------------------------------------------------------
/* This parses the dependency elements out of a standard string in place,
   bit by bit. */
const char *debListParser::ParseDepends(const char *Start,const char *Stop,
					string &Package,string &Ver,
					unsigned int &Op, bool ParseArchFlags)
{
   // Strip off leading space
   for (;Start != Stop && isspace(*Start) != 0; Start++);
   
   // Parse off the package name
   const char *I = Start;
   for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
	*I != ',' && *I != '|'; I++);
   
   // Malformed, no '('
   if (I != Stop && *I == ')')
      return 0;

   if (I == Start)
      return 0;
   
   // Stash the package name
   Package.assign(Start,I - Start);
   
   // Skip white space to the '('
   for (;I != Stop && isspace(*I) != 0 ; I++);
   
   // Parse a version
   if (I != Stop && *I == '(')
   {
      // Skip the '('
      for (I++; I != Stop && isspace(*I) != 0 ; I++);
      if (I + 3 >= Stop)
	 return 0;
      I = ConvertRelation(I,Op);
      
      // Skip whitespace
      for (;I != Stop && isspace(*I) != 0; I++);
      Start = I;
      for (;I != Stop && *I != ')'; I++);
      if (I == Stop || Start == I)
	 return 0;     
      
      // Skip trailing whitespace
      const char *End = I;
      for (; End > Start && isspace(End[-1]); End--);
      
      Ver = string(Start,End-Start);
      I++;
   }
   else
   {
      Ver = string();
      Op = pkgCache::Dep::NoOp;
   }
   
   // Skip whitespace
   for (;I != Stop && isspace(*I) != 0; I++);

   if (ParseArchFlags == true)
   {
      string arch = _config->Find("APT::Architecture");

      // Parse an architecture
      if (I != Stop && *I == '[')
      {
	 // malformed
         I++;
         if (I == Stop)
	    return 0; 
	 
         const char *End = I;
         bool Found = false;
      	 bool NegArch = false;
         while (I != Stop) 
	 {
            // look for whitespace or ending ']'
	    while (End != Stop && !isspace(*End) && *End != ']') 
	       End++;
	 
	    if (End == Stop) 
	       return 0;

	    if (*I == '!')
            {
	       NegArch = true;
	       I++;
            }

	    if (stringcmp(arch,I,End) == 0)
	       Found = true;
	    
	    if (*End++ == ']') {
	       I = End;
	       break;
	    }
	    
	    I = End;
	    for (;I != Stop && isspace(*I) != 0; I++);
         }

	 if (NegArch)
	    Found = !Found;
	 
         if (Found == false)
	    Package = ""; /* not for this arch */
      }
      
      // Skip whitespace
      for (;I != Stop && isspace(*I) != 0; I++);
   }

   if (I != Stop && *I == '|')
      Op |= pkgCache::Dep::Or;
   
   if (I == Stop || *I == ',' || *I == '|')
   {
      if (I != Stop)
	 for (I++; I != Stop && isspace(*I) != 0; I++);
      return I;
   }
   
   return 0;
}
									/*}}}*/
// ListParser::ParseDepends - Parse a dependency list			/*{{{*/
// ---------------------------------------------------------------------
/* This is the higher level depends parser. It takes a tag and generates
   a complete depends tree for the given version. */
bool debListParser::ParseDepends(pkgCache::VerIterator Ver,
				 const char *Tag,unsigned int Type)
{
   const char *Start;
   const char *Stop;
   if (Section.Find(Tag,Start,Stop) == false)
      return true;
   
   string Package;
   string Version;
   unsigned int Op;

   while (1)
   {
      Start = ParseDepends(Start,Stop,Package,Version,Op);
      if (Start == 0)
	 return _error->Error("Problem parsing dependency %s",Tag);
      
      if (NewDepends(Ver,Package,Version,Op,Type) == false)
	 return false;
      if (Start == Stop)
	 break;
   }
   return true;
}
									/*}}}*/
// ListParser::ParseProvides - Parse the provides list			/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debListParser::ParseProvides(pkgCache::VerIterator Ver)
{
   const char *Start;
   const char *Stop;
   if (Section.Find("Provides",Start,Stop) == false)
      return true;
   
   string Package;
   string Version;
   unsigned int Op;

   while (1)
   {
      Start = ParseDepends(Start,Stop,Package,Version,Op);
      if (Start == 0)
	 return _error->Error("Problem parsing Provides line");
      if (Op != pkgCache::Dep::NoOp)
	 return _error->Error("Malformed provides line");

      if (NewProvides(Ver,Package,Version) == false)
	 return false;

      if (Start == Stop)
	 break;
   }
   
   return true;
}
									/*}}}*/
// ListParser::GrabWord - Matches a word and returns			/*{{{*/
// ---------------------------------------------------------------------
/* Looks for a word in a list of words - for ParseStatus */
bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
{
   for (unsigned int C = 0; List[C].Str != 0; C++)
   {
      if (strcasecmp(Word.c_str(),List[C].Str) == 0)
      {
	 Out = List[C].Val;
	 return true;
      }
   }
   return false;
}
									/*}}}*/
// ListParser::Step - Move to the next section in the file		/*{{{*/
// ---------------------------------------------------------------------
/* This has to be carefull to only process the correct architecture */
bool debListParser::Step()
{
   iOffset = Tags.Offset();
   while (Tags.Step(Section) == true)
   {      
      /* See if this is the correct Architecture, if it isn't then we
         drop the whole section. A missing arch tag only happens (in theory)
         inside the Status file, so that is a positive return */
      const char *Start;
      const char *Stop;
      if (Section.Find("Architecture",Start,Stop) == false)
	 return true;

      if (stringcmp(Arch,Start,Stop) == 0)
	 return true;

      if (stringcmp(Start,Stop,"all") == 0)
	 return true;

      iOffset = Tags.Offset();
   }   
   return false;
}
									/*}}}*/
// ListParser::LoadReleaseInfo - Load the release information		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator FileI,
				    FileFd &File, string component)
{
   pkgTagFile Tags(&File, File.Size() + 256); // XXX
   pkgTagSection Section;
   if (Tags.Step(Section) == false)
      return false;

   //mvo: I don't think we need to fill that in (it's unused since apt-0.6)
   //FileI->Architecture = WriteUniqString(Arch);
   
   // apt-secure does no longer download individual (per-section) Release
   // file. to provide Component pinning we use the section name now
   FileI->Component = WriteUniqString(component);

   const char *Start;
   const char *Stop;
   if (Section.Find("Suite",Start,Stop) == true)
      FileI->Archive = WriteUniqString(Start,Stop - Start);
   if (Section.Find("Component",Start,Stop) == true)
      FileI->Component = WriteUniqString(Start,Stop - Start);
   if (Section.Find("Version",Start,Stop) == true)
      FileI->Version = WriteUniqString(Start,Stop - Start);
   if (Section.Find("Origin",Start,Stop) == true)
      FileI->Origin = WriteUniqString(Start,Stop - Start);
   if (Section.Find("Label",Start,Stop) == true)
      FileI->Label = WriteUniqString(Start,Stop - Start);
   if (Section.Find("Architecture",Start,Stop) == true)
      FileI->Architecture = WriteUniqString(Start,Stop - Start);
   
   if (Section.FindFlag("NotAutomatic",FileI->Flags,
			pkgCache::Flag::NotAutomatic) == false)
      _error->Warning("Bad NotAutomatic flag");

   return !_error->PendingError();
}
									/*}}}*/
// ListParser::GetPrio - Convert the priority from a string		/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned char debListParser::GetPrio(string Str)
{
   unsigned char Out;
   if (GrabWord(Str,PrioList,Out) == false)
      Out = pkgCache::State::Extra;
   
   return Out;
}
									/*}}}*/
Commit	Line	Data
f55a958f AL	1	// -- mode: cpp; mode: fold --
f55a958f AL	2	// Description /{{{/
7db98ffc	3	// $Id: deblistparser.cc,v 1.29.2.5 2004/01/06 01:43:44 mdz Exp $
f55a958f AL	4	/* ######################################################################
	5
	6	Package Cache Generator - Generator for the cache structure.
	7
	8	This builds the cache structure from the abstract package list parser.
	9
	10	##################################################################### */
	11	/}}}/
	12	// Include Files /{{{/
094a497d AL	13	#include <apt-pkg/deblistparser.h>
	14	#include <apt-pkg/error.h>
	15	#include <apt-pkg/configuration.h>
cdcc6d34	16	#include <apt-pkg/strutl.h>
204fbdcc	17	#include <apt-pkg/crc-16.h>
9c14e3d6	18
e7b470ee AL	19	#include <ctype.h>
e7b470ee AL	20
f55a958f AL	21	#include <system.h>
	22	/}}}/
	23
b2e465d6 AL	24	static debListParser::WordList PrioList[] = {{"important",pkgCache::State::Important},
	25	{"required",pkgCache::State::Required},
	26	{"standard",pkgCache::State::Standard},
	27	{"optional",pkgCache::State::Optional},
	28	{"extra",pkgCache::State::Extra},
	29	{}};
	30
f55a958f AL	31	// ListParser::debListParser - Constructor /{{{/
	32	// ---------------------------------------------------------------------
	33	/* */
b2e465d6	34	debListParser::debListParser(FileFd *File) : Tags(File)
f55a958f	35	{
ddc1d8d0	36	Arch = _config->Find("APT::architecture");
0149949b AL	37	}
0149949b AL	38	/}}}/
f55a958f AL	39	// ListParser::UniqFindTagWrite - Find the tag and write a unq string /{{{/
	40	// ---------------------------------------------------------------------
	41	/* */
	42	unsigned long debListParser::UniqFindTagWrite(const char *Tag)
	43	{
	44	const char *Start;
	45	const char *Stop;
	46	if (Section.Find(Tag,Start,Stop) == false)
	47	return 0;
	48	return WriteUniqString(Start,Stop - Start);
	49	}
	50	/}}}/
f55a958f AL	51	// ListParser::Package - Return the package name /{{{/
	52	// ---------------------------------------------------------------------
	53	/* This is to return the name of the package this section describes */
	54	string debListParser::Package()
	55	{
b0b4efb9	56	string Result = Section.FindS("Package");
f55a958f	57	if (Result.empty() == true)
65a1e968	58	_error->Error("Encountered a section with no Package: header");
f55a958f AL	59	return Result;
	60	}
	61	/}}}/
	62	// ListParser::Version - Return the version string /{{{/
	63	// ---------------------------------------------------------------------
	64	/* This is to return the string describing the version in debian form,
	65	epoch:upstream-release. If this returns the blank string then the
	66	entry is assumed to only describe package properties */
	67	string debListParser::Version()
	68	{
b0b4efb9	69	return Section.FindS("Version");
f55a958f AL	70	}
f55a958f AL	71	/}}}/
f55a958f AL	72	// ListParser::NewVersion - Fill in the version structure /{{{/
	73	// ---------------------------------------------------------------------
	74	/* */
	75	bool debListParser::NewVersion(pkgCache::VerIterator Ver)
0149949b AL	76	{
0149949b AL	77	// Parse the section
b35d2f5f	78	Ver->Section = UniqFindTagWrite("Section");
17caf1b1	79	Ver->Arch = UniqFindTagWrite("Architecture");
0149949b AL	80
0149949b AL	81	// Archive Size
b0b4efb9	82	Ver->Size = (unsigned)Section.FindI("Size");
0149949b AL	83
0149949b AL	84	// Unpacked Size (in K)
b0b4efb9	85	Ver->InstalledSize = (unsigned)Section.FindI("Installed-Size");
0149949b AL	86	Ver->InstalledSize *= 1024;
	87
	88	// Priority
	89	const char *Start;
	90	const char *Stop;
	91	if (Section.Find("Priority",Start,Stop) == true)
b2e465d6 AL	92	{
b2e465d6 AL	93	if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
421c8d10	94	Ver->Priority = pkgCache::State::Extra;
0149949b	95	}
dcb79bae	96
6c139d6e	97	if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
dcb79bae	98	return false;
8efa2a3b	99	if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
dcb79bae	100	return false;
6c139d6e	101	if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
dcb79bae	102	return false;
6c139d6e	103	if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
dcb79bae	104	return false;
6c139d6e	105	if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
dcb79bae	106	return false;
f55ece0e	107	if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
dcb79bae AL	108	return false;
dcb79bae AL	109
b2e465d6 AL	110	// Obsolete.
	111	if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
	112	return false;
	113
dcb79bae AL	114	if (ParseProvides(Ver) == false)
dcb79bae AL	115	return false;
0149949b	116
f55a958f AL	117	return true;
	118	}
	119	/}}}/
	120	// ListParser::UsePackage - Update a package structure /{{{/
	121	// ---------------------------------------------------------------------
	122	/* This is called to update the package with any new information
	123	that might be found in the section */
	124	bool debListParser::UsePackage(pkgCache::PkgIterator Pkg,
	125	pkgCache::VerIterator Ver)
	126	{
	127	if (Pkg->Section == 0)
b35d2f5f	128	Pkg->Section = UniqFindTagWrite("Section");
b0b4efb9	129	if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
f55a958f	130	return false;
138d4b3d	131	if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
f55a958f	132	return false;
138d4b3d AL	133
	134	if (strcmp(Pkg.Name(),"apt") == 0)
	135	Pkg->Flags \|= pkgCache::Flag::Important;
	136
f55a958f AL	137	if (ParseStatus(Pkg,Ver) == false)
	138	return false;
	139	return true;
	140	}
	141	/}}}/
204fbdcc AL	142	// ListParser::VersionHash - Compute a unique hash for this version /{{{/
	143	// ---------------------------------------------------------------------
	144	/* */
	145	unsigned short debListParser::VersionHash()
	146	{
	147	const char *Sections[] ={"Installed-Size",
	148	"Depends",
	149	"Pre-Depends",
f78439bf AL	150	// "Suggests",
f78439bf AL	151	// "Recommends",
204fbdcc AL	152	"Conflicts",
	153	"Replaces",0};
	154	unsigned long Result = INIT_FCS;
418a471f	155	char S[1024];
204fbdcc AL	156	for (const char *I = Sections; I != 0; I++)
	157	{
	158	const char *Start;
	159	const char *End;
	160	if (Section.Find(*I,Start,End) == false \|\| End - Start >= (signed)sizeof(S))
	161	continue;
	162
	163	/* Strip out any spaces from the text, this undoes dpkgs reformatting
421c8d10 AL	164	of certain fields. dpkg also has the rather interesting notion of
421c8d10 AL	165	reformatting depends operators < -> <= */
204fbdcc AL	166	char *I = S;
204fbdcc AL	167	for (; Start != End; Start++)
421c8d10	168	{
204fbdcc	169	if (isspace(*Start) == 0)
ddc1d8d0	170	I++ = tolower(Start);
421c8d10 AL	171	if (*Start == '<' && Start[1] != '<' && Start[1] != '=')
	172	*I++ = '=';
	173	if (*Start == '>' && Start[1] != '>' && Start[1] != '=')
	174	*I++ = '=';
	175	}
418a471f	176
204fbdcc AL	177	Result = AddCRC16(Result,S,I - S);
	178	}
	179
	180	return Result;
	181	}
	182	/}}}/
dcb79bae	183	// ListParser::ParseStatus - Parse the status field /{{{/
f55a958f AL	184	// ---------------------------------------------------------------------
	185	/* Status lines are of the form,
	186	Status: want flag status
	187	want = unknown, install, hold, deinstall, purge
	188	flag = ok, reinstreq, hold, hold-reinstreq
a005475e	189	status = not-installed, unpacked, half-configured,
f55a958f AL	190	half-installed, config-files, post-inst-failed,
	191	removal-failed, installed
	192
	193	Some of the above are obsolete (I think?) flag = hold-* and
	194	status = post-inst-failed, removal-failed at least.
	195	*/
	196	bool debListParser::ParseStatus(pkgCache::PkgIterator Pkg,
	197	pkgCache::VerIterator Ver)
	198	{
	199	const char *Start;
	200	const char *Stop;
	201	if (Section.Find("Status",Start,Stop) == false)
	202	return true;
	203
	204	// Isolate the first word
	205	const char *I = Start;
	206	for(; I < Stop && *I != ' '; I++);
	207	if (I >= Stop \|\| *I != ' ')
	208	return _error->Error("Malformed Status line");
	209
	210	// Process the want field
6c139d6e AL	211	WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
	212	{"install",pkgCache::State::Install},
	213	{"hold",pkgCache::State::Hold},
	214	{"deinstall",pkgCache::State::DeInstall},
b2e465d6 AL	215	{"purge",pkgCache::State::Purge},
	216	{}};
	217	if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
f55a958f AL	218	return _error->Error("Malformed 1st word in the Status line");
	219
	220	// Isloate the next word
	221	I++;
	222	Start = I;
	223	for(; I < Stop && *I != ' '; I++);
	224	if (I >= Stop \|\| *I != ' ')
	225	return _error->Error("Malformed status line, no 2nd word");
	226
	227	// Process the flag field
6c139d6e AL	228	WordList FlagList[] = {{"ok",pkgCache::State::Ok},
	229	{"reinstreq",pkgCache::State::ReInstReq},
	230	{"hold",pkgCache::State::HoldInst},
b2e465d6 AL	231	{"hold-reinstreq",pkgCache::State::HoldReInstReq},
	232	{}};
	233	if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
f55a958f AL	234	return _error->Error("Malformed 2nd word in the Status line");
	235
	236	// Isloate the last word
	237	I++;
	238	Start = I;
	239	for(; I < Stop && *I != ' '; I++);
	240	if (I != Stop)
	241	return _error->Error("Malformed Status line, no 3rd word");
	242
	243	// Process the flag field
6c139d6e AL	244	WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
	245	{"unpacked",pkgCache::State::UnPacked},
	246	{"half-configured",pkgCache::State::HalfConfigured},
	247	{"installed",pkgCache::State::Installed},
6c139d6e AL	248	{"half-installed",pkgCache::State::HalfInstalled},
	249	{"config-files",pkgCache::State::ConfigFiles},
	250	{"post-inst-failed",pkgCache::State::HalfConfigured},
b2e465d6 AL	251	{"removal-failed",pkgCache::State::HalfInstalled},
	252	{}};
	253	if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
f55a958f AL	254	return _error->Error("Malformed 3rd word in the Status line");
	255
	256	/* A Status line marks the package as indicating the current
	257	version as well. Only if it is actually installed.. Otherwise
	258	the interesting dpkg handling of the status file creates bogus
	259	entries. */
6c139d6e AL	260	if (!(Pkg->CurrentState == pkgCache::State::NotInstalled \|\|
6c139d6e AL	261	Pkg->CurrentState == pkgCache::State::ConfigFiles))
f55a958f AL	262	{
	263	if (Ver.end() == true)
	264	_error->Warning("Encountered status field in a non-version description");
	265	else
	266	Pkg->CurrentVer = Ver.Index();
	267	}
	268
dcb79bae AL	269	return true;
dcb79bae AL	270	}
a1826878	271
b2e465d6 AL	272	const char debListParser::ConvertRelation(const char I,unsigned int &Op)
	273	{
	274	// Determine the operator
	275	switch (*I)
	276	{
	277	case '<':
	278	I++;
	279	if (*I == '=')
	280	{
	281	I++;
	282	Op = pkgCache::Dep::LessEq;
	283	break;
	284	}
	285
	286	if (*I == '<')
	287	{
	288	I++;
	289	Op = pkgCache::Dep::Less;
	290	break;
	291	}
	292
	293	// < is the same as <= and << is really Cs < for some reason
	294	Op = pkgCache::Dep::LessEq;
	295	break;
	296
	297	case '>':
	298	I++;
	299	if (*I == '=')
	300	{
	301	I++;
	302	Op = pkgCache::Dep::GreaterEq;
	303	break;
	304	}
	305
	306	if (*I == '>')
	307	{
	308	I++;
	309	Op = pkgCache::Dep::Greater;
	310	break;
	311	}
	312
	313	// > is the same as >= and >> is really Cs > for some reason
	314	Op = pkgCache::Dep::GreaterEq;
	315	break;
	316
	317	case '=':
	318	Op = pkgCache::Dep::Equals;
	319	I++;
	320	break;
	321
	322	// HACK around bad package definitions
	323	default:
	324	Op = pkgCache::Dep::Equals;
	325	break;
	326	}
	327	return I;
	328	}
	329
a1826878 AL	330	/}}}/
	331	// ListParser::ParseDepends - Parse a dependency element /{{{/
	332	// ---------------------------------------------------------------------
	333	/* This parses the dependency elements out of a standard string in place,
	334	bit by bit. */
dcb79bae AL	335	const char debListParser::ParseDepends(const char Start,const char *Stop,
dcb79bae AL	336	string &Package,string &Ver,
b2e465d6	337	unsigned int &Op, bool ParseArchFlags)
dcb79bae AL	338	{
	339	// Strip off leading space
	340	for (;Start != Stop && isspace(*Start) != 0; Start++);
	341
	342	// Parse off the package name
	343	const char *I = Start;
	344	for (;I != Stop && isspace(I) == 0 && I != '(' && *I != ')' &&
	345	I != ',' && I != '\|'; I++);
	346
	347	// Malformed, no '('
	348	if (I != Stop && *I == ')')
	349	return 0;
	350
	351	if (I == Start)
	352	return 0;
	353
	354	// Stash the package name
	355	Package.assign(Start,I - Start);
	356
	357	// Skip white space to the '('
	358	for (;I != Stop && isspace(*I) != 0 ; I++);
	359
	360	// Parse a version
	361	if (I != Stop && *I == '(')
	362	{
	363	// Skip the '('
	364	for (I++; I != Stop && isspace(*I) != 0 ; I++);
	365	if (I + 3 >= Stop)
	366	return 0;
b2e465d6	367	I = ConvertRelation(I,Op);
dcb79bae AL	368
	369	// Skip whitespace
	370	for (;I != Stop && isspace(*I) != 0; I++);
	371	Start = I;
	372	for (;I != Stop && *I != ')'; I++);
	373	if (I == Stop \|\| Start == I)
	374	return 0;
	375
02f000a9 AL	376	// Skip trailing whitespace
	377	const char *End = I;
	378	for (; End > Start && isspace(End[-1]); End--);
	379
	380	Ver = string(Start,End-Start);
dcb79bae AL	381	I++;
	382	}
	383	else
	384	{
	385	Ver = string();
6c139d6e	386	Op = pkgCache::Dep::NoOp;
dcb79bae AL	387	}
	388
	389	// Skip whitespace
	390	for (;I != Stop && isspace(*I) != 0; I++);
b2e465d6 AL	391
	392	if (ParseArchFlags == true)
	393	{
	394	string arch = _config->Find("APT::Architecture");
9e10ad8a	395
b2e465d6 AL	396	// Parse an architecture
	397	if (I != Stop && *I == '[')
	398	{
	399	// malformed
	400	I++;
	401	if (I == Stop)
	402	return 0;
	403
	404	const char *End = I;
	405	bool Found = false;
9e10ad8a	406	bool NegArch = false;
b2e465d6 AL	407	while (I != Stop)
	408	{
	409	// look for whitespace or ending ']'
	410	while (End != Stop && !isspace(End) && End != ']')
	411	End++;
	412
	413	if (End == Stop)
	414	return 0;
9e10ad8a AL	415
	416	if (*I == '!')
	417	{
	418	NegArch = true;
	419	I++;
	420	}
	421
3e18cc75	422	if (stringcmp(arch,I,End) == 0)
b2e465d6 AL	423	Found = true;
	424
	425	if (*End++ == ']') {
	426	I = End;
	427	break;
	428	}
	429
	430	I = End;
	431	for (;I != Stop && isspace(*I) != 0; I++);
	432	}
9e10ad8a AL	433
	434	if (NegArch)
	435	Found = !Found;
b2e465d6	436
9e10ad8a	437	if (Found == false)
b2e465d6 AL	438	Package = ""; /* not for this arch */
	439	}
	440
	441	// Skip whitespace
	442	for (;I != Stop && isspace(*I) != 0; I++);
	443	}
	444
dcb79bae	445	if (I != Stop && *I == '\|')
6c139d6e	446	Op \|= pkgCache::Dep::Or;
dcb79bae AL	447
	448	if (I == Stop \|\| I == ',' \|\| I == '\|')
	449	{
	450	if (I != Stop)
	451	for (I++; I != Stop && isspace(*I) != 0; I++);
	452	return I;
	453	}
	454
	455	return 0;
	456	}
	457	/}}}/
	458	// ListParser::ParseDepends - Parse a dependency list /{{{/
	459	// ---------------------------------------------------------------------
	460	/* This is the higher level depends parser. It takes a tag and generates
	461	a complete depends tree for the given version. */
	462	bool debListParser::ParseDepends(pkgCache::VerIterator Ver,
	463	const char *Tag,unsigned int Type)
	464	{
	465	const char *Start;
	466	const char *Stop;
	467	if (Section.Find(Tag,Start,Stop) == false)
	468	return true;
	469
	470	string Package;
	471	string Version;
	472	unsigned int Op;
	473
8efa2a3b	474	while (1)
dcb79bae	475	{
8efa2a3b	476	Start = ParseDepends(Start,Stop,Package,Version,Op);
dcb79bae AL	477	if (Start == 0)
dcb79bae AL	478	return _error->Error("Problem parsing dependency %s",Tag);
8efa2a3b	479
dcb79bae AL	480	if (NewDepends(Ver,Package,Version,Op,Type) == false)
dcb79bae AL	481	return false;
8efa2a3b AL	482	if (Start == Stop)
8efa2a3b AL	483	break;
dcb79bae AL	484	}
	485	return true;
	486	}
	487	/}}}/
	488	// ListParser::ParseProvides - Parse the provides list /{{{/
	489	// ---------------------------------------------------------------------
	490	/* */
	491	bool debListParser::ParseProvides(pkgCache::VerIterator Ver)
	492	{
	493	const char *Start;
	494	const char *Stop;
	495	if (Section.Find("Provides",Start,Stop) == false)
	496	return true;
	497
	498	string Package;
	499	string Version;
	500	unsigned int Op;
	501
	502	while (1)
	503	{
	504	Start = ParseDepends(Start,Stop,Package,Version,Op);
	505	if (Start == 0)
	506	return _error->Error("Problem parsing Provides line");
6c139d6e	507	if (Op != pkgCache::Dep::NoOp)
dcb79bae AL	508	return _error->Error("Malformed provides line");
	509
	510	if (NewProvides(Ver,Package,Version) == false)
	511	return false;
	512
	513	if (Start == Stop)
	514	break;
	515	}
	516
f55a958f AL	517	return true;
	518	}
	519	/}}}/
	520	// ListParser::GrabWord - Matches a word and returns /{{{/
	521	// ---------------------------------------------------------------------
	522	/* Looks for a word in a list of words - for ParseStatus */
b2e465d6	523	bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
f55a958f	524	{
b2e465d6	525	for (unsigned int C = 0; List[C].Str != 0; C++)
f55a958f AL	526	{
	527	if (strcasecmp(Word.c_str(),List[C].Str) == 0)
	528	{
	529	Out = List[C].Val;
	530	return true;
	531	}
	532	}
	533	return false;
	534	}
	535	/}}}/
	536	// ListParser::Step - Move to the next section in the file /{{{/
	537	// ---------------------------------------------------------------------
0149949b	538	/* This has to be carefull to only process the correct architecture */
f55a958f AL	539	bool debListParser::Step()
f55a958f AL	540	{
dcb79bae	541	iOffset = Tags.Offset();
0149949b	542	while (Tags.Step(Section) == true)
ddc1d8d0 AL	543	{
	544	/* See if this is the correct Architecture, if it isn't then we
	545	drop the whole section. A missing arch tag only happens (in theory)
	546	inside the Status file, so that is a positive return */
0149949b AL	547	const char *Start;
	548	const char *Stop;
	549	if (Section.Find("Architecture",Start,Stop) == false)
	550	return true;
9c14e3d6	551
3e18cc75	552	if (stringcmp(Arch,Start,Stop) == 0)
0149949b AL	553	return true;
0149949b AL	554
9c14e3d6	555	if (stringcmp(Start,Stop,"all") == 0)
0149949b	556	return true;
dcb79bae AL	557
dcb79bae AL	558	iOffset = Tags.Offset();
0149949b AL	559	}
0149949b AL	560	return false;
f55a958f AL	561	}
f55a958f AL	562	/}}}/
b0b4efb9 AL	563	// ListParser::LoadReleaseInfo - Load the release information /{{{/
	564	// ---------------------------------------------------------------------
	565	/* */
	566	bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator FileI,
16176b64	567	FileFd &File, string component)
b0b4efb9	568	{
7db98ffc	569	pkgTagFile Tags(&File, File.Size() + 256); // XXX
b0b4efb9 AL	570	pkgTagSection Section;
	571	if (Tags.Step(Section) == false)
	572	return false;
	573
16176b64 MV	574	//mvo: I don't think we need to fill that in (it's unused since apt-0.6)
	575	//FileI->Architecture = WriteUniqString(Arch);
	576
	577	// apt-secure does no longer download individual (per-section) Release
	578	// file. to provide Component pinning we use the section name now
	579	FileI->Component = WriteUniqString(component);
	580
b0b4efb9 AL	581	const char *Start;
b0b4efb9 AL	582	const char *Stop;
7db98ffc	583	if (Section.Find("Suite",Start,Stop) == true)
b0b4efb9 AL	584	FileI->Archive = WriteUniqString(Start,Stop - Start);
	585	if (Section.Find("Component",Start,Stop) == true)
	586	FileI->Component = WriteUniqString(Start,Stop - Start);
	587	if (Section.Find("Version",Start,Stop) == true)
	588	FileI->Version = WriteUniqString(Start,Stop - Start);
	589	if (Section.Find("Origin",Start,Stop) == true)
	590	FileI->Origin = WriteUniqString(Start,Stop - Start);
	591	if (Section.Find("Label",Start,Stop) == true)
	592	FileI->Label = WriteUniqString(Start,Stop - Start);
	593	if (Section.Find("Architecture",Start,Stop) == true)
	594	FileI->Architecture = WriteUniqString(Start,Stop - Start);
0dbb95d8	595
3c124dde AL	596	if (Section.FindFlag("NotAutomatic",FileI->Flags,
3c124dde AL	597	pkgCache::Flag::NotAutomatic) == false)
0dbb95d8	598	_error->Warning("Bad NotAutomatic flag");
16176b64	599
b0b4efb9 AL	600	return !_error->PendingError();
	601	}
	602	/}}}/
b2e465d6 AL	603	// ListParser::GetPrio - Convert the priority from a string /{{{/
	604	// ---------------------------------------------------------------------
	605	/* */
	606	unsigned char debListParser::GetPrio(string Str)
	607	{
	608	unsigned char Out;
	609	if (GrabWord(Str,PrioList,Out) == false)
	610	Out = pkgCache::State::Extra;
	611
	612	return Out;
	613	}
	614	/}}}/