apt-pkg/deb/deblistparser.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: deblistparser.cc,v 1.29.2.5 2004/01/06 01:43:44 mdz Exp $
   4 /* ######################################################################
   5
   6    Package Cache Generator - Generator for the cache structure.
   7
   8    This builds the cache structure from the abstract package list parser.
   9
  10    ##################################################################### */
  11                                                                         /*}}}*/
  12 // Include Files                                                        /*{{{*/
  13 #include <apt-pkg/deblistparser.h>
  14 #include <apt-pkg/error.h>
  15 #include <apt-pkg/configuration.h>
  16 #include <apt-pkg/aptconfiguration.h>
  17 #include <apt-pkg/strutl.h>
  18 #include <apt-pkg/crc-16.h>
  19 #include <apt-pkg/md5.h>
  20
  21 #include <ctype.h>
  22
  23 #include <system.h>
  24                                                                         /*}}}*/
  25
  26 static debListParser::WordList PrioList[] = {{"important",pkgCache::State::Important},
  27                        {"required",pkgCache::State::Required},
  28                        {"standard",pkgCache::State::Standard},
  29                        {"optional",pkgCache::State::Optional},
  30                        {"extra",pkgCache::State::Extra},
  31                        {}};
  32
  33 // ListParser::debListParser - Constructor                              /*{{{*/
  34 // ---------------------------------------------------------------------
  35 /* */
  36 debListParser::debListParser(FileFd *File) : Tags(File)
  37 {
  38    Arch = _config->Find("APT::architecture");
  39 }
  40                                                                         /*}}}*/
  41 // ListParser::UniqFindTagWrite - Find the tag and write a unq string   /*{{{*/
  42 // ---------------------------------------------------------------------
  43 /* */
  44 unsigned long debListParser::UniqFindTagWrite(const char *Tag)
  45 {
  46    const char *Start;
  47    const char *Stop;
  48    if (Section.Find(Tag,Start,Stop) == false)
  49       return 0;
  50    return WriteUniqString(Start,Stop - Start);
  51 }
  52                                                                         /*}}}*/
  53 // ListParser::Package - Return the package name                        /*{{{*/
  54 // ---------------------------------------------------------------------
  55 /* This is to return the name of the package this section describes */
  56 string debListParser::Package()
  57 {
  58    string Result = Section.FindS("Package");
  59    if (Result.empty() == true)
  60       _error->Error("Encountered a section with no Package: header");
  61    return Result;
  62 }
  63                                                                         /*}}}*/
  64 // ListParser::Version - Return the version string                      /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* This is to return the string describing the version in debian form,
  67    epoch:upstream-release. If this returns the blank string then the
  68    entry is assumed to only describe package properties */
  69 string debListParser::Version()
  70 {
  71    return Section.FindS("Version");
  72 }
  73                                                                         /*}}}*/
  74 // ListParser::NewVersion - Fill in the version structure               /*{{{*/
  75 // ---------------------------------------------------------------------
  76 /* */
  77 bool debListParser::NewVersion(pkgCache::VerIterator Ver)
  78 {
  79    // Parse the section
  80    Ver->Section = UniqFindTagWrite("Section");
  81    Ver->Arch = UniqFindTagWrite("Architecture");
  82
  83    // Archive Size
  84    Ver->Size = (unsigned)Section.FindI("Size");
  85
  86    // Unpacked Size (in K)
  87    Ver->InstalledSize = (unsigned)Section.FindI("Installed-Size");
  88    Ver->InstalledSize *= 1024;
  89
  90    // Priority
  91    const char *Start;
  92    const char *Stop;
  93    if (Section.Find("Priority",Start,Stop) == true)
  94    {
  95       if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
  96          Ver->Priority = pkgCache::State::Extra;
  97    }
  98
  99    if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
 100       return false;
 101    if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
 102       return false;
 103    if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
 104       return false;
 105    if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
 106       return false;
 107    if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
 108       return false;
 109    if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
 110       return false;
 111    if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
 112       return false;
 113    if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
 114       return false;
 115
 116    // Obsolete.
 117    if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
 118       return false;
 119
 120    if (ParseProvides(Ver) == false)
 121       return false;
 122
 123    return true;
 124 }
 125                                                                         /*}}}*/
 126 // ListParser::Description - Return the description string              /*{{{*/
 127 // ---------------------------------------------------------------------
 128 /* This is to return the string describing the package in debian
 129    form. If this returns the blank string then the entry is assumed to
 130    only describe package properties */
 131 string debListParser::Description()
 132 {
 133    string const lang = DescriptionLanguage();
 134    if (lang.empty())
 135       return Section.FindS("Description");
 136    else
 137       return Section.FindS(string("Description-").append(lang).c_str());
 138 }
 139                                                                         /*}}}*/
 140 // ListParser::DescriptionLanguage - Return the description lang string /*{{{*/
 141 // ---------------------------------------------------------------------
 142 /* This is to return the string describing the language of
 143    description. If this returns the blank string then the entry is
 144    assumed to describe original description. */
 145 string debListParser::DescriptionLanguage()
 146 {
 147    if (Section.FindS("Description").empty() == false)
 148       return "";
 149
 150    std::vector<string> const lang = APT::Configuration::getLanguages();
 151    for (std::vector<string>::const_iterator l = lang.begin();
 152         l != lang.end(); l++)
 153       if (Section.FindS(string("Description-").append(*l).c_str()).empty() == false)
 154          return *l;
 155
 156    return "";
 157 }
 158                                                                         /*}}}*/
 159 // ListParser::Description - Return the description_md5 MD5SumValue     /*{{{*/
 160 // ---------------------------------------------------------------------
 161 /* This is to return the md5 string to allow the check if it is the right
 162    description. If no Description-md5 is found in the section it will be
 163    calculated.
 164  */
 165 MD5SumValue debListParser::Description_md5()
 166 {
 167    string value = Section.FindS("Description-md5");
 168
 169    if (value.empty())
 170    {
 171       MD5Summation md5;
 172       md5.Add((Description() + "\n").c_str());
 173       return md5.Result();
 174    } else
 175       return MD5SumValue(value);
 176 }
 177                                                                         /*}}}*/
 178 // ListParser::UsePackage - Update a package structure                  /*{{{*/
 179 // ---------------------------------------------------------------------
 180 /* This is called to update the package with any new information
 181    that might be found in the section */
 182 bool debListParser::UsePackage(pkgCache::PkgIterator Pkg,
 183                                pkgCache::VerIterator Ver)
 184 {
 185    if (Pkg->Section == 0)
 186       Pkg->Section = UniqFindTagWrite("Section");
 187    if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
 188       return false;
 189    if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
 190       return false;
 191
 192    if (strcmp(Pkg.Name(),"apt") == 0)
 193       Pkg->Flags |= pkgCache::Flag::Important;
 194
 195    if (ParseStatus(Pkg,Ver) == false)
 196       return false;
 197    return true;
 198 }
 199                                                                         /*}}}*/
 200 // ListParser::VersionHash - Compute a unique hash for this version     /*{{{*/
 201 // ---------------------------------------------------------------------
 202 /* */
 203 unsigned short debListParser::VersionHash()
 204 {
 205    const char *Sections[] ={"Installed-Size",
 206                             "Depends",
 207                             "Pre-Depends",
 208 //                            "Suggests",
 209 //                            "Recommends",
 210                             "Conflicts",
 211                             "Breaks",
 212                             "Replaces",0};
 213    unsigned long Result = INIT_FCS;
 214    char S[1024];
 215    for (const char **I = Sections; *I != 0; I++)
 216    {
 217       const char *Start;
 218       const char *End;
 219       if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S))
 220          continue;
 221
 222       /* Strip out any spaces from the text, this undoes dpkgs reformatting
 223          of certain fields. dpkg also has the rather interesting notion of
 224          reformatting depends operators < -> <= */
 225       char *I = S;
 226       for (; Start != End; Start++)
 227       {
 228          if (isspace(*Start) == 0)
 229             *I++ = tolower_ascii(*Start);
 230          if (*Start == '<' && Start[1] != '<' && Start[1] != '=')
 231             *I++ = '=';
 232          if (*Start == '>' && Start[1] != '>' && Start[1] != '=')
 233             *I++ = '=';
 234       }
 235
 236       Result = AddCRC16(Result,S,I - S);
 237    }
 238
 239    return Result;
 240 }
 241                                                                         /*}}}*/
 242 // ListParser::ParseStatus - Parse the status field                     /*{{{*/
 243 // ---------------------------------------------------------------------
 244 /* Status lines are of the form,
 245      Status: want flag status
 246    want = unknown, install, hold, deinstall, purge
 247    flag = ok, reinstreq, hold, hold-reinstreq
 248    status = not-installed, unpacked, half-configured,
 249             half-installed, config-files, post-inst-failed,
 250             removal-failed, installed
 251
 252    Some of the above are obsolete (I think?) flag = hold-* and
 253    status = post-inst-failed, removal-failed at least.
 254  */
 255 bool debListParser::ParseStatus(pkgCache::PkgIterator Pkg,
 256                                 pkgCache::VerIterator Ver)
 257 {
 258    const char *Start;
 259    const char *Stop;
 260    if (Section.Find("Status",Start,Stop) == false)
 261       return true;
 262
 263    // Isolate the first word
 264    const char *I = Start;
 265    for(; I < Stop && *I != ' '; I++);
 266    if (I >= Stop || *I != ' ')
 267       return _error->Error("Malformed Status line");
 268
 269    // Process the want field
 270    WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
 271                           {"install",pkgCache::State::Install},
 272                           {"hold",pkgCache::State::Hold},
 273                           {"deinstall",pkgCache::State::DeInstall},
 274                           {"purge",pkgCache::State::Purge},
 275                           {}};
 276    if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
 277       return _error->Error("Malformed 1st word in the Status line");
 278
 279    // Isloate the next word
 280    I++;
 281    Start = I;
 282    for(; I < Stop && *I != ' '; I++);
 283    if (I >= Stop || *I != ' ')
 284       return _error->Error("Malformed status line, no 2nd word");
 285
 286    // Process the flag field
 287    WordList FlagList[] = {{"ok",pkgCache::State::Ok},
 288                           {"reinstreq",pkgCache::State::ReInstReq},
 289                           {"hold",pkgCache::State::HoldInst},
 290                           {"hold-reinstreq",pkgCache::State::HoldReInstReq},
 291                           {}};
 292    if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
 293       return _error->Error("Malformed 2nd word in the Status line");
 294
 295    // Isloate the last word
 296    I++;
 297    Start = I;
 298    for(; I < Stop && *I != ' '; I++);
 299    if (I != Stop)
 300       return _error->Error("Malformed Status line, no 3rd word");
 301
 302    // Process the flag field
 303    WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
 304                             {"unpacked",pkgCache::State::UnPacked},
 305                             {"half-configured",pkgCache::State::HalfConfigured},
 306                             {"installed",pkgCache::State::Installed},
 307                             {"half-installed",pkgCache::State::HalfInstalled},
 308                             {"config-files",pkgCache::State::ConfigFiles},
 309                             {"triggers-awaited",pkgCache::State::TriggersAwaited},
 310                             {"triggers-pending",pkgCache::State::TriggersPending},
 311                             {"post-inst-failed",pkgCache::State::HalfConfigured},
 312                             {"removal-failed",pkgCache::State::HalfInstalled},
 313                             {}};
 314    if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
 315       return _error->Error("Malformed 3rd word in the Status line");
 316
 317    /* A Status line marks the package as indicating the current
 318       version as well. Only if it is actually installed.. Otherwise
 319       the interesting dpkg handling of the status file creates bogus
 320       entries. */
 321    if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
 322          Pkg->CurrentState == pkgCache::State::ConfigFiles))
 323    {
 324       if (Ver.end() == true)
 325          _error->Warning("Encountered status field in a non-version description");
 326       else
 327          Pkg->CurrentVer = Ver.Index();
 328    }
 329
 330    return true;
 331 }
 332
 333 const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
 334 {
 335    // Determine the operator
 336    switch (*I)
 337    {
 338       case '<':
 339       I++;
 340       if (*I == '=')
 341       {
 342          I++;
 343          Op = pkgCache::Dep::LessEq;
 344          break;
 345       }
 346
 347       if (*I == '<')
 348       {
 349          I++;
 350          Op = pkgCache::Dep::Less;
 351          break;
 352       }
 353
 354       // < is the same as <= and << is really Cs < for some reason
 355       Op = pkgCache::Dep::LessEq;
 356       break;
 357
 358       case '>':
 359       I++;
 360       if (*I == '=')
 361       {
 362          I++;
 363          Op = pkgCache::Dep::GreaterEq;
 364          break;
 365       }
 366
 367       if (*I == '>')
 368       {
 369          I++;
 370          Op = pkgCache::Dep::Greater;
 371          break;
 372       }
 373
 374       // > is the same as >= and >> is really Cs > for some reason
 375       Op = pkgCache::Dep::GreaterEq;
 376       break;
 377
 378       case '=':
 379       Op = pkgCache::Dep::Equals;
 380       I++;
 381       break;
 382
 383       // HACK around bad package definitions
 384       default:
 385       Op = pkgCache::Dep::Equals;
 386       break;
 387    }
 388    return I;
 389 }
 390
 391                                                                         /*}}}*/
 392 // ListParser::ParseDepends - Parse a dependency element                /*{{{*/
 393 // ---------------------------------------------------------------------
 394 /* This parses the dependency elements out of a standard string in place,
 395    bit by bit. */
 396 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 397                                         string &Package,string &Ver,
 398                                         unsigned int &Op, bool ParseArchFlags)
 399 {
 400    // Strip off leading space
 401    for (;Start != Stop && isspace(*Start) != 0; Start++);
 402
 403    // Parse off the package name
 404    const char *I = Start;
 405    for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
 406         *I != ',' && *I != '|'; I++);
 407
 408    // Malformed, no '('
 409    if (I != Stop && *I == ')')
 410       return 0;
 411
 412    if (I == Start)
 413       return 0;
 414
 415    // Stash the package name
 416    Package.assign(Start,I - Start);
 417
 418    // Skip white space to the '('
 419    for (;I != Stop && isspace(*I) != 0 ; I++);
 420
 421    // Parse a version
 422    if (I != Stop && *I == '(')
 423    {
 424       // Skip the '('
 425       for (I++; I != Stop && isspace(*I) != 0 ; I++);
 426       if (I + 3 >= Stop)
 427          return 0;
 428       I = ConvertRelation(I,Op);
 429
 430       // Skip whitespace
 431       for (;I != Stop && isspace(*I) != 0; I++);
 432       Start = I;
 433       for (;I != Stop && *I != ')'; I++);
 434       if (I == Stop || Start == I)
 435          return 0;
 436
 437       // Skip trailing whitespace
 438       const char *End = I;
 439       for (; End > Start && isspace(End[-1]); End--);
 440
 441       Ver.assign(Start,End-Start);
 442       I++;
 443    }
 444    else
 445    {
 446       Ver.clear();
 447       Op = pkgCache::Dep::NoOp;
 448    }
 449
 450    // Skip whitespace
 451    for (;I != Stop && isspace(*I) != 0; I++);
 452
 453    if (ParseArchFlags == true)
 454    {
 455       string arch = _config->Find("APT::Architecture");
 456
 457       // Parse an architecture
 458       if (I != Stop && *I == '[')
 459       {
 460          // malformed
 461          I++;
 462          if (I == Stop)
 463             return 0;
 464
 465          const char *End = I;
 466          bool Found = false;
 467          bool NegArch = false;
 468          while (I != Stop)
 469          {
 470             // look for whitespace or ending ']'
 471             while (End != Stop && !isspace(*End) && *End != ']')
 472                End++;
 473
 474             if (End == Stop)
 475                return 0;
 476
 477             if (*I == '!')
 478             {
 479                NegArch = true;
 480                I++;
 481             }
 482
 483             if (stringcmp(arch,I,End) == 0)
 484                Found = true;
 485
 486             if (*End++ == ']') {
 487                I = End;
 488                break;
 489             }
 490
 491             I = End;
 492             for (;I != Stop && isspace(*I) != 0; I++);
 493          }
 494
 495          if (NegArch)
 496             Found = !Found;
 497
 498          if (Found == false)
 499             Package = ""; /* not for this arch */
 500       }
 501
 502       // Skip whitespace
 503       for (;I != Stop && isspace(*I) != 0; I++);
 504    }
 505
 506    if (I != Stop && *I == '|')
 507       Op |= pkgCache::Dep::Or;
 508
 509    if (I == Stop || *I == ',' || *I == '|')
 510    {
 511       if (I != Stop)
 512          for (I++; I != Stop && isspace(*I) != 0; I++);
 513       return I;
 514    }
 515
 516    return 0;
 517 }
 518                                                                         /*}}}*/
 519 // ListParser::ParseDepends - Parse a dependency list                   /*{{{*/
 520 // ---------------------------------------------------------------------
 521 /* This is the higher level depends parser. It takes a tag and generates
 522    a complete depends tree for the given version. */
 523 bool debListParser::ParseDepends(pkgCache::VerIterator Ver,
 524                                  const char *Tag,unsigned int Type)
 525 {
 526    const char *Start;
 527    const char *Stop;
 528    if (Section.Find(Tag,Start,Stop) == false)
 529       return true;
 530
 531    string Package;
 532    string Version;
 533    unsigned int Op;
 534
 535    while (1)
 536    {
 537       Start = ParseDepends(Start,Stop,Package,Version,Op);
 538       if (Start == 0)
 539          return _error->Error("Problem parsing dependency %s",Tag);
 540
 541       if (NewDepends(Ver,Package,Version,Op,Type) == false)
 542          return false;
 543       if (Start == Stop)
 544          break;
 545    }
 546    return true;
 547 }
 548                                                                         /*}}}*/
 549 // ListParser::ParseProvides - Parse the provides list                  /*{{{*/
 550 // ---------------------------------------------------------------------
 551 /* */
 552 bool debListParser::ParseProvides(pkgCache::VerIterator Ver)
 553 {
 554    const char *Start;
 555    const char *Stop;
 556    if (Section.Find("Provides",Start,Stop) == false)
 557       return true;
 558
 559    string Package;
 560    string Version;
 561    unsigned int Op;
 562
 563    while (1)
 564    {
 565       Start = ParseDepends(Start,Stop,Package,Version,Op);
 566       if (Start == 0)
 567          return _error->Error("Problem parsing Provides line");
 568       if (Op != pkgCache::Dep::NoOp) {
 569          _error->Warning("Ignoring Provides line with DepCompareOp for package %s", Package.c_str());
 570       } else {
 571          if (NewProvides(Ver,Package,Version) == false)
 572             return false;
 573       }
 574
 575       if (Start == Stop)
 576          break;
 577    }
 578
 579    return true;
 580 }
 581                                                                         /*}}}*/
 582 // ListParser::GrabWord - Matches a word and returns                    /*{{{*/
 583 // ---------------------------------------------------------------------
 584 /* Looks for a word in a list of words - for ParseStatus */
 585 bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
 586 {
 587    for (unsigned int C = 0; List[C].Str != 0; C++)
 588    {
 589       if (strcasecmp(Word.c_str(),List[C].Str) == 0)
 590       {
 591          Out = List[C].Val;
 592          return true;
 593       }
 594    }
 595    return false;
 596 }
 597                                                                         /*}}}*/
 598 // ListParser::Step - Move to the next section in the file              /*{{{*/
 599 // ---------------------------------------------------------------------
 600 /* This has to be carefull to only process the correct architecture */
 601 bool debListParser::Step()
 602 {
 603    iOffset = Tags.Offset();
 604    while (Tags.Step(Section) == true)
 605    {
 606       /* See if this is the correct Architecture, if it isn't then we
 607          drop the whole section. A missing arch tag only happens (in theory)
 608          inside the Status file, so that is a positive return */
 609       const char *Start;
 610       const char *Stop;
 611       if (Section.Find("Architecture",Start,Stop) == false)
 612          return true;
 613
 614       if (stringcmp(Arch,Start,Stop) == 0)
 615          return true;
 616
 617       if (stringcmp(Start,Stop,"all") == 0)
 618          return true;
 619
 620       iOffset = Tags.Offset();
 621    }
 622    return false;
 623 }
 624                                                                         /*}}}*/
 625 // ListParser::LoadReleaseInfo - Load the release information           /*{{{*/
 626 // ---------------------------------------------------------------------
 627 /* */
 628 bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator FileI,
 629                                     FileFd &File, string component)
 630 {
 631    pkgTagFile Tags(&File, File.Size() + 256); // XXX
 632    pkgTagSection Section;
 633    if (Tags.Step(Section) == false)
 634       return false;
 635
 636    //mvo: I don't think we need to fill that in (it's unused since apt-0.6)
 637    //FileI->Architecture = WriteUniqString(Arch);
 638
 639    // apt-secure does no longer download individual (per-section) Release
 640    // file. to provide Component pinning we use the section name now
 641    FileI->Component = WriteUniqString(component);
 642
 643    const char *Start;
 644    const char *Stop;
 645    if (Section.Find("Suite",Start,Stop) == true)
 646       FileI->Archive = WriteUniqString(Start,Stop - Start);
 647    if (Section.Find("Component",Start,Stop) == true)
 648       FileI->Component = WriteUniqString(Start,Stop - Start);
 649    if (Section.Find("Version",Start,Stop) == true)
 650       FileI->Version = WriteUniqString(Start,Stop - Start);
 651    if (Section.Find("Origin",Start,Stop) == true)
 652       FileI->Origin = WriteUniqString(Start,Stop - Start);
 653    if (Section.Find("Codename",Start,Stop) == true)
 654       FileI->Codename = WriteUniqString(Start,Stop - Start);
 655    if (Section.Find("Label",Start,Stop) == true)
 656       FileI->Label = WriteUniqString(Start,Stop - Start);
 657    if (Section.Find("Architecture",Start,Stop) == true)
 658       FileI->Architecture = WriteUniqString(Start,Stop - Start);
 659
 660    if (Section.FindFlag("NotAutomatic",FileI->Flags,
 661                         pkgCache::Flag::NotAutomatic) == false)
 662       _error->Warning("Bad NotAutomatic flag");
 663
 664    return !_error->PendingError();
 665 }
 666                                                                         /*}}}*/
 667 // ListParser::GetPrio - Convert the priority from a string             /*{{{*/
 668 // ---------------------------------------------------------------------
 669 /* */
 670 unsigned char debListParser::GetPrio(string Str)
 671 {
 672    unsigned char Out;
 673    if (GrabWord(Str,PrioList,Out) == false)
 674       Out = pkgCache::State::Extra;
 675
 676    return Out;
 677 }
 678                                                                         /*}}}*/