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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: tagfile.cc,v 1.37.2.2 2003/12/31 16:02:30 mdz Exp $
/* ######################################################################

   Fast scanner for RFC-822 type header information
   
   This uses a rotating buffer to load the package information into.
   The scanner runs over it and isolates and indexes a single section.
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/tagfile.h"
#endif

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

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

using std::string;

// TagFile::pkgTagFile - Constructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgTagFile::pkgTagFile(FileFd *pFd,unsigned long Size) :
     Fd(*pFd),
     Size(Size)
{
   if (Fd.IsOpen() == false || Fd.Size() == 0)
   {
      Buffer = 0;
      Start = End = Buffer = 0;
      iOffset = 0;
      Map = NULL;
      return;
   }
   
   Map = new MMap (Fd, MMap::Public | MMap::ReadOnly);
   Buffer = (char *) Map->Data ();
   Start = Buffer;
   End = Buffer + Map->Size ();
   iOffset = 0;
}
									/*}}}*/
// TagFile::~pkgTagFile - Destructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgTagFile::~pkgTagFile()
{
   delete Map;
}
									/*}}}*/
// TagFile::Step - Advance to the next section				/*{{{*/
// ---------------------------------------------------------------------
/* If the Section Scanner fails we refill the buffer and try again. */
bool pkgTagFile::Step(pkgTagSection &Tag)
{
   if (Start == End)
      return false;

   if (Tag.Scan(Start,End - Start) == false)
   {
      return _error->Error(_("Unable to parse package file %s (1)"),
	      Fd.Name().c_str());
   }
   Start += Tag.size();
   iOffset += Tag.size();

   Tag.Trim();
   return true;
}
									/*}}}*/
// TagFile::Jump - Jump to a pre-recorded location in the file		/*{{{*/
// ---------------------------------------------------------------------
/* This jumps to a pre-recorded file location and reads the record
   that is there */
bool pkgTagFile::Jump(pkgTagSection &Tag,unsigned long Offset)
{
   // We are within a buffer space of the next hit..
   if (Offset >= iOffset && iOffset + (End - Start) > Offset)
   {
      unsigned long Dist = Offset - iOffset;
      Start += Dist;
      iOffset += Dist;
      return Step(Tag);
   }

   // Reposition and reload..
   iOffset = Offset;
   Start = Buffer + iOffset;
   
   // Start != End is a special case to not fail on empty TagFiles
   if (Start != End && Tag.Scan(Start,End - Start) == false)
      return _error->Error(_("Unable to parse package file %s (2)"),Fd.Name().c_str());
   
   return true;
}
									/*}}}*/
// TagSection::Scan - Scan for the end of the header information	/*{{{*/
// ---------------------------------------------------------------------
/* This looks for the first double new line in the data stream. It also
   indexes the tags in the section. This very simple hash function for the
   first 3 letters gives very good performance on the debian package files */
inline static unsigned long AlphaHash(const char *Text, const char *End = 0)
{
   unsigned long Res = 0;
   for (; Text != End && *Text != ':' && *Text != 0; Text++)
      Res = (unsigned long)(*Text) ^ (Res << 2);
   return Res & 0xFF;
}

bool pkgTagSection::Scan(const char *Start,unsigned long MaxLength)
{
   const char *End = Start + MaxLength;
   Stop = Section = Start;
   memset(AlphaIndexes,0,sizeof(AlphaIndexes));

   if (Stop == 0 || MaxLength == 0)
      return false;
   
   TagCount = 0;
   while (TagCount+1 < sizeof(Indexes)/sizeof(Indexes[0]) && Stop < End)
   {
      // Start a new index and add it to the hash
      if (isspace(Stop[0]) == 0)
      {
	 Indexes[TagCount++] = Stop - Section;
	 AlphaIndexes[AlphaHash(Stop,End)] = TagCount;
      }

      Stop = (const char *)memchr(Stop,'\n',End - Stop);
      
      if (Stop == 0)
	 return false;
      
      for (; Stop+1 < End && Stop[1] == '\r'; Stop++);

      // Double newline marks the end of the record
      if (Stop+1 < End && Stop[1] == '\n')
      {
	 Indexes[TagCount] = Stop - Section;
	 for (; Stop < End && (Stop[0] == '\n' || Stop[0] == '\r'); Stop++);
	 return true;
      }
      
      Stop++;
   }

   if ((Stop+1 >= End) && (End[-1] == '\n' || End[-1] == '\r'))
   {
       Indexes[TagCount] = (End - 1) - Section;
       return true;
   }

   return false;
}
									/*}}}*/
