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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: versionmatch.cc,v 1.9 2003/05/19 17:58:26 doogie Exp $
/* ######################################################################

   Version Matching 
   
   This module takes a matching string and a type and locates the version
   record that satisfies the constraint described by the matching string.
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/versionmatch.h>

#include <apt-pkg/strutl.h>
#include <apt-pkg/error.h>

#include <stdio.h>
#include <ctype.h>
									/*}}}*/

// VersionMatch::pkgVersionMatch - Constructor				/*{{{*/
// ---------------------------------------------------------------------
/* Break up the data string according to the selected type */
pkgVersionMatch::pkgVersionMatch(string Data,MatchType Type) : Type(Type)
{
   MatchAll = false;
   VerPrefixMatch = false;
   RelVerPrefixMatch = false;
   
   if (Type == None || Data.length() < 1)
      return;
   
   // Cut up the version representation
   if (Type == Version)
   {
      if (Data.end()[-1] == '*')
      {
	 VerPrefixMatch = true;
	 VerStr = string(Data,0,Data.length()-1);
      }
      else
	 VerStr = Data;
      return;
   }   
   
   if (Type == Release)
   {
      // All empty = match all
      if (Data == "*")
      {
	 MatchAll = true;
	 return;
      }
      
      // Are we a simple specification?
      string::const_iterator I = Data.begin();
      for (; I != Data.end() && *I != '='; I++);
      if (I == Data.end())
      {
	 // Temporary
	 if (isdigit(Data[0]))
	    RelVerStr = Data;
	 else
	    RelRelease = Data;

	 if (RelVerStr.length() > 0 && RelVerStr.end()[-1] == '*')
	 {
	    RelVerPrefixMatch = true;
	    RelVerStr = string(RelVerStr.begin(),RelVerStr.end()-1);
	 }	 
	 return;
      }
            
      char Spec[300];
      char *Fragments[20];
      snprintf(Spec,sizeof(Spec),"%s",Data.c_str());
      if (TokSplitString(',',Spec,Fragments,
			 sizeof(Fragments)/sizeof(Fragments[0])) == false)
      {
	 Type = None;
	 return;
      }
      
      for (unsigned J = 0; Fragments[J] != 0; J++)
      {
	 if (strlen(Fragments[J]) < 3)
	    continue;

	 if (stringcasecmp(Fragments[J],Fragments[J]+2,"v=") == 0)
	    RelVerStr = Fragments[J]+2;
	 else if (stringcasecmp(Fragments[J],Fragments[J]+2,"o=") == 0)
	    RelOrigin = Fragments[J]+2;
	 else if (stringcasecmp(Fragments[J],Fragments[J]+2,"a=") == 0)
	    RelArchive = Fragments[J]+2;
	 else if (stringcasecmp(Fragments[J],Fragments[J]+2,"n=") == 0)
	    RelCodename = Fragments[J]+2;
	 else if (stringcasecmp(Fragments[J],Fragments[J]+2,"l=") == 0)
	    RelLabel = Fragments[J]+2;
	 else if (stringcasecmp(Fragments[J],Fragments[J]+2,"c=") == 0)
	    RelComponent = Fragments[J]+2;
	 else if (stringcasecmp(Fragments[J],Fragments[J]+2,"b=") == 0)
	    RelArchitecture = Fragments[J]+2;
      }

      if (RelVerStr.end()[-1] == '*')
      {
	 RelVerPrefixMatch = true;
	 RelVerStr = string(RelVerStr.begin(),RelVerStr.end()-1);
      }	 
      return;
   }
   
   if (Type == Origin)
   {
      OrSite = Data;
      return;
   }   
}
									/*}}}*/
// VersionMatch::MatchVer - Match a version string with prefixing	/*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgVersionMatch::MatchVer(const char *A,string B,bool Prefix)
{   
   const char *Ab = A;
   const char *Ae = Ab + strlen(A);
   
   // Strings are not a compatible size.
   if (((unsigned)(Ae - Ab) != B.length() && Prefix == false) ||
       (unsigned)(Ae - Ab) < B.length())
      return false;
   
   // Match (leading?)
   if (stringcasecmp(B,Ab,Ab + B.length()) == 0)
      return true;
   
   return false;
}
									/*}}}*/
