apt-pkg/tagfile.cc

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