[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)
   {
      Buffer = 0;
      Start = End = Buffer = 0;
      Done = true;
      iOffset = 0;
      return;
   }
   
   Buffer = new char[Size];
   Start = End = Buffer;
   Done = false;
   iOffset = 0;
   Fill();
}
									/*}}}*/
// TagFile::~pkgTagFile - Destructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgTagFile::~pkgTagFile()
{
   delete [] Buffer;
}
									/*}}}*/
// 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 (Tag.Scan(Start,End - Start) == false)
   {
      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);
   }

   // Reposition and reload..
   iOffset = Offset;
   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)
      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++;
   }

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