// TagSection::Trim - Trim off any trailing garbage			/*{{{*/
// ---------------------------------------------------------------------
/* There should be exactly 1 newline at the end of the buffer, no more. */
void pkgTagSection::Trim()
{
   for (; Stop > Section + 2 && (Stop[-2] == '\n' || Stop[-2] == '\r'); Stop--);
}
									/*}}}*/
// TagSection::Find - Locate a tag					/*{{{*/
// ---------------------------------------------------------------------
/* This searches the section for a tag that matches the given string. */
bool pkgTagSection::Find(const char *Tag,unsigned &Pos) const
{
   unsigned int Length = strlen(Tag);
   unsigned int I = AlphaIndexes[AlphaHash(Tag)];
   if (I == 0)
      return false;
   I--;
   
   for (unsigned int Counter = 0; Counter != TagCount; Counter++, 
	I = (I+1)%TagCount)
   {
      const char *St;
      St = Section + Indexes[I];
      if (strncasecmp(Tag,St,Length) != 0)
	 continue;

      // Make sure the colon is in the right place
      const char *C = St + Length;
      for (; isspace(*C) != 0; C++);
      if (*C != ':')
	 continue;
      Pos = I;
      return true;
   }

   Pos = 0;
   return false;
}
									/*}}}*/
// TagSection::Find - Locate a tag					/*{{{*/
// ---------------------------------------------------------------------
/* This searches the section for a tag that matches the given string. */
bool pkgTagSection::Find(const char *Tag,const char *&Start,
		         const char *&End) const
{
   unsigned int Length = strlen(Tag);
   unsigned int I = AlphaIndexes[AlphaHash(Tag)];
   if (I == 0)
      return false;
   I--;
   
   for (unsigned int Counter = 0; Counter != TagCount; Counter++, 
	I = (I+1)%TagCount)
   {
      const char *St;
      St = Section + Indexes[I];
      if (strncasecmp(Tag,St,Length) != 0)
	 continue;
      
      // Make sure the colon is in the right place
      const char *C = St + Length;
      for (; isspace(*C) != 0; C++);
      if (*C != ':')
	 continue;

      // Strip off the gunk from the start end
      Start = C;
      End = Section + Indexes[I+1];
      if (Start >= End)
	 return _error->Error("Internal parsing error");
      
      for (; (isspace(*Start) != 0 || *Start == ':') && Start < End; Start++);
      for (; isspace(End[-1]) != 0 && End > Start; End--);
      
      return true;
   }
   
   Start = End = 0;
   return false;
}
									/*}}}*/
// TagSection::FindS - Find a string					/*{{{*/
// ---------------------------------------------------------------------
/* */
string pkgTagSection::FindS(const char *Tag) const
{
   const char *Start;
   const char *End;
   if (Find(Tag,Start,End) == false)
      return string();
   return string(Start,End);      
}
									/*}}}*/
// TagSection::FindI - Find an integer					/*{{{*/
// ---------------------------------------------------------------------
/* */
signed int pkgTagSection::FindI(const char *Tag,signed long Default) const
{
   const char *Start;
   const char *Stop;
   if (Find(Tag,Start,Stop) == false)
      return Default;

   // Copy it into a temp buffer so we can use strtol
   char S[300];
   if ((unsigned)(Stop - Start) >= sizeof(S))
      return Default;
   strncpy(S,Start,Stop-Start);
   S[Stop - Start] = 0;
   
   char *End;
   signed long Result = strtol(S,&End,10);
   if (S == End)
      return Default;
   return Result;
}
									/*}}}*/
