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 <config.h>
  14
  15 #include <apt-pkg/deblistparser.h>
  16 #include <apt-pkg/error.h>
  17 #include <apt-pkg/configuration.h>
  18 #include <apt-pkg/cachefilter.h>
  19 #include <apt-pkg/aptconfiguration.h>
  20 #include <apt-pkg/strutl.h>
  21 #include <apt-pkg/crc-16.h>
  22 #include <apt-pkg/md5.h>
  23 #include <apt-pkg/pkgcache.h>
  24 #include <apt-pkg/cacheiterators.h>
  25 #include <apt-pkg/tagfile.h>
  26 #include <apt-pkg/macros.h>
  27
  28 #include <stddef.h>
  29 #include <string.h>
  30 #include <algorithm>
  31 #include <string>
  32 #include <vector>
  33 #include <ctype.h>
  34                                                                         /*}}}*/
  35
  36 using std::string;
  37
  38 static const debListParser::WordList PrioList[] = {
  39    {"required",pkgCache::State::Required},
  40    {"important",pkgCache::State::Important},
  41    {"standard",pkgCache::State::Standard},
  42    {"optional",pkgCache::State::Optional},
  43    {"extra",pkgCache::State::Extra},
  44    {NULL, 0}};
  45
  46 // ListParser::debListParser - Constructor                              /*{{{*/
  47 // ---------------------------------------------------------------------
  48 /* Provide an architecture and only this one and "all" will be accepted
  49    in Step(), if no Architecture is given we will accept every arch
  50    we would accept in general with checkArchitecture() */
  51 debListParser::debListParser(FileFd *File) :
  52    pkgCacheListParser(), d(NULL), Tags(File)
  53 {
  54 }
  55                                                                         /*}}}*/
  56 // ListParser::Package - Return the package name                        /*{{{*/
  57 // ---------------------------------------------------------------------
  58 /* This is to return the name of the package this section describes */
  59 string debListParser::Package() {
  60    string Result = Section.FindS("Package");
  61
  62    // Normalize mixed case package names to lower case, like dpkg does
  63    // See Bug#807012 for details
  64    std::transform(Result.begin(), Result.end(), Result.begin(), tolower_ascii);
  65
  66    if(unlikely(Result.empty() == true))
  67       _error->Error("Encountered a section with no Package: header");
  68    return Result;
  69 }
  70                                                                         /*}}}*/
  71 // ListParser::Architecture - Return the package arch                   /*{{{*/
  72 // ---------------------------------------------------------------------
  73 /* This will return the Architecture of the package this section describes */
  74 string debListParser::Architecture() {
  75    std::string const Arch = Section.FindS("Architecture");
  76    return Arch.empty() ? "none" : Arch;
  77 }
  78                                                                         /*}}}*/
  79 // ListParser::ArchitectureAll                                          /*{{{*/
  80 // ---------------------------------------------------------------------
  81 /* */
  82 bool debListParser::ArchitectureAll() {
  83    return Section.FindS("Architecture") == "all";
  84 }
  85                                                                         /*}}}*/
  86 // ListParser::Version - Return the version string                      /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* This is to return the string describing the version in debian form,
  89    epoch:upstream-release. If this returns the blank string then the
  90    entry is assumed to only describe package properties */
  91 string debListParser::Version()
  92 {
  93    return Section.FindS("Version");
  94 }
  95                                                                         /*}}}*/
  96 unsigned char debListParser::ParseMultiArch(bool const showErrors)      /*{{{*/
  97 {
  98    unsigned char MA;
  99    string const MultiArch = Section.FindS("Multi-Arch");
 100    if (MultiArch.empty() == true || MultiArch == "no")
 101       MA = pkgCache::Version::No;
 102    else if (MultiArch == "same") {
 103       if (ArchitectureAll() == true)
 104       {
 105          if (showErrors == true)
 106             _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
 107                   Section.FindS("Package").c_str());
 108          MA = pkgCache::Version::No;
 109       }
 110       else
 111          MA = pkgCache::Version::Same;
 112    }
 113    else if (MultiArch == "foreign")
 114       MA = pkgCache::Version::Foreign;
 115    else if (MultiArch == "allowed")
 116       MA = pkgCache::Version::Allowed;
 117    else
 118    {
 119       if (showErrors == true)
 120          _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
 121                MultiArch.c_str(), Section.FindS("Package").c_str());
 122       MA = pkgCache::Version::No;
 123    }
 124
 125    if (ArchitectureAll() == true)
 126       MA |= pkgCache::Version::All;
 127
 128    return MA;
 129 }
 130                                                                         /*}}}*/
 131 // ListParser::NewVersion - Fill in the version structure               /*{{{*/
 132 // ---------------------------------------------------------------------
 133 /* */
 134 bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
 135 {
 136    const char *Start;
 137    const char *Stop;
 138
 139    // Parse the section
 140    if (Section.Find("Section",Start,Stop) == true)
 141    {
 142       map_stringitem_t const idx = StoreString(pkgCacheGenerator::SECTION, Start, Stop - Start);
 143       Ver->Section = idx;
 144    }
 145    // Parse the source package name
 146    pkgCache::GrpIterator const G = Ver.ParentPkg().Group();
 147    Ver->SourcePkgName = G->Name;
 148    Ver->SourceVerStr = Ver->VerStr;
 149    if (Section.Find("Source",Start,Stop) == true)
 150    {
 151       const char * const Space = (const char * const) memchr(Start, ' ', Stop - Start);
 152       pkgCache::VerIterator V;
 153
 154       if (Space != NULL)
 155       {
 156          Stop = Space;
 157          const char * const Open = (const char * const) memchr(Space, '(', Stop - Space);
 158          if (likely(Open != NULL))
 159          {
 160             const char * const Close = (const char * const) memchr(Open, ')', Stop - Open);
 161             if (likely(Close != NULL))
 162             {
 163                std::string const version(Open + 1, (Close - Open) - 1);
 164                if (version != Ver.VerStr())
 165                {
 166                   map_stringitem_t const idx = StoreString(pkgCacheGenerator::VERSIONNUMBER, version);
 167                   Ver->SourceVerStr = idx;
 168                }
 169             }
 170          }
 171       }
 172
 173       std::string const pkgname(Start, Stop - Start);
 174       if (pkgname != G.Name())
 175       {
 176          for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P))
 177          {
 178             for (V = P.VersionList(); V.end() == false; ++V)
 179             {
 180                if (pkgname == V.SourcePkgName())
 181                {
 182                   Ver->SourcePkgName = V->SourcePkgName;
 183                   break;
 184                }
 185             }
 186             if (V.end() == false)
 187                break;
 188          }
 189          if (V.end() == true)
 190          {
 191             map_stringitem_t const idx = StoreString(pkgCacheGenerator::PKGNAME, pkgname);
 192             Ver->SourcePkgName = idx;
 193          }
 194       }
 195    }
 196
 197    Ver->MultiArch = ParseMultiArch(true);
 198    // Archive Size
 199    Ver->Size = Section.FindULL("Size");
 200    // Unpacked Size (in K)
 201    Ver->InstalledSize = Section.FindULL("Installed-Size");
 202    Ver->InstalledSize *= 1024;
 203
 204    // Priority
 205    if (Section.Find("Priority",Start,Stop) == true)
 206    {
 207       if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
 208          Ver->Priority = pkgCache::State::Extra;
 209    }
 210
 211    if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
 212       return false;
 213    if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
 214       return false;
 215    if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
 216       return false;
 217    if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
 218       return false;
 219    if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
 220       return false;
 221    if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
 222       return false;
 223    if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
 224       return false;
 225    if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
 226       return false;
 227    // Obsolete.
 228    if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
 229       return false;
 230
 231    if (ParseProvides(Ver) == false)
 232       return false;
 233
 234    return true;
 235 }
 236                                                                         /*}}}*/
 237 // ListParser::Description - Return the description string              /*{{{*/
 238 // ---------------------------------------------------------------------
 239 /* This is to return the string describing the package in debian
 240    form. If this returns the blank string then the entry is assumed to
 241    only describe package properties */
 242 string debListParser::Description(std::string const &lang)
 243 {
 244    if (lang.empty())
 245       return Section.FindS("Description");
 246    else
 247       return Section.FindS(string("Description-").append(lang).c_str());
 248 }
 249                                                                         /*}}}*/
 250 // ListParser::AvailableDescriptionLanguages                            /*{{{*/
 251 std::vector<std::string> debListParser::AvailableDescriptionLanguages()
 252 {
 253    std::vector<std::string> const understood = APT::Configuration::getLanguages();
 254    std::vector<std::string> avail;
 255    if (Section.Exists("Description") == true)
 256       avail.push_back("");
 257    for (std::vector<std::string>::const_iterator lang = understood.begin(); lang != understood.end(); ++lang)
 258    {
 259       std::string const tagname = "Description-" + *lang;
 260       if (Section.Exists(tagname.c_str()) == true)
 261          avail.push_back(*lang);
 262    }
 263    return avail;
 264 }
 265                                                                         /*}}}*/
 266 // ListParser::Description_md5 - Return the description_md5 MD5SumValue /*{{{*/
 267 // ---------------------------------------------------------------------
 268 /* This is to return the md5 string to allow the check if it is the right
 269    description. If no Description-md5 is found in the section it will be
 270    calculated.
 271  */
 272 MD5SumValue debListParser::Description_md5()
 273 {
 274    string const value = Section.FindS("Description-md5");
 275    if (value.empty() == true)
 276    {
 277       std::string const desc = Description("") + "\n";
 278       if (desc == "\n")
 279          return MD5SumValue();
 280
 281       MD5Summation md5;
 282       md5.Add(desc.c_str());
 283       return md5.Result();
 284    }
 285    else if (likely(value.size() == 32))
 286    {
 287       if (likely(value.find_first_not_of("0123456789abcdefABCDEF") == string::npos))
 288          return MD5SumValue(value);
 289       _error->Error("Malformed Description-md5 line; includes invalid character '%s'", value.c_str());
 290       return MD5SumValue();
 291    }
 292    _error->Error("Malformed Description-md5 line; doesn't have the required length (32 != %d) '%s'", (int)value.size(), value.c_str());
 293    return MD5SumValue();
 294 }
 295                                                                         /*}}}*/
 296 // ListParser::UsePackage - Update a package structure                  /*{{{*/
 297 // ---------------------------------------------------------------------
 298 /* This is called to update the package with any new information
 299    that might be found in the section */
 300 bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
 301                                pkgCache::VerIterator &Ver)
 302 {
 303    string const static myArch = _config->Find("APT::Architecture");
 304    // Possible values are: "all", "native", "installed" and "none"
 305    // The "installed" mode is handled by ParseStatus(), See #544481 and friends.
 306    string const static essential = _config->Find("pkgCacheGen::Essential", "all");
 307    if (essential == "all" ||
 308        (essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()))
 309       if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
 310          return false;
 311    if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
 312       return false;
 313
 314    if (strcmp(Pkg.Name(),"apt") == 0)
 315    {
 316       if ((essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()) ||
 317           essential == "all")
 318          Pkg->Flags |= pkgCache::Flag::Essential | pkgCache::Flag::Important;
 319       else
 320          Pkg->Flags |= pkgCache::Flag::Important;
 321    }
 322
 323    if (ParseStatus(Pkg,Ver) == false)
 324       return false;
 325    return true;
 326 }
 327                                                                         /*}}}*/
 328 // ListParser::VersionHash - Compute a unique hash for this version     /*{{{*/
 329 // ---------------------------------------------------------------------
 330 /* */
 331 unsigned short debListParser::VersionHash()
 332 {
 333    const char *Sections[] ={"Installed-Size",
 334                             "Depends",
 335                             "Pre-Depends",
 336 //                            "Suggests",
 337 //                            "Recommends",
 338                             "Conflicts",
 339                             "Breaks",
 340                             "Replaces",0};
 341    unsigned long Result = INIT_FCS;
 342    char S[1024];
 343    for (const char * const *I = Sections; *I != 0; ++I)
 344    {
 345       const char *Start;
 346       const char *End;
 347       if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S))
 348          continue;
 349
 350       /* Strip out any spaces from the text, this undoes dpkgs reformatting
 351          of certain fields. dpkg also has the rather interesting notion of
 352          reformatting depends operators < -> <= */
 353       char *J = S;
 354       for (; Start != End; ++Start)
 355       {
 356          if (isspace(*Start) != 0)
 357             continue;
 358          *J++ = tolower_ascii(*Start);
 359
 360          if ((*Start == '<' || *Start == '>') && Start[1] != *Start && Start[1] != '=')
 361             *J++ = '=';
 362       }
 363
 364       Result = AddCRC16(Result,S,J - S);
 365    }
 366
 367    return Result;
 368 }
 369                                                                         /*}}}*/
 370 // StatusListParser::ParseStatus - Parse the status field               /*{{{*/
 371 // ---------------------------------------------------------------------
 372 /* Status lines are of the form,
 373      Status: want flag status
 374    want = unknown, install, hold, deinstall, purge
 375    flag = ok, reinstreq
 376    status = not-installed, config-files, half-installed, unpacked,
 377             half-configured, triggers-awaited, triggers-pending, installed
 378  */
 379 bool debListParser::ParseStatus(pkgCache::PkgIterator &,
 380                                 pkgCache::VerIterator &)
 381 {
 382    return true;
 383 }
 384 bool debStatusListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
 385                                 pkgCache::VerIterator &Ver)
 386 {
 387    const char *Start;
 388    const char *Stop;
 389    if (Section.Find("Status",Start,Stop) == false)
 390       return true;
 391
 392    // UsePackage() is responsible for setting the flag in the default case
 393    bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed";
 394    if (essential == true &&
 395        Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
 396       return false;
 397
 398    // Isolate the first word
 399    const char *I = Start;
 400    for(; I < Stop && *I != ' '; I++);
 401    if (I >= Stop || *I != ' ')
 402       return _error->Error("Malformed Status line");
 403
 404    // Process the want field
 405    WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
 406                           {"install",pkgCache::State::Install},
 407                           {"hold",pkgCache::State::Hold},
 408                           {"deinstall",pkgCache::State::DeInstall},
 409                           {"purge",pkgCache::State::Purge},
 410                           {NULL, 0}};
 411    if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
 412       return _error->Error("Malformed 1st word in the Status line");
 413
 414    // Isloate the next word
 415    I++;
 416    Start = I;
 417    for(; I < Stop && *I != ' '; I++);
 418    if (I >= Stop || *I != ' ')
 419       return _error->Error("Malformed status line, no 2nd word");
 420
 421    // Process the flag field
 422    WordList FlagList[] = {{"ok",pkgCache::State::Ok},
 423                           {"reinstreq",pkgCache::State::ReInstReq},
 424                           {"hold",pkgCache::State::HoldInst},
 425                           {"hold-reinstreq",pkgCache::State::HoldReInstReq},
 426                           {NULL, 0}};
 427    if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
 428       return _error->Error("Malformed 2nd word in the Status line");
 429
 430    // Isloate the last word
 431    I++;
 432    Start = I;
 433    for(; I < Stop && *I != ' '; I++);
 434    if (I != Stop)
 435       return _error->Error("Malformed Status line, no 3rd word");
 436
 437    // Process the flag field
 438    WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
 439                             {"config-files",pkgCache::State::ConfigFiles},
 440                             {"half-installed",pkgCache::State::HalfInstalled},
 441                             {"unpacked",pkgCache::State::UnPacked},
 442                             {"half-configured",pkgCache::State::HalfConfigured},
 443                             {"triggers-awaited",pkgCache::State::TriggersAwaited},
 444                             {"triggers-pending",pkgCache::State::TriggersPending},
 445                             {"installed",pkgCache::State::Installed},
 446                             {NULL, 0}};
 447    if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
 448       return _error->Error("Malformed 3rd word in the Status line");
 449
 450    /* A Status line marks the package as indicating the current
 451       version as well. Only if it is actually installed.. Otherwise
 452       the interesting dpkg handling of the status file creates bogus
 453       entries. */
 454    if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
 455          Pkg->CurrentState == pkgCache::State::ConfigFiles))
 456    {
 457       if (Ver.end() == true)
 458          _error->Warning("Encountered status field in a non-version description");
 459       else
 460          Pkg->CurrentVer = Ver.Index();
 461    }
 462
 463    return true;
 464 }
 465
 466 const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
 467 {
 468    // Determine the operator
 469    switch (*I)
 470    {
 471       case '<':
 472       I++;
 473       if (*I == '=')
 474       {
 475          I++;
 476          Op = pkgCache::Dep::LessEq;
 477          break;
 478       }
 479
 480       if (*I == '<')
 481       {
 482          I++;
 483          Op = pkgCache::Dep::Less;
 484          break;
 485       }
 486
 487       // < is the same as <= and << is really Cs < for some reason
 488       Op = pkgCache::Dep::LessEq;
 489       break;
 490
 491       case '>':
 492       I++;
 493       if (*I == '=')
 494       {
 495          I++;
 496          Op = pkgCache::Dep::GreaterEq;
 497          break;
 498       }
 499
 500       if (*I == '>')
 501       {
 502          I++;
 503          Op = pkgCache::Dep::Greater;
 504          break;
 505       }
 506
 507       // > is the same as >= and >> is really Cs > for some reason
 508       Op = pkgCache::Dep::GreaterEq;
 509       break;
 510
 511       case '=':
 512       Op = pkgCache::Dep::Equals;
 513       I++;
 514       break;
 515
 516       // HACK around bad package definitions
 517       default:
 518       Op = pkgCache::Dep::Equals;
 519       break;
 520    }
 521    return I;
 522 }
 523                                                                         /*}}}*/
 524 // ListParser::ParseDepends - Parse a dependency element                /*{{{*/
 525 // ---------------------------------------------------------------------
 526 /* This parses the dependency elements out of a standard string in place,
 527    bit by bit. */
 528 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 529                std::string &Package,std::string &Ver,unsigned int &Op)
 530    { return ParseDepends(Start, Stop, Package, Ver, Op, false, true, false); }
 531 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 532                std::string &Package,std::string &Ver,unsigned int &Op,
 533                bool const &ParseArchFlags)
 534    { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, true, false); }
 535 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 536                std::string &Package,std::string &Ver,unsigned int &Op,
 537                bool const &ParseArchFlags, bool const &StripMultiArch)
 538    { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, StripMultiArch, false); }
 539 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 540                                         string &Package,string &Ver,
 541                                         unsigned int &Op, bool const &ParseArchFlags,
 542                                         bool const &StripMultiArch,
 543                                         bool const &ParseRestrictionsList)
 544 {
 545    // Strip off leading space
 546    for (;Start != Stop && isspace(*Start) != 0; ++Start);
 547
 548    // Parse off the package name
 549    const char *I = Start;
 550    for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
 551         *I != ',' && *I != '|' && *I != '[' && *I != ']' &&
 552         *I != '<' && *I != '>'; ++I);
 553
 554    // Malformed, no '('
 555    if (I != Stop && *I == ')')
 556       return 0;
 557
 558    if (I == Start)
 559       return 0;
 560
 561    // Stash the package name
 562    Package.assign(Start,I - Start);
 563
 564    // We don't want to confuse library users which can't handle MultiArch
 565    string const arch = _config->Find("APT::Architecture");
 566    if (StripMultiArch == true) {
 567       size_t const found = Package.rfind(':');
 568       if (found != string::npos &&
 569           (strcmp(Package.c_str() + found, ":any") == 0 ||
 570            strcmp(Package.c_str() + found, ":native") == 0 ||
 571            strcmp(Package.c_str() + found + 1, arch.c_str()) == 0))
 572          Package = Package.substr(0,found);
 573    }
 574
 575    // Skip white space to the '('
 576    for (;I != Stop && isspace(*I) != 0 ; I++);
 577
 578    // Parse a version
 579    if (I != Stop && *I == '(')
 580    {
 581       // Skip the '('
 582       for (I++; I != Stop && isspace(*I) != 0 ; I++);
 583       if (I + 3 >= Stop)
 584          return 0;
 585       I = ConvertRelation(I,Op);
 586
 587       // Skip whitespace
 588       for (;I != Stop && isspace(*I) != 0; I++);
 589       Start = I;
 590       I = (const char*) memchr(I, ')', Stop - I);
 591       if (I == NULL || Start == I)
 592          return 0;
 593
 594       // Skip trailing whitespace
 595       const char *End = I;
 596       for (; End > Start && isspace(End[-1]); End--);
 597
 598       Ver.assign(Start,End-Start);
 599       I++;
 600    }
 601    else
 602    {
 603       Ver.clear();
 604       Op = pkgCache::Dep::NoOp;
 605    }
 606
 607    // Skip whitespace
 608    for (;I != Stop && isspace(*I) != 0; I++);
 609
 610    if (ParseArchFlags == true)
 611    {
 612       APT::CacheFilter::PackageArchitectureMatchesSpecification matchesArch(arch, false);
 613
 614       // Parse an architecture
 615       if (I != Stop && *I == '[')
 616       {
 617          ++I;
 618          // malformed
 619          if (unlikely(I == Stop))
 620             return 0;
 621
 622          const char *End = I;
 623          bool Found = false;
 624          bool NegArch = false;
 625          while (I != Stop)
 626          {
 627             // look for whitespace or ending ']'
 628             for (;End != Stop && !isspace(*End) && *End != ']'; ++End);
 629
 630             if (unlikely(End == Stop))
 631                return 0;
 632
 633             if (*I == '!')
 634             {
 635                NegArch = true;
 636                ++I;
 637             }
 638
 639             std::string arch(I, End);
 640             if (arch.empty() == false && matchesArch(arch.c_str()) == true)
 641             {
 642                Found = true;
 643                if (I[-1] != '!')
 644                   NegArch = false;
 645                // we found a match, so fast-forward to the end of the wildcards
 646                for (; End != Stop && *End != ']'; ++End);
 647             }
 648
 649             if (*End++ == ']') {
 650                I = End;
 651                break;
 652             }
 653
 654             I = End;
 655             for (;I != Stop && isspace(*I) != 0; I++);
 656          }
 657
 658          if (NegArch == true)
 659             Found = !Found;
 660
 661          if (Found == false)
 662             Package = ""; /* not for this arch */
 663       }
 664
 665       // Skip whitespace
 666       for (;I != Stop && isspace(*I) != 0; I++);
 667    }
 668
 669    if (ParseRestrictionsList == true)
 670    {
 671       // Parse a restrictions formula which is in disjunctive normal form:
 672       // (foo AND bar) OR (blub AND bla)
 673
 674       std::vector<string> const profiles = APT::Configuration::getBuildProfiles();
 675
 676       // if the next character is a restriction list, then by default the
 677       // dependency does not apply and the conditions have to be checked
 678       // if the next character is not a restriction list, then by default the
 679       // dependency applies
 680       bool applies1 = (*I != '<');
 681       while (I != Stop)
 682       {
 683          if (*I != '<')
 684              break;
 685
 686          ++I;
 687          // malformed
 688          if (unlikely(I == Stop))
 689             return 0;
 690
 691          const char *End = I;
 692
 693          // if of the prior restriction list is already fulfilled, then
 694          // we can just skip to the end of the current list
 695          if (applies1) {
 696             for (;End != Stop && *End != '>'; ++End);
 697             I = ++End;
 698             // skip whitespace
 699             for (;I != Stop && isspace(*I) != 0; I++);
 700          } else {
 701             bool applies2 = true;
 702             // all the conditions inside a restriction list have to be
 703             // met so once we find one that is not met, we can skip to
 704             // the end of this list
 705             while (I != Stop)
 706             {
 707                // look for whitespace or ending '>'
 708                // End now points to the character after the current term
 709                for (;End != Stop && !isspace(*End) && *End != '>'; ++End);
 710
 711                if (unlikely(End == Stop))
 712                   return 0;
 713
 714                bool NegRestriction = false;
 715                if (*I == '!')
 716                {
 717                   NegRestriction = true;
 718                   ++I;
 719                }
 720
 721                std::string restriction(I, End);
 722
 723                if (restriction.empty() == false && profiles.empty() == false &&
 724                   std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
 725                {
 726                   if (NegRestriction) {
 727                      applies2 = false;
 728                      // since one of the terms does not apply we don't have to check the others
 729                      for (; End != Stop && *End != '>'; ++End);
 730                   }
 731                } else {
 732                   if (!NegRestriction) {
 733                      applies2 = false;
 734                      // since one of the terms does not apply we don't have to check the others
 735                      for (; End != Stop && *End != '>'; ++End);
 736                   }
 737                }
 738
 739                if (*End++ == '>') {
 740                   I = End;
 741                   // skip whitespace
 742                   for (;I != Stop && isspace(*I) != 0; I++);
 743                   break;
 744                }
 745
 746                I = End;
 747                // skip whitespace
 748                for (;I != Stop && isspace(*I) != 0; I++);
 749             }
 750             if (applies2) {
 751                applies1 = true;
 752             }
 753          }
 754       }
 755
 756       if (applies1 == false) {
 757          Package = ""; //not for this restriction
 758       }
 759    }
 760
 761    if (I != Stop && *I == '|')
 762       Op |= pkgCache::Dep::Or;
 763
 764    if (I == Stop || *I == ',' || *I == '|')
 765    {
 766       if (I != Stop)
 767          for (I++; I != Stop && isspace(*I) != 0; I++);
 768       return I;
 769    }
 770
 771    return 0;
 772 }
 773                                                                         /*}}}*/
 774 // ListParser::ParseDepends - Parse a dependency list                   /*{{{*/
 775 // ---------------------------------------------------------------------
 776 /* This is the higher level depends parser. It takes a tag and generates
 777    a complete depends tree for the given version. */
 778 bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
 779                                  const char *Tag,unsigned int Type)
 780 {
 781    const char *Start;
 782    const char *Stop;
 783    if (Section.Find(Tag,Start,Stop) == false)
 784       return true;
 785
 786    string const pkgArch = Ver.Arch();
 787
 788    while (1)
 789    {
 790       string Package;
 791       string Version;
 792       unsigned int Op;
 793
 794       Start = ParseDepends(Start, Stop, Package, Version, Op, false, false, false);
 795       if (Start == 0)
 796          return _error->Error("Problem parsing dependency %s",Tag);
 797       size_t const found = Package.rfind(':');
 798
 799       if (found == string::npos)
 800       {
 801          if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
 802             return false;
 803       }
 804       else if (strcmp(Package.c_str() + found, ":any") == 0)
 805       {
 806          if (NewDepends(Ver,Package,"any",Version,Op,Type) == false)
 807             return false;
 808       }
 809       else
 810       {
 811          // Such dependencies are not supposed to be accepted …
 812          // … but this is probably the best thing to do anyway
 813          if (Package.substr(found + 1) == "native")
 814             Package = Package.substr(0, found) + ':' + Ver.Cache()->NativeArch();
 815
 816          if (NewDepends(Ver, Package, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
 817             return false;
 818       }
 819
 820       if (Start == Stop)
 821          break;
 822    }
 823    return true;
 824 }
 825                                                                         /*}}}*/
 826 // ListParser::ParseProvides - Parse the provides list                  /*{{{*/
 827 // ---------------------------------------------------------------------
 828 /* */
 829 bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
 830 {
 831    /* it is unlikely, but while parsing dependencies, we might have already
 832       picked up multi-arch implicit provides which we do not want to duplicate here */
 833    bool hasProvidesAlready = false;
 834    std::string const spzName = Ver.ParentPkg().FullName(false);
 835    {
 836       for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 837       {
 838          if (Prv.IsMultiArchImplicit() == false || (Prv->Flags & pkgCache::Flag::ArchSpecific) == 0)
 839             continue;
 840          if (spzName != Prv.OwnerPkg().FullName(false))
 841             continue;
 842          hasProvidesAlready = true;
 843          break;
 844       }
 845    }
 846
 847    string const Arch = Ver.Arch();
 848    const char *Start;
 849    const char *Stop;
 850    if (Section.Find("Provides",Start,Stop) == true)
 851    {
 852       string Package;
 853       string Version;
 854       unsigned int Op;
 855
 856       do
 857       {
 858          Start = ParseDepends(Start,Stop,Package,Version,Op, false, false, false);
 859          const size_t archfound = Package.rfind(':');
 860          if (Start == 0)
 861             return _error->Error("Problem parsing Provides line");
 862          if (Op != pkgCache::Dep::NoOp && Op != pkgCache::Dep::Equals) {
 863             _error->Warning("Ignoring Provides line with non-equal DepCompareOp for package %s", Package.c_str());
 864          } else if (archfound != string::npos) {
 865             std::string spzArch = Package.substr(archfound + 1);
 866             if (spzArch != "any")
 867             {
 868                if (NewProvides(Ver, Package.substr(0, archfound), spzArch, Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
 869                   return false;
 870             }
 871             if (NewProvides(Ver, Package, "any", Version, pkgCache::Flag::ArchSpecific) == false)
 872                return false;
 873          } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
 874             if (APT::Configuration::checkArchitecture(Arch))
 875                if (NewProvidesAllArch(Ver, Package, Version, 0) == false)
 876                   return false;
 877          } else {
 878             if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
 879             {
 880                if (NewProvides(Ver, Package + ":any", "any", Version, pkgCache::Flag::MultiArchImplicit) == false)
 881                   return false;
 882             }
 883             if (NewProvides(Ver, Package, Arch, Version, 0) == false)
 884                return false;
 885          }
 886          if (archfound == std::string::npos)
 887          {
 888             std::string const spzName = Package + ':' + Ver.ParentPkg().Arch();
 889             pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
 890             if (spzPkg.end() == false)
 891             {
 892                if (NewProvides(Ver, spzName, "any", Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
 893                   return false;
 894             }
 895          }
 896       } while (Start != Stop);
 897    }
 898
 899    if (APT::Configuration::checkArchitecture(Arch))
 900    {
 901       if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
 902       {
 903          string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
 904          if (NewProvides(Ver, Package, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
 905             return false;
 906       }
 907       else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
 908       {
 909          if (NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
 910             return false;
 911       }
 912    }
 913
 914    if (hasProvidesAlready == false)
 915    {
 916       pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
 917       if (spzPkg.end() == false)
 918       {
 919          if (NewProvides(Ver, spzName, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
 920             return false;
 921       }
 922    }
 923    return true;
 924 }
 925                                                                         /*}}}*/
 926 // ListParser::GrabWord - Matches a word and returns                    /*{{{*/
 927 // ---------------------------------------------------------------------
 928 /* Looks for a word in a list of words - for ParseStatus */
 929 bool debListParser::GrabWord(string Word,const WordList *List,unsigned char &Out)
 930 {
 931    for (unsigned int C = 0; List[C].Str != 0; C++)
 932    {
 933       if (strcasecmp(Word.c_str(),List[C].Str) == 0)
 934       {
 935          Out = List[C].Val;
 936          return true;
 937       }
 938    }
 939    return false;
 940 }
 941                                                                         /*}}}*/
 942 // ListParser::Step - Move to the next section in the file              /*{{{*/
 943 // ---------------------------------------------------------------------
 944 /* This has to be careful to only process the correct architecture */
 945 bool debListParser::Step()
 946 {
 947    iOffset = Tags.Offset();
 948    return Tags.Step(Section);
 949 }
 950                                                                         /*}}}*/
 951 // ListParser::GetPrio - Convert the priority from a string             /*{{{*/
 952 // ---------------------------------------------------------------------
 953 /* */
 954 unsigned char debListParser::GetPrio(string Str)
 955 {
 956    unsigned char Out;
 957    if (GrabWord(Str,PrioList,Out) == false)
 958       Out = pkgCache::State::Extra;
 959
 960    return Out;
 961 }
 962                                                                         /*}}}*/
 963 bool debListParser::SameVersion(unsigned short const Hash,              /*{{{*/
 964       pkgCache::VerIterator const &Ver)
 965 {
 966    if (pkgCacheListParser::SameVersion(Hash, Ver) == false)
 967       return false;
 968    // status file has no (Download)Size, but all others are fair game
 969    // status file is parsed last, so the first version we encounter is
 970    // probably also the version we have downloaded
 971    unsigned long long const Size = Section.FindULL("Size");
 972    if (Size != 0 && Size != Ver->Size)
 973       return false;
 974    // available everywhere, but easier to check here than to include in VersionHash
 975    unsigned char MultiArch = ParseMultiArch(false);
 976    if (MultiArch != Ver->MultiArch)
 977       return false;
 978    // for all practical proposes (we can check): same version
 979    return true;
 980 }
 981                                                                         /*}}}*/
 982
 983 debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)
 984    : debListParser(File), DebFile(DebFile)
 985 {
 986 }
 987
 988 bool debDebFileParser::UsePackage(pkgCache::PkgIterator &Pkg,
 989                                   pkgCache::VerIterator &Ver)
 990 {
 991    bool res = debListParser::UsePackage(Pkg, Ver);
 992    // we use the full file path as a provides so that the file is found
 993    // by its name
 994    if(NewProvides(Ver, DebFile, Pkg.Cache()->NativeArch(), Ver.VerStr(), 0) == false)
 995       return false;
 996    return res;
 997 }
 998
 999 debListParser::~debListParser() {}