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