// VersionMatch::Find - Locate the best match for the select type	/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgCache::VerIterator pkgVersionMatch::Find(pkgCache::PkgIterator Pkg)
{
   pkgCache::VerIterator Ver = Pkg.VersionList();
   for (; Ver.end() == false; Ver++)
   {
      if (Type == Version)
      {
	 if (MatchVer(Ver.VerStr(),VerStr,VerPrefixMatch) == true)
	    return Ver;
	 continue;
      }
      
      for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false; VF++)
	 if (FileMatch(VF.File()) == true)
	    return Ver;
   }
      
   // This will be Ended by now.
   return Ver;
}
									/*}}}*/
// VersionMatch::FileMatch - Match against an index file		/*{{{*/
// ---------------------------------------------------------------------
/* This matcher checks against the release file and the origin location 
   to see if the constraints are met. */
bool pkgVersionMatch::FileMatch(pkgCache::PkgFileIterator File)
{
   if (Type == Release)
   {
      if (MatchAll == true)
	 return true;

/*      cout << RelVerStr << ',' << RelOrigin << ',' << RelArchive << ',' << RelLabel << endl;
      cout << File.Version() << ',' << File.Origin() << ',' << File.Archive() << ',' << File.Label() << endl;*/

      if (RelVerStr.empty() == true && RelOrigin.empty() == true &&
	  RelArchive.empty() == true && RelLabel.empty() == true &&
	  RelRelease.empty() == true && RelCodename.empty() == true &&
	  RelComponent.empty() == true && RelArchitecture.empty() == true)
	 return false;

      if (RelVerStr.empty() == false)
	 if (File->Version == 0 ||
	     MatchVer(File.Version(),RelVerStr,RelVerPrefixMatch) == false)
	    return false;
      if (RelOrigin.empty() == false)
	 if (File->Origin == 0 ||
	     stringcasecmp(RelOrigin,File.Origin()) != 0)
	    return false;
      if (RelArchive.empty() == false)
	 if (File->Archive == 0 ||
	     stringcasecmp(RelArchive,File.Archive()) != 0)
            return false;
      if (RelCodename.empty() == false)
	 if (File->Codename == 0 ||
	     stringcasecmp(RelCodename,File.Codename()) != 0)
            return false;
      if (RelRelease.empty() == false)
	 if ((File->Archive == 0 ||
	     stringcasecmp(RelRelease,File.Archive()) != 0) &&
             (File->Codename == 0 ||
	      stringcasecmp(RelRelease,File.Codename()) != 0))
	       return false;
      if (RelLabel.empty() == false)
	 if (File->Label == 0 ||
	     stringcasecmp(RelLabel,File.Label()) != 0)
	    return false;
      if (RelComponent.empty() == false)
	 if (File->Component == 0 ||
	     stringcasecmp(RelComponent,File.Component()) != 0)
	    return false;
      if (RelArchitecture.empty() == false)
	 if (File->Architecture == 0 ||
	     stringcasecmp(RelArchitecture,File.Architecture()) != 0)
	    return false;
      return true;
   }

   if (Type == Origin)
   {
      if (OrSite.empty() == false) {
	 if (File->Site == 0 || OrSite != File.Site())
	    return false;
      } else // so we are talking about file:// or status file
	 if (strcmp(File.Site(),"") == 0 && File->Archive != 0) // skip the status file
	    return false;
      return (OrSite == File.Site());		/* both strings match */
   }

   return false;
}
									/*}}}*/
Commit	Line	Data
b2e465d6 AL	1	// -- mode: cpp; mode: fold --
b2e465d6 AL	2	// Description /{{{/
acfe7306	3	// $Id: versionmatch.cc,v 1.9 2003/05/19 17:58:26 doogie Exp $
b2e465d6 AL	4	/* ######################################################################
	5
	6	Version Matching
	7
	8	This module takes a matching string and a type and locates the version
	9	record that satisfies the constraint described by the matching string.
	10
	11	##################################################################### */
	12	/}}}/
	13	// Include Files /{{{/
b2e465d6 AL	14	#include <apt-pkg/versionmatch.h>
	15
	16	#include <apt-pkg/strutl.h>
	17	#include <apt-pkg/error.h>
	18
	19	#include <stdio.h>