// TagSection::FindFlag - Locate a yes/no type flag			/*{{{*/
// ---------------------------------------------------------------------
/* The bits marked in Flag are masked on/off in Flags */
bool pkgTagSection::FindFlag(const char *Tag,unsigned long &Flags,
			     unsigned long Flag) const
{
   const char *Start;
   const char *Stop;
   if (Find(Tag,Start,Stop) == false)
      return true;
   
   switch (StringToBool(string(Start,Stop)))
   {     
      case 0:
      Flags &= ~Flag;
      return true;

      case 1:
      Flags |= Flag;
      return true;

      default:
      _error->Warning("Unknown flag value: %s",string(Start,Stop).c_str());
      return true;
   }
   return true;
}
									/*}}}*/

// TFRewrite - Rewrite a control record					/*{{{*/
// ---------------------------------------------------------------------
/* This writes the control record to stdout rewriting it as necessary. The
   override map item specificies the rewriting rules to follow. This also
   takes the time to sort the feild list. */

/* The order of this list is taken from dpkg source lib/parse.c the fieldinfos
   array. */
static const char *iTFRewritePackageOrder[] = {
                          "Package",
                          "Essential",
                          "Status",
                          "Priority",
                          "Section",
                          "Installed-Size",
                          "Maintainer",
                          "Architecture",
                          "Source",
                          "Version",
                           "Revision",         // Obsolete
                           "Config-Version",   // Obsolete
                          "Replaces",
                          "Provides",
                          "Depends",
                          "Pre-Depends",
                          "Recommends",
                          "Suggests",
                          "Conflicts",
                          "Conffiles",
                          "Filename",
                          "Size",
                          "MD5Sum",
                          "SHA1",
                          "SHA256",
                           "MSDOS-Filename",   // Obsolete
                          "Description",
                          0};
static const char *iTFRewriteSourceOrder[] = {"Package",
                                      "Source",
                                      "Binary",
                                      "Version",
                                      "Priority",
                                      "Section",
                                      "Maintainer",
                                      "Build-Depends",
                                      "Build-Depends-Indep",
                                      "Build-Conflicts",
                                      "Build-Conflicts-Indep",
                                      "Architecture",
                                      "Standards-Version",
                                      "Format",
                                      "Directory",
                                      "Files",
                                      0};   

/* Two levels of initialization are used because gcc will set the symbol
   size of an array to the length of the array, causing dynamic relinking 
   errors. Doing this makes the symbol size constant */
const char **TFRewritePackageOrder = iTFRewritePackageOrder;
const char **TFRewriteSourceOrder = iTFRewriteSourceOrder;
   
