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<config.h>
  15
  16 #include <apt-pkg/tagfile.h>
  17 #include <apt-pkg/error.h>
  18 #include <apt-pkg/strutl.h>
  19 #include <apt-pkg/fileutl.h>
  20
  21 #include <string>
  22 #include <stdio.h>
  23 #include <ctype.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include <apti18n.h>
  28                                                                         /*}}}*/
  29
  30 using std::string;
  31
  32 class pkgTagFilePrivate
  33 {
  34 public:
  35    void Reset(FileFd * const pFd, unsigned long long const pSize)
  36    {
  37       if (Buffer != NULL)
  38          free(Buffer);
  39       Buffer = NULL;
  40       Fd = pFd;
  41       Start = NULL;
  42       End = NULL;
  43       Done = false;
  44       iOffset = 0;
  45       Size = pSize;
  46    }
  47
  48    pkgTagFilePrivate(FileFd * const pFd, unsigned long long const Size) : Buffer(NULL)
  49    {
  50       Reset(pFd, Size);
  51    }
  52    FileFd * Fd;
  53    char *Buffer;
  54    char *Start;
  55    char *End;
  56    bool Done;
  57    unsigned long long iOffset;
  58    unsigned long long Size;
  59
  60    ~pkgTagFilePrivate()
  61    {
  62       if (Buffer != NULL)
  63          free(Buffer);
  64    }
  65 };
  66
  67 class pkgTagSectionPrivate
  68 {
  69 public:
  70    pkgTagSectionPrivate()
  71    {
  72    }
  73    struct TagData {
  74       unsigned int StartTag;
  75       unsigned int EndTag;
  76       unsigned int StartValue;
  77       unsigned int NextInBucket;
  78
  79       explicit TagData(unsigned int const StartTag) : StartTag(StartTag), EndTag(0), StartValue(0), NextInBucket(0) {}
  80    };
  81    std::vector<TagData> Tags;
  82 };
  83
  84 static unsigned long AlphaHash(const char *Text, size_t Length)         /*{{{*/
  85 {
  86    /* This very simple hash function for the last 8 letters gives
  87       very good performance on the debian package files */
  88    if (Length > 8)
  89    {
  90     Text += (Length - 8);
  91     Length = 8;
  92    }
  93    unsigned long Res = 0;
  94    for (size_t i = 0; i < Length; ++i)
  95       Res = ((unsigned long)(Text[i]) & 0xDF) ^ (Res << 1);
  96    return Res & 0xFF;
  97 }
  98                                                                         /*}}}*/
  99
 100 // TagFile::pkgTagFile - Constructor                                    /*{{{*/
 101 // ---------------------------------------------------------------------
 102 /* */
 103 pkgTagFile::pkgTagFile(FileFd * const pFd,unsigned long long const Size)
 104    : d(new pkgTagFilePrivate(pFd, Size + 4))
 105 {
 106    Init(pFd, Size);
 107 }
 108 void pkgTagFile::Init(FileFd * const pFd,unsigned long long Size)
 109 {
 110    /* The size is increased by 4 because if we start with the Size of the
 111       filename we need to try to read 1 char more to see an EOF faster, 1
 112       char the end-pointer can be on and maybe 2 newlines need to be added
 113       to the end of the file -> 4 extra chars */
 114    Size += 4;
 115    d->Reset(pFd, Size);
 116
 117    if (d->Fd->IsOpen() == false)
 118       d->Start = d->End = d->Buffer = 0;
 119    else
 120       d->Buffer = (char*)malloc(sizeof(char) * Size);
 121
 122    if (d->Buffer == NULL)
 123       d->Done = true;
 124    else
 125       d->Done = false;
 126
 127    d->Start = d->End = d->Buffer;
 128    d->iOffset = 0;
 129    if (d->Done == false)
 130       Fill();
 131 }
 132                                                                         /*}}}*/
 133 // TagFile::~pkgTagFile - Destructor                                    /*{{{*/
 134 // ---------------------------------------------------------------------
 135 /* */
 136 pkgTagFile::~pkgTagFile()
 137 {
 138    delete d;
 139 }
 140                                                                         /*}}}*/
 141 // TagFile::Offset - Return the current offset in the buffer            /*{{{*/
 142 APT_PURE unsigned long pkgTagFile::Offset()
 143 {
 144    return d->iOffset;
 145 }
 146                                                                         /*}}}*/
 147 // TagFile::Resize - Resize the internal buffer                         /*{{{*/
 148 // ---------------------------------------------------------------------
 149 /* Resize the internal buffer (double it in size). Fail if a maximum size
 150  * size is reached.
 151  */
 152 bool pkgTagFile::Resize()
 153 {
 154    // fail is the buffer grows too big
 155    if(d->Size > 1024*1024+1)
 156       return false;
 157
 158    return Resize(d->Size * 2);
 159 }
 160 bool pkgTagFile::Resize(unsigned long long const newSize)
 161 {
 162    unsigned long long const EndSize = d->End - d->Start;
 163
 164    // get new buffer and use it
 165    char* newBuffer = (char*)realloc(d->Buffer, sizeof(char) * newSize);
 166    if (newBuffer == NULL)
 167       return false;
 168    d->Buffer = newBuffer;
 169    d->Size = newSize;
 170
 171    // update the start/end pointers to the new buffer
 172    d->Start = d->Buffer;
 173    d->End = d->Start + EndSize;
 174    return true;
 175 }
 176                                                                         /*}}}*/
 177 // TagFile::Step - Advance to the next section                          /*{{{*/
 178 // ---------------------------------------------------------------------
 179 /* If the Section Scanner fails we refill the buffer and try again.
 180  * If that fails too, double the buffer size and try again until a
 181  * maximum buffer is reached.
 182  */
 183 bool pkgTagFile::Step(pkgTagSection &Tag)
 184 {
 185    if(Tag.Scan(d->Start,d->End - d->Start) == false)
 186    {
 187       do
 188       {
 189          if (Fill() == false)
 190             return false;
 191
 192          if(Tag.Scan(d->Start,d->End - d->Start, false))
 193             break;
 194
 195          if (Resize() == false)
 196             return _error->Error(_("Unable to parse package file %s (%d)"),
 197                   d->Fd->Name().c_str(), 1);
 198
 199       } while (Tag.Scan(d->Start,d->End - d->Start, false) == false);
 200    }
 201
 202    d->Start += Tag.size();
 203    d->iOffset += Tag.size();
 204
 205    Tag.Trim();
 206    return true;
 207 }
 208                                                                         /*}}}*/
 209 // TagFile::Fill - Top up the buffer                                    /*{{{*/
 210 // ---------------------------------------------------------------------
 211 /* This takes the bit at the end of the buffer and puts it at the start
 212    then fills the rest from the file */
 213 bool pkgTagFile::Fill()
 214 {
 215    unsigned long long EndSize = d->End - d->Start;
 216    unsigned long long Actual = 0;
 217
 218    memmove(d->Buffer,d->Start,EndSize);
 219    d->Start = d->Buffer;
 220    d->End = d->Buffer + EndSize;
 221
 222    if (d->Done == false)
 223    {
 224       // See if only a bit of the file is left
 225       unsigned long long const dataSize = d->Size - ((d->End - d->Buffer) + 1);
 226       if (d->Fd->Read(d->End, dataSize, &Actual) == false)
 227          return false;
 228       if (Actual != dataSize)
 229          d->Done = true;
 230       d->End += Actual;
 231    }
 232
 233    if (d->Done == true)
 234    {
 235       if (EndSize <= 3 && Actual == 0)
 236          return false;
 237       if (d->Size - (d->End - d->Buffer) < 4)
 238          return true;
 239
 240       // Append a double new line if one does not exist
 241       unsigned int LineCount = 0;
 242       for (const char *E = d->End - 1; E - d->End < 6 && (*E == '\n' || *E == '\r'); E--)
 243          if (*E == '\n')
 244             LineCount++;
 245       if (LineCount < 2)
 246       {
 247          if ((unsigned)(d->End - d->Buffer) >= d->Size)
 248             Resize(d->Size + 3);
 249          for (; LineCount < 2; LineCount++)
 250             *d->End++ = '\n';
 251       }
 252
 253       return true;
 254    }
 255
 256    return true;
 257 }
 258                                                                         /*}}}*/
 259 // TagFile::Jump - Jump to a pre-recorded location in the file          /*{{{*/
 260 // ---------------------------------------------------------------------
 261 /* This jumps to a pre-recorded file location and reads the record
 262    that is there */
 263 bool pkgTagFile::Jump(pkgTagSection &Tag,unsigned long long Offset)
 264 {
 265    // We are within a buffer space of the next hit..
 266    if (Offset >= d->iOffset && d->iOffset + (d->End - d->Start) > Offset)
 267    {
 268       unsigned long long Dist = Offset - d->iOffset;
 269       d->Start += Dist;
 270       d->iOffset += Dist;
 271       // if we have seen the end, don't ask for more
 272       if (d->Done == true)
 273          return Tag.Scan(d->Start, d->End - d->Start);
 274       else
 275          return Step(Tag);
 276    }
 277
 278    // Reposition and reload..
 279    d->iOffset = Offset;
 280    d->Done = false;
 281    if (d->Fd->Seek(Offset) == false)
 282       return false;
 283    d->End = d->Start = d->Buffer;
 284
 285    if (Fill() == false)
 286       return false;
 287
 288    if (Tag.Scan(d->Start, d->End - d->Start) == true)
 289       return true;
 290
 291    // This appends a double new line (for the real eof handling)
 292    if (Fill() == false)
 293       return false;
 294
 295    if (Tag.Scan(d->Start, d->End - d->Start, false) == false)
 296       return _error->Error(_("Unable to parse package file %s (%d)"),d->Fd->Name().c_str(), 2);
 297
 298    return true;
 299 }
 300                                                                         /*}}}*/
 301 // pkgTagSection::pkgTagSection - Constructor                           /*{{{*/
 302 // ---------------------------------------------------------------------
 303 /* */
 304 APT_IGNORE_DEPRECATED_PUSH
 305 pkgTagSection::pkgTagSection()
 306    : Section(0), d(new pkgTagSectionPrivate()), Stop(0)
 307 {
 308    memset(&AlphaIndexes, 0, sizeof(AlphaIndexes));
 309 }
 310 APT_IGNORE_DEPRECATED_POP
 311                                                                         /*}}}*/
 312 // TagSection::Scan - Scan for the end of the header information        /*{{{*/
 313 bool pkgTagSection::Scan(const char *Start,unsigned long MaxLength, bool const Restart)
 314 {
 315    Section = Start;
 316    const char *End = Start + MaxLength;
 317
 318    if (Restart == false && d->Tags.empty() == false)
 319    {
 320       Stop = Section + d->Tags.back().StartTag;
 321       if (End <= Stop)
 322          return false;
 323       Stop = (const char *)memchr(Stop,'\n',End - Stop);
 324       if (Stop == NULL)
 325          return false;
 326       ++Stop;
 327    }
 328    else
 329    {
 330       Stop = Section;
 331       if (d->Tags.empty() == false)
 332       {
 333          memset(&AlphaIndexes, 0, sizeof(AlphaIndexes));
 334          d->Tags.clear();
 335       }
 336       d->Tags.reserve(0x100);
 337    }
 338    unsigned int TagCount = d->Tags.size();
 339
 340    if (Stop == 0)
 341       return false;
 342
 343    pkgTagSectionPrivate::TagData lastTagData(0);
 344    lastTagData.EndTag = 0;
 345    unsigned long lastTagHash = 0;
 346    while (Stop < End)
 347    {
 348       TrimRecord(true,End);
 349
 350       // this can happen when TrimRecord trims away the entire Record
 351       // (e.g. because it just contains comments)
 352       if(Stop == End)
 353          return true;
 354
 355       // Start a new index and add it to the hash
 356       if (isspace(Stop[0]) == 0)
 357       {
 358          // store the last found tag
 359          if (lastTagData.EndTag != 0)
 360          {
 361             if (AlphaIndexes[lastTagHash] != 0)
 362                lastTagData.NextInBucket = AlphaIndexes[lastTagHash];
 363             APT_IGNORE_DEPRECATED_PUSH
 364             AlphaIndexes[lastTagHash] = TagCount;
 365             APT_IGNORE_DEPRECATED_POP
 366             d->Tags.push_back(lastTagData);
 367          }
 368
 369          APT_IGNORE_DEPRECATED(++TagCount;)
 370          lastTagData = pkgTagSectionPrivate::TagData(Stop - Section);
 371          // find the colon separating tag and value
 372          char const * Colon = (char const *) memchr(Stop, ':', End - Stop);
 373          if (Colon == NULL)
 374             return false;
 375          // find the end of the tag (which might or might not be the colon)
 376          char const * EndTag = Colon;
 377          --EndTag;
 378          for (; EndTag > Stop && isspace(*EndTag) != 0; --EndTag)
 379             ;
 380          ++EndTag;
 381          lastTagData.EndTag = EndTag - Section;
 382          lastTagHash = AlphaHash(Stop, EndTag - Stop);
 383          // find the beginning of the value
 384          Stop = Colon + 1;
 385          for (; isspace(*Stop) != 0; ++Stop);
 386          if (Stop >= End)
 387             return false;
 388          lastTagData.StartValue = Stop - Section;
 389       }
 390
 391       Stop = (const char *)memchr(Stop,'\n',End - Stop);
 392
 393       if (Stop == 0)
 394          return false;
 395
 396       for (; Stop+1 < End && Stop[1] == '\r'; Stop++)
 397          /* nothing */
 398          ;
 399
 400       // Double newline marks the end of the record
 401       if (Stop+1 < End && Stop[1] == '\n')
 402       {
 403          if (lastTagData.EndTag != 0)
 404          {
 405             if (AlphaIndexes[lastTagHash] != 0)
 406                lastTagData.NextInBucket = AlphaIndexes[lastTagHash];
 407             APT_IGNORE_DEPRECATED(AlphaIndexes[lastTagHash] = TagCount;)
 408             d->Tags.push_back(lastTagData);
 409          }
 410
 411          pkgTagSectionPrivate::TagData const td(Stop - Section);
 412          d->Tags.push_back(td);
 413          TrimRecord(false,End);
 414          return true;
 415       }
 416
 417       Stop++;
 418    }
 419
 420    return false;
 421 }
 422                                                                         /*}}}*/
 423 // TagSection::TrimRecord - Trim off any garbage before/after a record  /*{{{*/
 424 // ---------------------------------------------------------------------
 425 /* There should be exactly 2 newline at the end of the record, no more. */
 426 void pkgTagSection::TrimRecord(bool BeforeRecord, const char*& End)
 427 {
 428    if (BeforeRecord == true)
 429       return;
 430    for (; Stop < End && (Stop[0] == '\n' || Stop[0] == '\r'); Stop++);
 431 }
 432                                                                         /*}}}*/
 433 // TagSection::Trim - Trim off any trailing garbage                     /*{{{*/
 434 // ---------------------------------------------------------------------
 435 /* There should be exactly 1 newline at the end of the buffer, no more. */
 436 void pkgTagSection::Trim()
 437 {
 438    for (; Stop > Section + 2 && (Stop[-2] == '\n' || Stop[-2] == '\r'); Stop--);
 439 }
 440                                                                         /*}}}*/
 441 // TagSection::Exists - return True if a tag exists                     /*{{{*/
 442 bool pkgTagSection::Exists(const char* const Tag) const
 443 {
 444    unsigned int tmp;
 445    return Find(Tag, tmp);
 446 }
 447                                                                         /*}}}*/
 448 // TagSection::Find - Locate a tag                                      /*{{{*/
 449 // ---------------------------------------------------------------------
 450 /* This searches the section for a tag that matches the given string. */
 451 bool pkgTagSection::Find(const char *Tag,unsigned int &Pos) const
 452 {
 453    size_t const Length = strlen(Tag);
 454    unsigned int Bucket = AlphaIndexes[AlphaHash(Tag, Length)];
 455    if (Bucket == 0)
 456       return false;
 457
 458    for (; Bucket != 0; Bucket = d->Tags[Bucket - 1].NextInBucket)
 459    {
 460       if ((d->Tags[Bucket - 1].EndTag - d->Tags[Bucket - 1].StartTag) != Length)
 461          continue;
 462
 463       char const * const St = Section + d->Tags[Bucket - 1].StartTag;
 464       if (strncasecmp(Tag,St,Length) != 0)
 465          continue;
 466
 467       Pos = Bucket - 1;
 468       return true;
 469    }
 470
 471    Pos = 0;
 472    return false;
 473 }
 474 bool pkgTagSection::Find(const char *Tag,const char *&Start,
 475                          const char *&End) const
 476 {
 477    unsigned int Pos;
 478    if (Find(Tag, Pos) == false)
 479       return false;
 480
 481    Start = Section + d->Tags[Pos].StartValue;
 482    // Strip off the gunk from the end
 483    End = Section + d->Tags[Pos + 1].StartTag;
 484    if (unlikely(Start > End))
 485       return _error->Error("Internal parsing error");
 486
 487    for (; isspace(End[-1]) != 0 && End > Start; --End);
 488
 489    return true;
 490 }
 491                                                                         /*}}}*/
 492 // TagSection::FindS - Find a string                                    /*{{{*/
 493 string pkgTagSection::FindS(const char *Tag) const
 494 {
 495    const char *Start;
 496    const char *End;
 497    if (Find(Tag,Start,End) == false)
 498       return string();
 499    return string(Start,End);
 500 }
 501                                                                         /*}}}*/
 502 // TagSection::FindRawS - Find a string                                 /*{{{*/
 503 string pkgTagSection::FindRawS(const char *Tag) const
 504 {
 505    unsigned int Pos;
 506    if (Find(Tag, Pos) == false)
 507       return "";
 508
 509    char const *Start = (char const *) memchr(Section + d->Tags[Pos].EndTag, ':', d->Tags[Pos].StartValue - d->Tags[Pos].EndTag);
 510    ++Start;
 511    char const *End = Section + d->Tags[Pos + 1].StartTag;
 512    if (unlikely(Start > End))
 513       return "";
 514
 515    for (; isspace(End[-1]) != 0 && End > Start; --End);
 516
 517    return std::string(Start, End - Start);
 518 }
 519                                                                         /*}}}*/
 520 // TagSection::FindI - Find an integer                                  /*{{{*/
 521 // ---------------------------------------------------------------------
 522 /* */
 523 signed int pkgTagSection::FindI(const char *Tag,signed long Default) const
 524 {
 525    const char *Start;
 526    const char *Stop;
 527    if (Find(Tag,Start,Stop) == false)
 528       return Default;
 529
 530    // Copy it into a temp buffer so we can use strtol
 531    char S[300];
 532    if ((unsigned)(Stop - Start) >= sizeof(S))
 533       return Default;
 534    strncpy(S,Start,Stop-Start);
 535    S[Stop - Start] = 0;
 536
 537    errno = 0;
 538    char *End;
 539    signed long Result = strtol(S,&End,10);
 540    if (errno == ERANGE ||
 541        Result < std::numeric_limits<int>::min() || Result > std::numeric_limits<int>::max()) {
 542       errno = ERANGE;
 543       _error->Error(_("Cannot convert %s to integer: out of range"), S);
 544    }
 545    if (S == End)
 546       return Default;
 547    return Result;
 548 }
 549                                                                         /*}}}*/
 550 // TagSection::FindULL - Find an unsigned long long integer             /*{{{*/
 551 // ---------------------------------------------------------------------
 552 /* */
 553 unsigned long long pkgTagSection::FindULL(const char *Tag, unsigned long long const &Default) const
 554 {
 555    const char *Start;
 556    const char *Stop;
 557    if (Find(Tag,Start,Stop) == false)
 558       return Default;
 559
 560    // Copy it into a temp buffer so we can use strtoull
 561    char S[100];
 562    if ((unsigned)(Stop - Start) >= sizeof(S))
 563       return Default;
 564    strncpy(S,Start,Stop-Start);
 565    S[Stop - Start] = 0;
 566
 567    char *End;
 568    unsigned long long Result = strtoull(S,&End,10);
 569    if (S == End)
 570       return Default;
 571    return Result;
 572 }
 573                                                                         /*}}}*/
 574 // TagSection::FindB - Find boolean value                               /*{{{*/
 575 // ---------------------------------------------------------------------
 576 /* */
 577 bool pkgTagSection::FindB(const char *Tag, bool const &Default) const
 578 {
 579    const char *Start, *Stop;
 580    if (Find(Tag, Start, Stop) == false)
 581       return Default;
 582    return StringToBool(string(Start, Stop));
 583 }
 584                                                                         /*}}}*/
 585 // TagSection::FindFlag - Locate a yes/no type flag                     /*{{{*/
 586 // ---------------------------------------------------------------------
 587 /* The bits marked in Flag are masked on/off in Flags */
 588 bool pkgTagSection::FindFlag(const char * const Tag, uint8_t &Flags,
 589                              uint8_t const Flag) const
 590 {
 591    const char *Start;
 592    const char *Stop;
 593    if (Find(Tag,Start,Stop) == false)
 594       return true;
 595    return FindFlag(Flags, Flag, Start, Stop);
 596 }
 597 bool pkgTagSection::FindFlag(uint8_t &Flags, uint8_t const Flag,
 598                                         char const* const Start, char const* const Stop)
 599 {
 600    switch (StringToBool(string(Start, Stop)))
 601    {
 602       case 0:
 603       Flags &= ~Flag;
 604       return true;
 605
 606       case 1:
 607       Flags |= Flag;
 608       return true;
 609
 610       default:
 611       _error->Warning("Unknown flag value: %s",string(Start,Stop).c_str());
 612       return true;
 613    }
 614    return true;
 615 }
 616 bool pkgTagSection::FindFlag(const char *Tag,unsigned long &Flags,
 617                              unsigned long Flag) const
 618 {
 619    const char *Start;
 620    const char *Stop;
 621    if (Find(Tag,Start,Stop) == false)
 622       return true;
 623    return FindFlag(Flags, Flag, Start, Stop);
 624 }
 625 bool pkgTagSection::FindFlag(unsigned long &Flags, unsigned long Flag,
 626                                         char const* Start, char const* Stop)
 627 {
 628    switch (StringToBool(string(Start, Stop)))
 629    {
 630       case 0:
 631       Flags &= ~Flag;
 632       return true;
 633
 634       case 1:
 635       Flags |= Flag;
 636       return true;
 637
 638       default:
 639       _error->Warning("Unknown flag value: %s",string(Start,Stop).c_str());
 640       return true;
 641    }
 642    return true;
 643 }
 644                                                                         /*}}}*/
 645 void pkgTagSection::Get(const char *&Start,const char *&Stop,unsigned int I) const
 646 {
 647    Start = Section + d->Tags[I].StartTag;
 648    Stop = Section + d->Tags[I+1].StartTag;
 649 }
 650 APT_PURE unsigned int pkgTagSection::Count() const {                    /*{{{*/
 651    if (d->Tags.empty() == true)
 652       return 0;
 653    // the last element is just marking the end and isn't a real one
 654    return d->Tags.size() - 1;
 655 }
 656                                                                         /*}}}*/
 657 // TagSection::Write - Ordered (re)writing of fields                    /*{{{*/
 658 pkgTagSection::Tag pkgTagSection::Tag::Remove(std::string const &Name)
 659 {
 660    return Tag(REMOVE, Name, "");
 661 }
 662 pkgTagSection::Tag pkgTagSection::Tag::Rename(std::string const &OldName, std::string const &NewName)
 663 {
 664    return Tag(RENAME, OldName, NewName);
 665 }
 666 pkgTagSection::Tag pkgTagSection::Tag::Rewrite(std::string const &Name, std::string const &Data)
 667 {
 668    if (Data.empty() == true)
 669       return Tag(REMOVE, Name, "");
 670    else
 671       return Tag(REWRITE, Name, Data);
 672 }
 673 static bool WriteTag(FileFd &File, std::string Tag, std::string const &Value)
 674 {
 675    if (Value.empty() || isspace(Value[0]) != 0)
 676       Tag.append(":");
 677    else
 678       Tag.append(": ");
 679    Tag.append(Value);
 680    Tag.append("\n");
 681    return File.Write(Tag.c_str(), Tag.length());
 682 }
 683 static bool RewriteTags(FileFd &File, pkgTagSection const * const This, char const * const Tag,
 684       std::vector<pkgTagSection::Tag>::const_iterator &R,
 685       std::vector<pkgTagSection::Tag>::const_iterator const &REnd)
 686 {
 687    size_t const TagLen = strlen(Tag);
 688    for (; R != REnd; ++R)
 689    {
 690       std::string data;
 691       if (R->Name.length() == TagLen && strncasecmp(R->Name.c_str(), Tag, R->Name.length()) == 0)
 692       {
 693          if (R->Action != pkgTagSection::Tag::REWRITE)
 694             break;
 695          data = R->Data;
 696       }
 697       else if(R->Action == pkgTagSection::Tag::RENAME && R->Data.length() == TagLen &&
 698             strncasecmp(R->Data.c_str(), Tag, R->Data.length()) == 0)
 699          data = This->FindRawS(R->Name.c_str());
 700       else
 701          continue;
 702
 703       return WriteTag(File, Tag, data);
 704    }
 705    return true;
 706 }
 707 bool pkgTagSection::Write(FileFd &File, char const * const * const Order, std::vector<Tag> const &Rewrite) const
 708 {
 709    // first pass: Write everything we have an order for
 710    if (Order != NULL)
 711    {
 712       for (unsigned int I = 0; Order[I] != 0; ++I)
 713       {
 714          std::vector<Tag>::const_iterator R = Rewrite.begin();
 715          if (RewriteTags(File, this, Order[I], R, Rewrite.end()) == false)
 716             return false;
 717          if (R != Rewrite.end())
 718             continue;
 719
 720          if (Exists(Order[I]) == false)
 721             continue;
 722
 723          if (WriteTag(File, Order[I], FindRawS(Order[I])) == false)
 724             return false;
 725       }
 726    }
 727    // second pass: See if we have tags which aren't ordered
 728    if (d->Tags.empty() == false)
 729    {
 730       for (std::vector<pkgTagSectionPrivate::TagData>::const_iterator T = d->Tags.begin(); T != d->Tags.end() - 1; ++T)
 731       {
 732          char const * const fieldname = Section + T->StartTag;
 733          size_t fieldnamelen = T->EndTag - T->StartTag;
 734          if (Order != NULL)
 735          {
 736             unsigned int I = 0;
 737             for (; Order[I] != 0; ++I)
 738             {
 739                if (fieldnamelen == strlen(Order[I]) && strncasecmp(fieldname, Order[I], fieldnamelen) == 0)
 740                   break;
 741             }
 742             if (Order[I] != 0)
 743                continue;
 744          }
 745
 746          std::string const name(fieldname, fieldnamelen);
 747          std::vector<Tag>::const_iterator R = Rewrite.begin();
 748          if (RewriteTags(File, this, name.c_str(), R, Rewrite.end()) == false)
 749             return false;
 750          if (R != Rewrite.end())
 751             continue;
 752
 753          if (WriteTag(File, name, FindRawS(name.c_str())) == false)
 754             return false;
 755       }
 756    }
 757    // last pass: see if there are any rewrites remaining we haven't done yet
 758    for (std::vector<Tag>::const_iterator R = Rewrite.begin(); R != Rewrite.end(); ++R)
 759    {
 760       if (R->Action == Tag::REMOVE)
 761          continue;
 762       std::string const name = ((R->Action == Tag::RENAME) ? R->Data : R->Name);
 763       if (Exists(name.c_str()))
 764          continue;
 765       if (Order != NULL)
 766       {
 767          unsigned int I = 0;
 768          for (; Order[I] != 0; ++I)
 769          {
 770             if (strncasecmp(name.c_str(), Order[I], name.length()) == 0 && name.length() == strlen(Order[I]))
 771                break;
 772          }
 773          if (Order[I] != 0)
 774             continue;
 775       }
 776
 777       if (WriteTag(File, name, ((R->Action == Tag::RENAME) ? FindRawS(R->Name.c_str()) : R->Data)) == false)
 778          return false;
 779    }
 780    return true;
 781 }
 782                                                                         /*}}}*/
 783
 784 void pkgUserTagSection::TrimRecord(bool /*BeforeRecord*/, const char* &End)/*{{{*/
 785 {
 786    for (; Stop < End && (Stop[0] == '\n' || Stop[0] == '\r' || Stop[0] == '#'); Stop++)
 787       if (Stop[0] == '#')
 788          Stop = (const char*) memchr(Stop,'\n',End-Stop);
 789 }
 790                                                                         /*}}}*/
 791
 792 #include "tagfile-order.c"
 793
 794 // TFRewrite - Rewrite a control record                                 /*{{{*/
 795 // ---------------------------------------------------------------------
 796 /* This writes the control record to stdout rewriting it as necessary. The
 797    override map item specificies the rewriting rules to follow. This also
 798    takes the time to sort the feild list. */
 799 APT_IGNORE_DEPRECATED_PUSH
 800 bool TFRewrite(FILE *Output,pkgTagSection const &Tags,const char *Order[],
 801                TFRewriteData *Rewrite)
 802 {
 803    unsigned char Visited[256];   // Bit 1 is Order, Bit 2 is Rewrite
 804    for (unsigned I = 0; I != 256; I++)
 805       Visited[I] = 0;
 806
 807    // Set new tag up as necessary.
 808    for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 809    {
 810       if (Rewrite[J].NewTag == 0)
 811          Rewrite[J].NewTag = Rewrite[J].Tag;
 812    }
 813
 814    // Write all all of the tags, in order.
 815    if (Order != NULL)
 816    {
 817       for (unsigned int I = 0; Order[I] != 0; I++)
 818       {
 819          bool Rewritten = false;
 820
 821          // See if this is a field that needs to be rewritten
 822          for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 823          {
 824             if (strcasecmp(Rewrite[J].Tag,Order[I]) == 0)
 825             {
 826                Visited[J] |= 2;
 827                if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
 828                {
 829                   if (isspace(Rewrite[J].Rewrite[0]))
 830                      fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 831                   else
 832                      fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 833                }
 834                Rewritten = true;
 835                break;
 836             }
 837          }
 838
 839          // See if it is in the fragment
 840          unsigned Pos;
 841          if (Tags.Find(Order[I],Pos) == false)
 842             continue;
 843          Visited[Pos] |= 1;
 844
 845          if (Rewritten == true)
 846             continue;
 847
 848          /* Write out this element, taking a moment to rewrite the tag
 849             in case of changes of case. */
 850          const char *Start;
 851          const char *Stop;
 852          Tags.Get(Start,Stop,Pos);
 853
 854          if (fputs(Order[I],Output) < 0)
 855             return _error->Errno("fputs","IO Error to output");
 856          Start += strlen(Order[I]);
 857          if (fwrite(Start,Stop - Start,1,Output) != 1)
 858             return _error->Errno("fwrite","IO Error to output");
 859          if (Stop[-1] != '\n')
 860             fprintf(Output,"\n");
 861       }
 862    }
 863
 864    // Now write all the old tags that were missed.
 865    for (unsigned int I = 0; I != Tags.Count(); I++)
 866    {
 867       if ((Visited[I] & 1) == 1)
 868          continue;
 869
 870       const char *Start;
 871       const char *Stop;
 872       Tags.Get(Start,Stop,I);
 873       const char *End = Start;
 874       for (; End < Stop && *End != ':'; End++);
 875
 876       // See if this is a field that needs to be rewritten
 877       bool Rewritten = false;
 878       for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 879       {
 880          if (stringcasecmp(Start,End,Rewrite[J].Tag) == 0)
 881          {
 882             Visited[J] |= 2;
 883             if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
 884             {
 885                if (isspace(Rewrite[J].Rewrite[0]))
 886                   fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 887                else
 888                   fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 889             }
 890
 891             Rewritten = true;
 892             break;
 893          }
 894       }
 895
 896       if (Rewritten == true)
 897          continue;
 898
 899       // Write out this element
 900       if (fwrite(Start,Stop - Start,1,Output) != 1)
 901          return _error->Errno("fwrite","IO Error to output");
 902       if (Stop[-1] != '\n')
 903          fprintf(Output,"\n");
 904    }
 905
 906    // Now write all the rewrites that were missed
 907    for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 908    {
 909       if ((Visited[J] & 2) == 2)
 910          continue;
 911
 912       if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
 913       {
 914          if (isspace(Rewrite[J].Rewrite[0]))
 915             fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 916          else
 917             fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 918       }
 919    }
 920
 921    return true;
 922 }
 923 APT_IGNORE_DEPRECATED_POP
 924                                                                         /*}}}*/
 925
 926 pkgTagSection::~pkgTagSection() { delete d; }