8d9850a1	20	#include <ctype.h>
b2e465d6 AL	21	/}}}/
	22
	23	// VersionMatch::pkgVersionMatch - Constructor /{{{/
	24	// ---------------------------------------------------------------------
	25	/* Break up the data string according to the selected type */
	26	pkgVersionMatch::pkgVersionMatch(string Data,MatchType Type) : Type(Type)
	27	{
4e0680f9 AL	28	MatchAll = false;
	29	VerPrefixMatch = false;
	30	RelVerPrefixMatch = false;
	31
b2e465d6 AL	32	if (Type == None \|\| Data.length() < 1)
	33	return;
	34
	35	// Cut up the version representation
	36	if (Type == Version)
	37	{
	38	if (Data.end()[-1] == '*')
	39	{
	40	VerPrefixMatch = true;
8d9850a1	41	VerStr = string(Data,0,Data.length()-1);
b2e465d6 AL	42	}
	43	else
	44	VerStr = Data;
	45	return;
	46	}
	47
	48	if (Type == Release)
	49	{
	50	// All empty = match all
	51	if (Data == "*")
0a5e4a03 AL	52	{
0a5e4a03 AL	53	MatchAll = true;
b2e465d6	54	return;
0a5e4a03 AL	55	}
0a5e4a03 AL	56
b2e465d6	57	// Are we a simple specification?
8d9850a1 AL	58	string::const_iterator I = Data.begin();
8d9850a1 AL	59	for (; I != Data.end() && *I != '='; I++);
b2e465d6 AL	60	if (I == Data.end())
	61	{
	62	// Temporary
	63	if (isdigit(Data[0]))
	64	RelVerStr = Data;
	65	else
efc487fb DK	66	RelRelease = Data;
efc487fb DK	67
b8b7c37d	68	if (RelVerStr.length() > 0 && RelVerStr.end()[-1] == '*')
b2e465d6 AL	69	{
	70	RelVerPrefixMatch = true;
	71	RelVerStr = string(RelVerStr.begin(),RelVerStr.end()-1);
	72	}
	73	return;
	74	}
	75
	76	char Spec[300];
	77	char *Fragments[20];
	78	snprintf(Spec,sizeof(Spec),"%s",Data.c_str());
	79	if (TokSplitString(',',Spec,Fragments,
	80	sizeof(Fragments)/sizeof(Fragments[0])) == false)
	81	{
	82	Type = None;
	83	return;
	84	}
	85
	86	for (unsigned J = 0; Fragments[J] != 0; J++)
	87	{
	88	if (strlen(Fragments[J]) < 3)
	89	continue;
efc487fb	90
b2e465d6 AL	91	if (stringcasecmp(Fragments[J],Fragments[J]+2,"v=") == 0)
	92	RelVerStr = Fragments[J]+2;
	93	else if (stringcasecmp(Fragments[J],Fragments[J]+2,"o=") == 0)
	94	RelOrigin = Fragments[J]+2;
	95	else if (stringcasecmp(Fragments[J],Fragments[J]+2,"a=") == 0)
	96	RelArchive = Fragments[J]+2;
efc487fb DK	97	else if (stringcasecmp(Fragments[J],Fragments[J]+2,"n=") == 0)
efc487fb DK	98	RelCodename = Fragments[J]+2;
b2e465d6 AL	99	else if (stringcasecmp(Fragments[J],Fragments[J]+2,"l=") == 0)
	100	RelLabel = Fragments[J]+2;
	101	else if (stringcasecmp(Fragments[J],Fragments[J]+2,"c=") == 0)
	102	RelComponent = Fragments[J]+2;
5dd4c8b8 DK	103	else if (stringcasecmp(Fragments[J],Fragments[J]+2,"b=") == 0)
5dd4c8b8 DK	104	RelArchitecture = Fragments[J]+2;
b2e465d6	105	}
efc487fb	106
b2e465d6 AL	107	if (RelVerStr.end()[-1] == '*')
	108	{
	109	RelVerPrefixMatch = true;
	110	RelVerStr = string(RelVerStr.begin(),RelVerStr.end()-1);
	111	}
	112	return;
	113	}
	114
	115	if (Type == Origin)
	116	{
	117	OrSite = Data;
	118	return;
	119	}
	120	}
	121	/}}}/
	122	// VersionMatch::MatchVer - Match a version string with prefixing /{{{/
	123	// ---------------------------------------------------------------------
	124	/* */
	125	bool pkgVersionMatch::MatchVer(const char *A,string B,bool Prefix)
	126	{
	127	const char *Ab = A;
	128	const char *Ae = Ab + strlen(A);
	129
	130	// Strings are not a compatible size.
d320fdc3	131	if (((unsigned)(Ae - Ab) != B.length() && Prefix == false) \|\|
b2e465d6 AL	132	(unsigned)(Ae - Ab) < B.length())
	133	return false;
	134
	135	// Match (leading?)
8d9850a1	136	if (stringcasecmp(B,Ab,Ab + B.length()) == 0)
b2e465d6 AL	137	return true;
	138
	139	return false;
	140	}
	141	/}}}/
	142	// VersionMatch::Find - Locate the best match for the select type /{{{/
	143	// ---------------------------------------------------------------------
	144	/* */
	145	pkgCache::VerIterator pkgVersionMatch::Find(pkgCache::PkgIterator Pkg)
	146	{
	147	pkgCache::VerIterator Ver = Pkg.VersionList();
	148	for (; Ver.end() == false; Ver++)
	149	{
	150	if (Type == Version)
	151	{
	152	if (MatchVer(Ver.VerStr(),VerStr,VerPrefixMatch) == true)
	153	return Ver;
	154	continue;
	155	}
	156
	157	for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false; VF++)
	158	if (FileMatch(VF.File()) == true)
	159	return Ver;
	160	}
	161
	162	// This will be Ended by now.
	163	return Ver;
	164	}
	165	/}}}/
	166	// VersionMatch::FileMatch - Match against an index file /{{{/
	167	// ---------------------------------------------------------------------
	168	/* This matcher checks against the release file and the origin location
	169	to see if the constraints are met. */
	170	bool pkgVersionMatch::FileMatch(pkgCache::PkgFileIterator File)
	171	{
	172	if (Type == Release)
	173	{
0a5e4a03 AL	174	if (MatchAll == true)
0a5e4a03 AL	175	return true;
efc487fb	176
b2e465d6	177	/* cout << RelVerStr << ',' << RelOrigin << ',' << RelArchive << ',' << RelLabel << endl;
af87ab54	178	cout << File.Version() << ',' << File.Origin() << ',' << File.Archive() << ',' << File.Label() << endl;*/
efc487fb	179
b2e465d6 AL	180	if (RelVerStr.empty() == true && RelOrigin.empty() == true &&
b2e465d6 AL	181	RelArchive.empty() == true && RelLabel.empty() == true &&
efc487fb	182	RelRelease.empty() == true && RelCodename.empty() == true &&
5dd4c8b8	183	RelComponent.empty() == true && RelArchitecture.empty() == true)
b2e465d6	184	return false;
efc487fb	185
b2e465d6 AL	186	if (RelVerStr.empty() == false)
	187	if (File->Version == 0 \|\|
	188	MatchVer(File.Version(),RelVerStr,RelVerPrefixMatch) == false)
	189	return false;
	190	if (RelOrigin.empty() == false)
	191	if (File->Origin == 0 \|\|
	192	stringcasecmp(RelOrigin,File.Origin()) != 0)
	193	return false;
	194	if (RelArchive.empty() == false)
efc487fb	195	if (File->Archive == 0 \|\|
b2e465d6	196	stringcasecmp(RelArchive,File.Archive()) != 0)
efc487fb DK	197	return false;
	198	if (RelCodename.empty() == false)
	199	if (File->Codename == 0 \|\|
	200	stringcasecmp(RelCodename,File.Codename()) != 0)
	201	return false;
	202	if (RelRelease.empty() == false)
	203	if ((File->Archive == 0 \|\|
	204	stringcasecmp(RelRelease,File.Archive()) != 0) &&
	205	(File->Codename == 0 \|\|
	206	stringcasecmp(RelRelease,File.Codename()) != 0))
	207	return false;
b2e465d6 AL	208	if (RelLabel.empty() == false)
	209	if (File->Label == 0 \|\|
	210	stringcasecmp(RelLabel,File.Label()) != 0)
	211	return false;
	212	if (RelComponent.empty() == false)
	213	if (File->Component == 0 \|\|
af87ab54	214	stringcasecmp(RelComponent,File.Component()) != 0)
b2e465d6	215	return false;
5dd4c8b8 DK	216	if (RelArchitecture.empty() == false)
	217	if (File->Architecture == 0 \|\|
	218	stringcasecmp(RelArchitecture,File.Architecture()) != 0)
	219	return false;
b2e465d6 AL	220	return true;
b2e465d6 AL	221	}
efc487fb	222
b2e465d6 AL	223	if (Type == Origin)
b2e465d6 AL	224	{
acfe7306 AL	225	if (OrSite.empty() == false) {
	226	if (File->Site == 0 \|\| OrSite != File.Site())
	227	return false;
	228	} else // so we are talking about file:// or status file
	229	if (strcmp(File.Site(),"") == 0 && File->Archive != 0) // skip the status file
	230	return false;
5955efd4	231	return (OrSite == File.Site()); /* both strings match */
b2e465d6	232	}
efc487fb	233
b2e465d6 AL	234	return false;
	235	}
	236	/}}}/