bool TFRewrite(FILE *Output,pkgTagSection const &Tags,const char *Order[],
	       TFRewriteData *Rewrite)
{
   unsigned char Visited[256];   // Bit 1 is Order, Bit 2 is Rewrite
   for (unsigned I = 0; I != 256; I++)
      Visited[I] = 0;

   // Set new tag up as necessary.
   for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
   {
      if (Rewrite[J].NewTag == 0)
	 Rewrite[J].NewTag = Rewrite[J].Tag;
   }
   
   // Write all all of the tags, in order.
   for (unsigned int I = 0; Order[I] != 0; I++)
   {
      bool Rewritten = false;
      
      // See if this is a field that needs to be rewritten
      for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
      {
	 if (strcasecmp(Rewrite[J].Tag,Order[I]) == 0)
	 {
	    Visited[J] |= 2;
	    if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
	    {
	       if (isspace(Rewrite[J].Rewrite[0]))
		  fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
	       else
		  fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
	    }
	    
	    Rewritten = true;
	    break;
	 }
      }      
	    
      // See if it is in the fragment
      unsigned Pos;
      if (Tags.Find(Order[I],Pos) == false)
	 continue;
      Visited[Pos] |= 1;

      if (Rewritten == true)
	 continue;
      
      /* Write out this element, taking a moment to rewrite the tag
         in case of changes of case. */
      const char *Start;
      const char *Stop;
      Tags.Get(Start,Stop,Pos);
      
      if (fputs(Order[I],Output) < 0)
	 return _error->Errno("fputs","IO Error to output");
      Start += strlen(Order[I]);
      if (fwrite(Start,Stop - Start,1,Output) != 1)
	 return _error->Errno("fwrite","IO Error to output");
      if (Stop[-1] != '\n')
	 fprintf(Output,"\n");
   }   

   // Now write all the old tags that were missed.
   for (unsigned int I = 0; I != Tags.Count(); I++)
   {
      if ((Visited[I] & 1) == 1)
	 continue;

      const char *Start;
      const char *Stop;
      Tags.Get(Start,Stop,I);
      const char *End = Start;
      for (; End < Stop && *End != ':'; End++);

      // See if this is a field that needs to be rewritten
      bool Rewritten = false;
      for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
      {
	 if (stringcasecmp(Start,End,Rewrite[J].Tag) == 0)
	 {
	    Visited[J] |= 2;
	    if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
	    {
	       if (isspace(Rewrite[J].Rewrite[0]))
		  fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
	       else
		  fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
	    }
	    
	    Rewritten = true;
	    break;
	 }
      }      
      
      if (Rewritten == true)
	 continue;
      
      // Write out this element
      if (fwrite(Start,Stop - Start,1,Output) != 1)
	 return _error->Errno("fwrite","IO Error to output");
      if (Stop[-1] != '\n')
	 fprintf(Output,"\n");
   }
   
   // Now write all the rewrites that were missed
   for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
   {
      if ((Visited[J] & 2) == 2)
	 continue;
      
      if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
      {
	 if (isspace(Rewrite[J].Rewrite[0]))
	    fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
	 else
	    fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
      }      
   }
      
   return true;
}
									/*}}}*/
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
b3d44315	3	// $Id: tagfile.cc,v 1.37.2.2 2003/12/31 16:02:30 mdz Exp $
578bfd0a AL	4	/* ######################################################################
	5
	6	Fast scanner for RFC-822 type header information
	7
ad00ae81	8	This uses a rotating buffer to load the package information into.
578bfd0a AL	9	The scanner runs over it and isolates and indexes a single section.
	10
	11	##################################################################### */
	12	/}}}/
	13	// Include Files /{{{/
6c139d6e	14	#ifdef __GNUG__
094a497d	15	#pragma implementation "apt-pkg/tagfile.h"
6c139d6e AL	16	#endif
6c139d6e AL	17
094a497d AL	18	#include <apt-pkg/tagfile.h>
094a497d AL	19	#include <apt-pkg/error.h>
cdcc6d34	20	#include <apt-pkg/strutl.h>
578bfd0a	21
b2e465d6 AL	22	#include <apti18n.h>
b2e465d6 AL	23
578bfd0a AL	24	#include <string>
578bfd0a AL	25	#include <stdio.h>
851a45a8	26	#include <ctype.h>
578bfd0a AL	27	/}}}/
578bfd0a AL	28
851a45a8 AL	29	using std::string;
851a45a8 AL	30
578bfd0a AL	31	// TagFile::pkgTagFile - Constructor /{{{/
	32	// ---------------------------------------------------------------------
	33	/* */
b3d44315 MV	34	pkgTagFile::pkgTagFile(FileFd *pFd,unsigned long Size) :
	35	Fd(*pFd),
	36	Size(Size)
578bfd0a	37	{
432b168c	38	if (Fd.IsOpen() == false \|\| Fd.Size() == 0)
0e72dd52 AL	39	{
	40	Buffer = 0;
	41	Start = End = Buffer = 0;
0e72dd52	42	iOffset = 0;
432b168c	43	Map = NULL;
0e72dd52 AL	44	return;
	45	}
	46
432b168c MV	47	Map = new MMap (Fd, MMap::Public \| MMap::ReadOnly);
	48	Buffer = (char *) Map->Data ();
	49	Start = Buffer;
	50	End = Buffer + Map->Size ();
dcb79bae	51	iOffset = 0;
578bfd0a AL	52	}
578bfd0a AL	53	/}}}/
b2e465d6	54	// TagFile::~pkgTagFile - Destructor /{{{/
29f7b36c AL	55	// ---------------------------------------------------------------------
	56	/* */
	57	pkgTagFile::~pkgTagFile()
	58	{
432b168c	59	delete Map;
29f7b36c AL	60	}
29f7b36c AL	61	/}}}/
578bfd0a AL	62	// TagFile::Step - Advance to the next section /{{{/
	63	// ---------------------------------------------------------------------
	64	/* If the Section Scanner fails we refill the buffer and try again. */
	65	bool pkgTagFile::Step(pkgTagSection &Tag)
	66	{
432b168c MV	67	if (Start == End)
	68	return false;
	69
0852eaef AL	70	if (Tag.Scan(Start,End - Start) == false)
0852eaef AL	71	{
432b168c MV	72	return _error->Error(_("Unable to parse package file %s (1)"),
432b168c MV	73	Fd.Name().c_str());
613f9499	74	}
dcb79bae AL	75	Start += Tag.size();
dcb79bae AL	76	iOffset += Tag.size();
b2e465d6 AL	77
b2e465d6 AL	78	Tag.Trim();
578bfd0a AL	79	return true;
	80	}
	81	/}}}/
