[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),
     Map(NULL),
     Buffer(0)
{
   if (Fd.IsOpen() == false)
   {
      Start = End = Buffer = 0;
      Done = true;
      iOffset = 0;
      Map = NULL;
      return;
   }
   
   // check if we can MMap it
   if(Fd.Size() == 0)
   {
      Buffer = new char[Size];
      Start = End = Buffer;
      Done = false;
      Fill();
   } else {
      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()
{
   if(!Map) delete [] Buffer;
   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 ((Map != NULL) && (Start == End))
      return false;

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

      if (Fill() == false)
	 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::Fill - Top up the buffer					/*{{{*/
// ---------------------------------------------------------------------
/* This takes the bit at the end of the buffer and puts it at the start
   then fills the rest from the file */
bool pkgTagFile::Fill()
{
   unsigned long EndSize = End - Start;
   unsigned long Actual = 0;
   
   memmove(Buffer,Start,EndSize);
   Start = Buffer;
   End = Buffer + EndSize;
   
   if (Done == false)
   {
      // See if only a bit of the file is left
      if (Fd.Read(End,Size - (End - Buffer),&Actual) == false)
	 return false;
      if (Actual != Size - (End - Buffer))
	 Done = true;
      End += Actual;
   }
   
   if (Done == true)
   {
      if (EndSize <= 3 && Actual == 0)
	 return false;
      if (Size - (End - Buffer) < 4)
	 return true;
      
      // Append a double new line if one does not exist
      unsigned int LineCount = 0;
      for (const char *E = End - 1; E - End < 6 && (*E == '\n' || *E == '\r'); E--)
	 if (*E == '\n')
	    LineCount++;
      for (; LineCount < 2; LineCount++)
	 *End++ = '\n';
      
      return true;
   }
   
   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);
   }

   iOffset = Offset;
   if (Map != NULL)
   {
      Start = Buffer + iOffset;
   } 
   else 
   {
      // Reposition and reload..
      Done = false;
      if (Fd.Seek(Offset) == false)
	 return false;
      End = Start = Buffer;
   
      if (Fill() == false)
	 return false;

      if (Tag.Scan(Start,End - Start) == true)
	 return true;
   
      // This appends a double new line (for the real eof handling)
      if (Fill() == false)
	 return false;
   }

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