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