ad00ae81 AL	82	// TagFile::Jump - Jump to a pre-recorded location in the file /{{{/
ad00ae81 AL	83	// ---------------------------------------------------------------------
03e39e59 AL	84	/* This jumps to a pre-recorded file location and reads the record
03e39e59 AL	85	that is there */
ad00ae81 AL	86	bool pkgTagFile::Jump(pkgTagSection &Tag,unsigned long Offset)
ad00ae81 AL	87	{
b2e465d6 AL	88	// We are within a buffer space of the next hit..
	89	if (Offset >= iOffset && iOffset + (End - Start) > Offset)
	90	{
	91	unsigned long Dist = Offset - iOffset;
	92	Start += Dist;
	93	iOffset += Dist;
	94	return Step(Tag);
	95	}
	96
	97	// Reposition and reload..
ad00ae81	98	iOffset = Offset;
432b168c	99	Start = Buffer + iOffset;
0852eaef	100
b90d7d85	101	// Start != End is a special case to not fail on empty TagFiles
c08447c8	102	if (Start != End && Tag.Scan(Start,End - Start) == false)
b2e465d6	103	return _error->Error(_("Unable to parse package file %s (2)"),Fd.Name().c_str());
06bba740	104
ad00ae81 AL	105	return true;
	106	}
	107	/}}}/
578bfd0a AL	108	// TagSection::Scan - Scan for the end of the header information /{{{/
	109	// ---------------------------------------------------------------------
	110	/* This looks for the first double new line in the data stream. It also
c1a22377 AL	111	indexes the tags in the section. This very simple hash function for the
c1a22377 AL	112	first 3 letters gives very good performance on the debian package files */
b2e465d6 AL	113	inline static unsigned long AlphaHash(const char Text, const char End = 0)
	114	{
	115	unsigned long Res = 0;
	116	for (; Text != End && Text != ':' && Text != 0; Text++)
	117	Res = (unsigned long)(*Text) ^ (Res << 2);
	118	return Res & 0xFF;
	119	}
	120
