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    last 8 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) & 0xDF) ^ (Res << 1);
 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                           "Breaks",
 394                           "Conffiles",
 395                           "Filename",
 396                           "Size",
 397                           "MD5Sum",
 398                           "SHA1",
 399                           "SHA256",
 400                            "MSDOS-Filename",   // Obsolete
 401                           "Description",
 402                           0};
 403 static const char *iTFRewriteSourceOrder[] = {"Package",
 404                                       "Source",
 405                                       "Binary",
 406                                       "Version",
 407                                       "Priority",
 408                                       "Section",
 409                                       "Maintainer",
 410                                       "Build-Depends",
 411                                       "Build-Depends-Indep",
 412                                       "Build-Conflicts",
 413                                       "Build-Conflicts-Indep",
 414                                       "Architecture",
 415                                       "Standards-Version",
 416                                       "Format",
 417                                       "Directory",
 418                                       "Files",
 419                                       0};
 420
 421 /* Two levels of initialization are used because gcc will set the symbol
 422    size of an array to the length of the array, causing dynamic relinking
 423    errors. Doing this makes the symbol size constant */
 424 const char **TFRewritePackageOrder = iTFRewritePackageOrder;
 425 const char **TFRewriteSourceOrder = iTFRewriteSourceOrder;
 426
 427 bool TFRewrite(FILE *Output,pkgTagSection const &Tags,const char *Order[],
 428                TFRewriteData *Rewrite)
 429 {
 430    unsigned char Visited[256];   // Bit 1 is Order, Bit 2 is Rewrite
 431    for (unsigned I = 0; I != 256; I++)
 432       Visited[I] = 0;
 433
 434    // Set new tag up as necessary.
 435    for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 436    {
 437       if (Rewrite[J].NewTag == 0)
 438          Rewrite[J].NewTag = Rewrite[J].Tag;
 439    }
 440
 441    // Write all all of the tags, in order.
 442    for (unsigned int I = 0; Order[I] != 0; I++)
 443    {
 444       bool Rewritten = false;
 445
 446       // See if this is a field that needs to be rewritten
 447       for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 448       {
 449          if (strcasecmp(Rewrite[J].Tag,Order[I]) == 0)
 450          {
 451             Visited[J] |= 2;
 452             if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
 453             {
 454                if (isspace(Rewrite[J].Rewrite[0]))
 455                   fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 456                else
 457                   fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 458             }
 459
 460             Rewritten = true;
 461             break;
 462          }
 463       }
 464
 465       // See if it is in the fragment
 466       unsigned Pos;
 467       if (Tags.Find(Order[I],Pos) == false)
 468          continue;
 469       Visited[Pos] |= 1;
 470
 471       if (Rewritten == true)
 472          continue;
 473
 474       /* Write out this element, taking a moment to rewrite the tag
 475          in case of changes of case. */
 476       const char *Start;
 477       const char *Stop;
 478       Tags.Get(Start,Stop,Pos);
 479
 480       if (fputs(Order[I],Output) < 0)
 481          return _error->Errno("fputs","IO Error to output");
 482       Start += strlen(Order[I]);
 483       if (fwrite(Start,Stop - Start,1,Output) != 1)
 484          return _error->Errno("fwrite","IO Error to output");
 485       if (Stop[-1] != '\n')
 486          fprintf(Output,"\n");
 487    }
 488
 489    // Now write all the old tags that were missed.
 490    for (unsigned int I = 0; I != Tags.Count(); I++)
 491    {
 492       if ((Visited[I] & 1) == 1)
 493          continue;
 494
 495       const char *Start;
 496       const char *Stop;
 497       Tags.Get(Start,Stop,I);
 498       const char *End = Start;
 499       for (; End < Stop && *End != ':'; End++);
 500
 501       // See if this is a field that needs to be rewritten
 502       bool Rewritten = false;
 503       for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 504       {
 505          if (stringcasecmp(Start,End,Rewrite[J].Tag) == 0)
 506          {
 507             Visited[J] |= 2;
 508             if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
 509             {
 510                if (isspace(Rewrite[J].Rewrite[0]))
 511                   fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 512                else
 513                   fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 514             }
 515
 516             Rewritten = true;
 517             break;
 518          }
 519       }
 520
 521       if (Rewritten == true)
 522          continue;
 523
 524       // Write out this element
 525       if (fwrite(Start,Stop - Start,1,Output) != 1)
 526          return _error->Errno("fwrite","IO Error to output");
 527       if (Stop[-1] != '\n')
 528          fprintf(Output,"\n");
 529    }
 530
 531    // Now write all the rewrites that were missed
 532    for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
 533    {
 534       if ((Visited[J] & 2) == 2)
 535          continue;
 536
 537       if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
 538       {
 539          if (isspace(Rewrite[J].Rewrite[0]))
 540             fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 541          else
 542             fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
 543       }
 544    }
 545
 546    return true;
 547 }
 548                                                                         /*}}}*/