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