0852eaef	121	bool pkgTagSection::Scan(const char *Start,unsigned long MaxLength)
578bfd0a AL	122	{
	123	const char *End = Start + MaxLength;
	124	Stop = Section = Start;
c1a22377	125	memset(AlphaIndexes,0,sizeof(AlphaIndexes));
c7b5ce1c	126
432b168c	127	if (Stop == 0 \|\| MaxLength == 0)
0852eaef	128	return false;
578bfd0a AL	129
578bfd0a AL	130	TagCount = 0;
fd71171a	131	while (TagCount+1 < sizeof(Indexes)/sizeof(Indexes[0]) && Stop < End)
578bfd0a	132	{
90d64280	133	// Start a new index and add it to the hash
c1a22377 AL	134	if (isspace(Stop[0]) == 0)
	135	{
	136	Indexes[TagCount++] = Stop - Section;
b2e465d6	137	AlphaIndexes[AlphaHash(Stop,End)] = TagCount;
c1a22377	138	}
0a8e3465	139
c1a22377	140	Stop = (const char *)memchr(Stop,'\n',End - Stop);
0a8e3465	141
c1a22377	142	if (Stop == 0)
0852eaef	143	return false;
138d4b3d	144
b8b7c37d	145	for (; Stop+1 < End && Stop[1] == '\r'; Stop++);
c1a22377	146
f3bcc383 AL	147	// Double newline marks the end of the record
f3bcc383 AL	148	if (Stop+1 < End && Stop[1] == '\n')
578bfd0a	149	{
578bfd0a	150	Indexes[TagCount] = Stop - Section;
fd71171a	151	for (; Stop < End && (Stop[0] == '\n' \|\| Stop[0] == '\r'); Stop++);
0852eaef	152	return true;
578bfd0a AL	153	}
578bfd0a AL	154
c1a22377 AL	155	Stop++;
c1a22377 AL	156	}
138d4b3d	157
432b168c MV	158	if ((Stop+1 >= End) && (End[-1] == '\n' \|\| End[-1] == '\r'))
	159	{
	160	Indexes[TagCount] = (End - 1) - Section;
	161	return true;
	162	}
	163
0852eaef	164	return false;
578bfd0a AL	165	}
578bfd0a AL	166	/}}}/
b2e465d6 AL	167	// TagSection::Trim - Trim off any trailing garbage /{{{/
	168	// ---------------------------------------------------------------------
	169	/* There should be exactly 1 newline at the end of the buffer, no more. */
	170	void pkgTagSection::Trim()
	171	{
	172	for (; Stop > Section + 2 && (Stop[-2] == '\n' \|\| Stop[-2] == '\r'); Stop--);
	173	}
	174	/}}}/
578bfd0a AL	175	// TagSection::Find - Locate a tag /{{{/
	176	// ---------------------------------------------------------------------
	177	/* This searches the section for a tag that matches the given string. */
b2e465d6	178	bool pkgTagSection::Find(const char *Tag,unsigned &Pos) const
578bfd0a AL	179	{
578bfd0a AL	180	unsigned int Length = strlen(Tag);
b2e465d6	181	unsigned int I = AlphaIndexes[AlphaHash(Tag)];
c1a22377 AL	182	if (I == 0)
	183	return false;
	184	I--;
	185
	186	for (unsigned int Counter = 0; Counter != TagCount; Counter++,
	187	I = (I+1)%TagCount)
578bfd0a	188	{
c1a22377 AL	189	const char *St;
	190	St = Section + Indexes[I];
	191	if (strncasecmp(Tag,St,Length) != 0)
578bfd0a AL	192	continue;
578bfd0a AL	193
b2e465d6 AL	194	// Make sure the colon is in the right place
	195	const char *C = St + Length;
	196	for (; isspace(*C) != 0; C++);
	197	if (*C != ':')
	198	continue;
	199	Pos = I;
	200	return true;
	201	}
	202
	203	Pos = 0;
	204	return false;
	205	}
	206	/}}}/
	207	// TagSection::Find - Locate a tag /{{{/
	208	// ---------------------------------------------------------------------
	209	/* This searches the section for a tag that matches the given string. */
	210	bool pkgTagSection::Find(const char Tag,const char &Start,
	211	const char *&End) const
	212	{
	213	unsigned int Length = strlen(Tag);
	214	unsigned int I = AlphaIndexes[AlphaHash(Tag)];
	215	if (I == 0)
	216	return false;
	217	I--;
	218
	219	for (unsigned int Counter = 0; Counter != TagCount; Counter++,
	220	I = (I+1)%TagCount)
	221	{
	222	const char *St;
	223	St = Section + Indexes[I];
	224	if (strncasecmp(Tag,St,Length) != 0)
	225	continue;
	226
578bfd0a	227	// Make sure the colon is in the right place
c1a22377	228	const char *C = St + Length;
578bfd0a AL	229	for (; isspace(*C) != 0; C++);
	230	if (*C != ':')
	231	continue;
	232
	233	// Strip off the gunk from the start end
	234	Start = C;
	235	End = Section + Indexes[I+1];
06bba740 AL	236	if (Start >= End)
	237	return _error->Error("Internal parsing error");
	238
578bfd0a AL	239	for (; (isspace(Start) != 0 \|\| Start == ':') && Start < End; Start++);
578bfd0a AL	240	for (; isspace(End[-1]) != 0 && End > Start; End--);
06bba740	241
578bfd0a AL	242	return true;
578bfd0a AL	243	}
c1a22377	244
578bfd0a AL	245	Start = End = 0;
	246	return false;
	247	}
	248	/}}}/
