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