0e66b144	249	// TagSection::FindS - Find a string /{{{/
a05599f1 AL	250	// ---------------------------------------------------------------------
a05599f1 AL	251	/* */
b2e465d6	252	string pkgTagSection::FindS(const char *Tag) const
a05599f1 AL	253	{
	254	const char *Start;
	255	const char *End;
	256	if (Find(Tag,Start,End) == false)
	257	return string();
	258	return string(Start,End);
	259	}
	260	/}}}/
	261	// TagSection::FindI - Find an integer /{{{/
	262	// ---------------------------------------------------------------------
	263	/* */
b2e465d6	264	signed int pkgTagSection::FindI(const char *Tag,signed long Default) const
a05599f1 AL	265	{
a05599f1 AL	266	const char *Start;
b0b4efb9 AL	267	const char *Stop;
	268	if (Find(Tag,Start,Stop) == false)
	269	return Default;
	270
	271	// Copy it into a temp buffer so we can use strtol
	272	char S[300];
	273	if ((unsigned)(Stop - Start) >= sizeof(S))
	274	return Default;
	275	strncpy(S,Start,Stop-Start);
	276	S[Stop - Start] = 0;
	277
	278	char *End;
	279	signed long Result = strtol(S,&End,10);
	280	if (S == End)
	281	return Default;
	282	return Result;
	283	}
	284	/}}}/
	285	// TagSection::FindFlag - Locate a yes/no type flag /{{{/
	286	// ---------------------------------------------------------------------
	287	/* The bits marked in Flag are masked on/off in Flags */
	288	bool pkgTagSection::FindFlag(const char *Tag,unsigned long &Flags,
b2e465d6	289	unsigned long Flag) const
b0b4efb9 AL	290	{
	291	const char *Start;
	292	const char *Stop;
	293	if (Find(Tag,Start,Stop) == false)
	294	return true;
a05599f1	295
b0b4efb9 AL	296	switch (StringToBool(string(Start,Stop)))
	297	{
	298	case 0:
	299	Flags &= ~Flag;
	300	return true;
	301
	302	case 1:
	303	Flags \|= Flag;
	304	return true;
	305
	306	default:
b2e465d6	307	_error->Warning("Unknown flag value: %s",string(Start,Stop).c_str());
b0b4efb9 AL	308	return true;
	309	}
	310	return true;
a05599f1 AL	311	}
a05599f1 AL	312	/}}}/
b2e465d6 AL	313
	314	// TFRewrite - Rewrite a control record /{{{/
	315	// ---------------------------------------------------------------------
	316	/* This writes the control record to stdout rewriting it as necessary. The
	317	override map item specificies the rewriting rules to follow. This also
	318	takes the time to sort the feild list. */
	319
	320	/* The order of this list is taken from dpkg source lib/parse.c the fieldinfos
	321	array. */
	322	static const char *iTFRewritePackageOrder[] = {
	323	"Package",
	324	"Essential",
	325	"Status",
	326	"Priority",
	327	"Section",
	328	"Installed-Size",
	329	"Maintainer",
	330	"Architecture",
	331	"Source",
	332	"Version",
	333	"Revision", // Obsolete
	334	"Config-Version", // Obsolete
	335	"Replaces",
	336	"Provides",
	337	"Depends",
	338	"Pre-Depends",
	339	"Recommends",
	340	"Suggests",
	341	"Conflicts",
	342	"Conffiles",
	343	"Filename",
	344	"Size",
	345	"MD5Sum",
cde41ae8 MV	346	"SHA1",
cde41ae8 MV	347	"SHA256",
b2e465d6 AL	348	"MSDOS-Filename", // Obsolete
	349	"Description",
	350	0};
	351	static const char *iTFRewriteSourceOrder[] = {"Package",
	352	"Source",
	353	"Binary",
	354	"Version",
	355	"Priority",
	356	"Section",
	357	"Maintainer",
	358	"Build-Depends",
	359	"Build-Depends-Indep",
	360	"Build-Conflicts",
	361	"Build-Conflicts-Indep",
	362	"Architecture",
	363	"Standards-Version",
	364	"Format",
	365	"Directory",
	366	"Files",
	367	0};
	368
	369	/* Two levels of initialization are used because gcc will set the symbol
	370	size of an array to the length of the array, causing dynamic relinking
	371	errors. Doing this makes the symbol size constant */
	372	const char **TFRewritePackageOrder = iTFRewritePackageOrder;
	373	const char **TFRewriteSourceOrder = iTFRewriteSourceOrder;
	374
	375	bool TFRewrite(FILE Output,pkgTagSection const &Tags,const char Order[],
	376	TFRewriteData *Rewrite)
	377	{
	378	unsigned char Visited[256]; // Bit 1 is Order, Bit 2 is Rewrite
	379	for (unsigned I = 0; I != 256; I++)
	380	Visited[I] = 0;
	381
	382	// Set new tag up as necessary.
	383	for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
	384	{
	385	if (Rewrite[J].NewTag == 0)
	386	Rewrite[J].NewTag = Rewrite[J].Tag;
	387	}
	388
	389	// Write all all of the tags, in order.
	390	for (unsigned int I = 0; Order[I] != 0; I++)
	391	{
	392	bool Rewritten = false;
	393
	394	// See if this is a field that needs to be rewritten
	395	for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
	396	{
	397	if (strcasecmp(Rewrite[J].Tag,Order[I]) == 0)
	398	{
	399	Visited[J] \|= 2;
	400	if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
	401	{
	402	if (isspace(Rewrite[J].Rewrite[0]))
	403	fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
	404	else
	405	fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
	406	}
	407
	408	Rewritten = true;
	409	break;
	410	}
	411	}
412
413	// See if it is in the fragment
414	unsigned Pos;
415	if (Tags.Find(Order[I],Pos) == false)
416	continue;
417	Visited[Pos] \|= 1;
418
419	if (Rewritten == true)
420	continue;
421
422	/* Write out this element, taking a moment to rewrite the tag
423	in case of changes of case. */
424	const char *Start;
425	const char *Stop;
426	Tags.Get(Start,Stop,Pos);
427
428	if (fputs(Order[I],Output) < 0)
429	return _error->Errno("fputs","IO Error to output");
430	Start += strlen(Order[I]);
431	if (fwrite(Start,Stop - Start,1,Output) != 1)
432	return _error->Errno("fwrite","IO Error to output");
433	if (Stop[-1] != '\n')
434	fprintf(Output,"\n");
435	}
436
437	// Now write all the old tags that were missed.
438	for (unsigned int I = 0; I != Tags.Count(); I++)
439	{
440	if ((Visited[I] & 1) == 1)
441	continue;
442
443	const char *Start;
444	const char *Stop;
445	Tags.Get(Start,Stop,I);
446	const char *End = Start;
447	for (; End < Stop && *End != ':'; End++);
448
449	// See if this is a field that needs to be rewritten
450	bool Rewritten = false;
451	for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
452	{
453	if (stringcasecmp(Start,End,Rewrite[J].Tag) == 0)
454	{
455	Visited[J] \|= 2;
456	if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
457	{
458	if (isspace(Rewrite[J].Rewrite[0]))
459	fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
460	else
461	fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
462	}
463
464	Rewritten = true;
465	break;
466	}
467	}
468
469	if (Rewritten == true)
470	continue;
471
472	// Write out this element
473	if (fwrite(Start,Stop - Start,1,Output) != 1)
474	return _error->Errno("fwrite","IO Error to output");
475	if (Stop[-1] != '\n')
476	fprintf(Output,"\n");
477	}
478
479	// Now write all the rewrites that were missed
480	for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
481	{
482	if ((Visited[J] & 2) == 2)
483	continue;
484
485	if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
486	{
487	if (isspace(Rewrite[J].Rewrite[0]))
488	fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
489	else
490	fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
491	}
492	}
493
494	return true;
495	}
496	/}}}/