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/fileutl.h>
  22 #include <apt-pkg/crc-16.h>
  23 #include <apt-pkg/md5.h>
  24 #include <apt-pkg/macros.h>
  25
  26 #include <ctype.h>
  27                                                                         /*}}}*/
  28
  29 using std::string;
  30
  31 static debListParser::WordList PrioList[] = {
  32    {"required",pkgCache::State::Required},
  33    {"important",pkgCache::State::Important},
  34    {"standard",pkgCache::State::Standard},
  35    {"optional",pkgCache::State::Optional},
  36    {"extra",pkgCache::State::Extra},
  37    {}};
  38
  39 // ListParser::debListParser - Constructor                              /*{{{*/
  40 // ---------------------------------------------------------------------
  41 /* Provide an architecture and only this one and "all" will be accepted
  42    in Step(), if no Architecture is given we will accept every arch
  43    we would accept in general with checkArchitecture() */
  44 debListParser::debListParser(FileFd *File, string const &Arch) : Tags(File),
  45                                 Arch(Arch) {
  46    if (Arch == "native")
  47       this->Arch = _config->Find("APT::Architecture");
  48    Architectures = APT::Configuration::getArchitectures();
  49    MultiArchEnabled = Architectures.size() > 1;
  50 }
  51                                                                         /*}}}*/
  52 // ListParser::UniqFindTagWrite - Find the tag and write a unq string   /*{{{*/
  53 // ---------------------------------------------------------------------
  54 /* */
  55 unsigned long debListParser::UniqFindTagWrite(const char *Tag)
  56 {
  57    const char *Start;
  58    const char *Stop;
  59    if (Section.Find(Tag,Start,Stop) == false)
  60       return 0;
  61    return WriteUniqString(Start,Stop - Start);
  62 }
  63                                                                         /*}}}*/
  64 // ListParser::Package - Return the package name                        /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* This is to return the name of the package this section describes */
  67 string debListParser::Package() {
  68    string const Result = Section.FindS("Package");
  69    if(unlikely(Result.empty() == true))
  70       _error->Error("Encountered a section with no Package: header");
  71    return Result;
  72 }
  73                                                                         /*}}}*/
  74 // ListParser::Architecture - Return the package arch                   /*{{{*/
  75 // ---------------------------------------------------------------------
  76 /* This will return the Architecture of the package this section describes */
  77 string debListParser::Architecture() {
  78    return Section.FindS("Architecture");
  79 }
  80                                                                         /*}}}*/
  81 // ListParser::ArchitectureAll                                          /*{{{*/
  82 // ---------------------------------------------------------------------
  83 /* */
  84 bool debListParser::ArchitectureAll() {
  85    return Section.FindS("Architecture") == "all";
  86 }
  87                                                                         /*}}}*/
  88 // ListParser::Version - Return the version string                      /*{{{*/
  89 // ---------------------------------------------------------------------
  90 /* This is to return the string describing the version in debian form,
  91    epoch:upstream-release. If this returns the blank string then the
  92    entry is assumed to only describe package properties */
  93 string debListParser::Version()
  94 {
  95    return Section.FindS("Version");
  96 }
  97                                                                         /*}}}*/
  98 // ListParser::NewVersion - Fill in the version structure               /*{{{*/
  99 // ---------------------------------------------------------------------
 100 /* */
 101 bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
 102 {
 103    // Parse the section
 104    Ver->Section = UniqFindTagWrite("Section");
 105
 106    // Parse multi-arch
 107    string const MultiArch = Section.FindS("Multi-Arch");
 108    if (MultiArch.empty() == true)
 109       Ver->MultiArch = pkgCache::Version::None;
 110    else if (MultiArch == "same") {
 111       // Parse multi-arch
 112       if (ArchitectureAll() == true)
 113       {
 114          /* Arch all packages can't be Multi-Arch: same */
 115          _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
 116                         Section.FindS("Package").c_str());
 117          Ver->MultiArch = pkgCache::Version::None;
 118       }
 119       else
 120          Ver->MultiArch = pkgCache::Version::Same;
 121    }
 122    else if (MultiArch == "foreign")
 123       Ver->MultiArch = pkgCache::Version::Foreign;
 124    else if (MultiArch == "allowed")
 125       Ver->MultiArch = pkgCache::Version::Allowed;
 126    else
 127    {
 128       _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
 129                         MultiArch.c_str(), Section.FindS("Package").c_str());
 130       Ver->MultiArch = pkgCache::Version::None;
 131    }
 132
 133    if (ArchitectureAll() == true)
 134       Ver->MultiArch |= pkgCache::Version::All;
 135
 136    // Archive Size
 137    Ver->Size = Section.FindULL("Size");
 138    // Unpacked Size (in K)
 139    Ver->InstalledSize = Section.FindULL("Installed-Size");
 140    Ver->InstalledSize *= 1024;
 141
 142    // Priority
 143    const char *Start;
 144    const char *Stop;
 145    if (Section.Find("Priority",Start,Stop) == true)
 146    {
 147       if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
 148          Ver->Priority = pkgCache::State::Extra;
 149    }
 150
 151    if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
 152       return false;
 153    if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
 154       return false;
 155    if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
 156       return false;
 157    if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
 158       return false;
 159    if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
 160       return false;
 161    if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
 162       return false;
 163    if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
 164       return false;
 165    if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
 166       return false;
 167
 168    // Obsolete.
 169    if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
 170       return false;
 171
 172    if (ParseProvides(Ver) == false)
 173       return false;
 174
 175    return true;
 176 }
 177                                                                         /*}}}*/
 178 // ListParser::Description - Return the description string              /*{{{*/
 179 // ---------------------------------------------------------------------
 180 /* This is to return the string describing the package in debian
 181    form. If this returns the blank string then the entry is assumed to
 182    only describe package properties */
 183 string debListParser::Description()
 184 {
 185    string const lang = DescriptionLanguage();
 186    if (lang.empty())
 187       return Section.FindS("Description");
 188    else
 189       return Section.FindS(string("Description-").append(lang).c_str());
 190 }
 191                                                                         /*}}}*/
 192 // ListParser::DescriptionLanguage - Return the description lang string /*{{{*/
 193 // ---------------------------------------------------------------------
 194 /* This is to return the string describing the language of
 195    description. If this returns the blank string then the entry is
 196    assumed to describe original description. */
 197 string debListParser::DescriptionLanguage()
 198 {
 199    if (Section.FindS("Description").empty() == false)
 200       return "";
 201
 202    std::vector<string> const lang = APT::Configuration::getLanguages(true);
 203    for (std::vector<string>::const_iterator l = lang.begin();
 204         l != lang.end(); ++l)
 205       if (Section.FindS(string("Description-").append(*l).c_str()).empty() == false)
 206          return *l;
 207
 208    return "";
 209 }
 210                                                                         /*}}}*/
 211 // ListParser::Description - Return the description_md5 MD5SumValue     /*{{{*/
 212 // ---------------------------------------------------------------------
 213 /* This is to return the md5 string to allow the check if it is the right
 214    description. If no Description-md5 is found in the section it will be
 215    calculated.
 216  */
 217 MD5SumValue debListParser::Description_md5()
 218 {
 219    string const value = Section.FindS("Description-md5");
 220    if (value.empty() == true)
 221    {
 222       std::string const desc = Description() + "\n";
 223       if (desc == "\n")
 224          return MD5SumValue();
 225
 226       MD5Summation md5;
 227       md5.Add(desc.c_str());
 228       return md5.Result();
 229    }
 230    else if (likely(value.size() == 32))
 231    {
 232       if (likely(value.find_first_not_of("0123456789abcdefABCDEF") == string::npos))
 233          return MD5SumValue(value);
 234       _error->Error("Malformed Description-md5 line; includes invalid character '%s'", value.c_str());
 235       return MD5SumValue();
 236    }
 237    _error->Error("Malformed Description-md5 line; doesn't have the required length (32 != %d) '%s'", (int)value.size(), value.c_str());
 238    return MD5SumValue();
 239 }
 240                                                                         /*}}}*/
 241 // ListParser::UsePackage - Update a package structure                  /*{{{*/
 242 // ---------------------------------------------------------------------
 243 /* This is called to update the package with any new information
 244    that might be found in the section */
 245 bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
 246                                pkgCache::VerIterator &Ver)
 247 {
 248    if (Pkg->Section == 0)
 249       Pkg->Section = UniqFindTagWrite("Section");
 250
 251    string const static myArch = _config->Find("APT::Architecture");
 252    // Possible values are: "all", "native", "installed" and "none"
 253    // The "installed" mode is handled by ParseStatus(), See #544481 and friends.
 254    string const static essential = _config->Find("pkgCacheGen::Essential", "all");
 255    if (essential == "all" ||
 256        (essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()))
 257       if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
 258          return false;
 259    if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
 260       return false;
 261
 262    if (strcmp(Pkg.Name(),"apt") == 0)
 263    {
 264       if ((essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()) ||
 265           essential == "all")
 266          Pkg->Flags |= pkgCache::Flag::Essential | pkgCache::Flag::Important;
 267       else
 268          Pkg->Flags |= pkgCache::Flag::Important;
 269    }
 270
 271    if (ParseStatus(Pkg,Ver) == false)
 272       return false;
 273    return true;
 274 }
 275                                                                         /*}}}*/
 276 // ListParser::VersionHash - Compute a unique hash for this version     /*{{{*/
 277 // ---------------------------------------------------------------------
 278 /* */
 279 unsigned short debListParser::VersionHash()
 280 {
 281    const char *Sections[] ={"Installed-Size",
 282                             "Depends",
 283                             "Pre-Depends",
 284 //                            "Suggests",
 285 //                            "Recommends",
 286                             "Conflicts",
 287                             "Breaks",
 288                             "Replaces",0};
 289    unsigned long Result = INIT_FCS;
 290    char S[1024];
 291    for (const char * const *I = Sections; *I != 0; ++I)
 292    {
 293       const char *Start;
 294       const char *End;
 295       if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S))
 296          continue;
 297
 298       /* Strip out any spaces from the text, this undoes dpkgs reformatting
 299          of certain fields. dpkg also has the rather interesting notion of
 300          reformatting depends operators < -> <= */
 301       char *J = S;
 302       for (; Start != End; ++Start)
 303       {
 304          if (isspace(*Start) != 0)
 305             continue;
 306          *J++ = tolower_ascii(*Start);
 307
 308          if ((*Start == '<' || *Start == '>') && Start[1] != *Start && Start[1] != '=')
 309             *J++ = '=';
 310       }
 311
 312       Result = AddCRC16(Result,S,J - S);
 313    }
 314
 315    return Result;
 316 }
 317                                                                         /*}}}*/
 318 // ListParser::ParseStatus - Parse the status field                     /*{{{*/
 319 // ---------------------------------------------------------------------
 320 /* Status lines are of the form,
 321      Status: want flag status
 322    want = unknown, install, hold, deinstall, purge
 323    flag = ok, reinstreq, hold, hold-reinstreq
 324    status = not-installed, unpacked, half-configured,
 325             half-installed, config-files, post-inst-failed,
 326             removal-failed, installed
 327
 328    Some of the above are obsolete (I think?) flag = hold-* and
 329    status = post-inst-failed, removal-failed at least.
 330  */
 331 bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
 332                                 pkgCache::VerIterator &Ver)
 333 {
 334    const char *Start;
 335    const char *Stop;
 336    if (Section.Find("Status",Start,Stop) == false)
 337       return true;
 338
 339    // UsePackage() is responsible for setting the flag in the default case
 340    bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed";
 341    if (essential == true &&
 342        Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
 343       return false;
 344
 345    // Isolate the first word
 346    const char *I = Start;
 347    for(; I < Stop && *I != ' '; I++);
 348    if (I >= Stop || *I != ' ')
 349       return _error->Error("Malformed Status line");
 350
 351    // Process the want field
 352    WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
 353                           {"install",pkgCache::State::Install},
 354                           {"hold",pkgCache::State::Hold},
 355                           {"deinstall",pkgCache::State::DeInstall},
 356                           {"purge",pkgCache::State::Purge},
 357                           {}};
 358    if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
 359       return _error->Error("Malformed 1st word in the Status line");
 360
 361    // Isloate the next word
 362    I++;
 363    Start = I;
 364    for(; I < Stop && *I != ' '; I++);
 365    if (I >= Stop || *I != ' ')
 366       return _error->Error("Malformed status line, no 2nd word");
 367
 368    // Process the flag field
 369    WordList FlagList[] = {{"ok",pkgCache::State::Ok},
 370                           {"reinstreq",pkgCache::State::ReInstReq},
 371                           {"hold",pkgCache::State::HoldInst},
 372                           {"hold-reinstreq",pkgCache::State::HoldReInstReq},
 373                           {}};
 374    if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
 375       return _error->Error("Malformed 2nd word in the Status line");
 376
 377    // Isloate the last word
 378    I++;
 379    Start = I;
 380    for(; I < Stop && *I != ' '; I++);
 381    if (I != Stop)
 382       return _error->Error("Malformed Status line, no 3rd word");
 383
 384    // Process the flag field
 385    WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
 386                             {"unpacked",pkgCache::State::UnPacked},
 387                             {"half-configured",pkgCache::State::HalfConfigured},
 388                             {"installed",pkgCache::State::Installed},
 389                             {"half-installed",pkgCache::State::HalfInstalled},
 390                             {"config-files",pkgCache::State::ConfigFiles},
 391                             {"triggers-awaited",pkgCache::State::TriggersAwaited},
 392                             {"triggers-pending",pkgCache::State::TriggersPending},
 393                             {"post-inst-failed",pkgCache::State::HalfConfigured},
 394                             {"removal-failed",pkgCache::State::HalfInstalled},
 395                             {}};
 396    if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
 397       return _error->Error("Malformed 3rd word in the Status line");
 398
 399    /* A Status line marks the package as indicating the current
 400       version as well. Only if it is actually installed.. Otherwise
 401       the interesting dpkg handling of the status file creates bogus
 402       entries. */
 403    if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
 404          Pkg->CurrentState == pkgCache::State::ConfigFiles))
 405    {
 406       if (Ver.end() == true)
 407          _error->Warning("Encountered status field in a non-version description");
 408       else
 409          Pkg->CurrentVer = Ver.Index();
 410    }
 411
 412    return true;
 413 }
 414
 415 const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
 416 {
 417    // Determine the operator
 418    switch (*I)
 419    {
 420       case '<':
 421       I++;
 422       if (*I == '=')
 423       {
 424          I++;
 425          Op = pkgCache::Dep::LessEq;
 426          break;
 427       }
 428
 429       if (*I == '<')
 430       {
 431          I++;
 432          Op = pkgCache::Dep::Less;
 433          break;
 434       }
 435
 436       // < is the same as <= and << is really Cs < for some reason
 437       Op = pkgCache::Dep::LessEq;
 438       break;
 439
 440       case '>':
 441       I++;
 442       if (*I == '=')
 443       {
 444          I++;
 445          Op = pkgCache::Dep::GreaterEq;
 446          break;
 447       }
 448
 449       if (*I == '>')
 450       {
 451          I++;
 452          Op = pkgCache::Dep::Greater;
 453          break;
 454       }
 455
 456       // > is the same as >= and >> is really Cs > for some reason
 457       Op = pkgCache::Dep::GreaterEq;
 458       break;
 459
 460       case '=':
 461       Op = pkgCache::Dep::Equals;
 462       I++;
 463       break;
 464
 465       // HACK around bad package definitions
 466       default:
 467       Op = pkgCache::Dep::Equals;
 468       break;
 469    }
 470    return I;
 471 }
 472                                                                         /*}}}*/
 473 // ListParser::ParseDepends - Parse a dependency element                /*{{{*/
 474 // ---------------------------------------------------------------------
 475 /* This parses the dependency elements out of a standard string in place,
 476    bit by bit. */
 477 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 478                                         string &Package,string &Ver,
 479                                         unsigned int &Op, bool const &ParseArchFlags,
 480                                         bool const &StripMultiArch)
 481 {
 482    // Strip off leading space
 483    for (;Start != Stop && isspace(*Start) != 0; Start++);
 484
 485    // Parse off the package name
 486    const char *I = Start;
 487    for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
 488         *I != ',' && *I != '|' && *I != '[' && *I != ']'; I++);
 489
 490    // Malformed, no '('
 491    if (I != Stop && *I == ')')
 492       return 0;
 493
 494    if (I == Start)
 495       return 0;
 496
 497    // Stash the package name
 498    Package.assign(Start,I - Start);
 499
 500    // We don't want to confuse library users which can't handle MultiArch
 501    string const arch = _config->Find("APT::Architecture");
 502    if (StripMultiArch == true) {
 503       size_t const found = Package.rfind(':');
 504       if (found != string::npos &&
 505           (strcmp(Package.c_str() + found, ":any") == 0 ||
 506            strcmp(Package.c_str() + found, ":native") == 0 ||
 507            strcmp(Package.c_str() + found + 1, arch.c_str()) == 0))
 508          Package = Package.substr(0,found);
 509    }
 510
 511    // Skip white space to the '('
 512    for (;I != Stop && isspace(*I) != 0 ; I++);
 513
 514    // Parse a version
 515    if (I != Stop && *I == '(')
 516    {
 517       // Skip the '('
 518       for (I++; I != Stop && isspace(*I) != 0 ; I++);
 519       if (I + 3 >= Stop)
 520          return 0;
 521       I = ConvertRelation(I,Op);
 522
 523       // Skip whitespace
 524       for (;I != Stop && isspace(*I) != 0; I++);
 525       Start = I;
 526       I = (const char*) memchr(I, ')', Stop - I);
 527       if (I == NULL || Start == I)
 528          return 0;
 529
 530       // Skip trailing whitespace
 531       const char *End = I;
 532       for (; End > Start && isspace(End[-1]); End--);
 533
 534       Ver.assign(Start,End-Start);
 535       I++;
 536    }
 537    else
 538    {
 539       Ver.clear();
 540       Op = pkgCache::Dep::NoOp;
 541    }
 542
 543    // Skip whitespace
 544    for (;I != Stop && isspace(*I) != 0; I++);
 545
 546    if (ParseArchFlags == true)
 547    {
 548       APT::CacheFilter::PackageArchitectureMatchesSpecification matchesArch(arch, false);
 549
 550       // Parse an architecture
 551       if (I != Stop && *I == '[')
 552       {
 553          ++I;
 554          // malformed
 555          if (unlikely(I == Stop))
 556             return 0;
 557
 558          const char *End = I;
 559          bool Found = false;
 560          bool NegArch = false;
 561          while (I != Stop)
 562          {
 563             // look for whitespace or ending ']'
 564             for (;End != Stop && !isspace(*End) && *End != ']'; ++End);
 565
 566             if (unlikely(End == Stop))
 567                return 0;
 568
 569             if (*I == '!')
 570             {
 571                NegArch = true;
 572                ++I;
 573             }
 574
 575             std::string arch(I, End);
 576             if (arch.empty() == false && matchesArch(arch.c_str()) == true)
 577             {
 578                Found = true;
 579                if (I[-1] != '!')
 580                   NegArch = false;
 581                // we found a match, so fast-forward to the end of the wildcards
 582                for (; End != Stop && *End != ']'; ++End);
 583             }
 584
 585             if (*End++ == ']') {
 586                I = End;
 587                break;
 588             }
 589
 590             I = End;
 591             for (;I != Stop && isspace(*I) != 0; I++);
 592          }
 593
 594          if (NegArch == true)
 595             Found = !Found;
 596
 597          if (Found == false)
 598             Package = ""; /* not for this arch */
 599       }
 600
 601       // Skip whitespace
 602       for (;I != Stop && isspace(*I) != 0; I++);
 603    }
 604
 605    if (I != Stop && *I == '|')
 606       Op |= pkgCache::Dep::Or;
 607
 608    if (I == Stop || *I == ',' || *I == '|')
 609    {
 610       if (I != Stop)
 611          for (I++; I != Stop && isspace(*I) != 0; I++);
 612       return I;
 613    }
 614
 615    return 0;
 616 }
 617                                                                         /*}}}*/
 618 // ListParser::ParseDepends - Parse a dependency list                   /*{{{*/
 619 // ---------------------------------------------------------------------
 620 /* This is the higher level depends parser. It takes a tag and generates
 621    a complete depends tree for the given version. */
 622 bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
 623                                  const char *Tag,unsigned int Type)
 624 {
 625    const char *Start;
 626    const char *Stop;
 627    if (Section.Find(Tag,Start,Stop) == false)
 628       return true;
 629
 630    string const pkgArch = Ver.Arch();
 631
 632    while (1)
 633    {
 634       string Package;
 635       string Version;
 636       unsigned int Op;
 637
 638       Start = ParseDepends(Start, Stop, Package, Version, Op, false, false);
 639       if (Start == 0)
 640          return _error->Error("Problem parsing dependency %s",Tag);
 641       size_t const found = Package.rfind(':');
 642
 643       // If negative is unspecific it needs to apply on all architectures
 644       if (MultiArchEnabled == true && found == string::npos &&
 645           (Type == pkgCache::Dep::Conflicts ||
 646            Type == pkgCache::Dep::DpkgBreaks ||
 647            Type == pkgCache::Dep::Replaces))
 648       {
 649          for (std::vector<std::string>::const_iterator a = Architectures.begin();
 650               a != Architectures.end(); ++a)
 651             if (NewDepends(Ver,Package,*a,Version,Op,Type) == false)
 652                return false;
 653          if (NewDepends(Ver,Package,"none",Version,Op,Type) == false)
 654             return false;
 655       }
 656       else if (MultiArchEnabled == true && found != string::npos &&
 657                strcmp(Package.c_str() + found, ":any") != 0)
 658       {
 659          string Arch = Package.substr(found+1, string::npos);
 660          Package = Package.substr(0, found);
 661          // Such dependencies are not supposed to be accepted …
 662          // … but this is probably the best thing to do.
 663          if (Arch == "native")
 664             Arch = _config->Find("APT::Architecture");
 665          if (NewDepends(Ver,Package,Arch,Version,Op,Type) == false)
 666             return false;
 667       }
 668       else
 669       {
 670          if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
 671             return false;
 672          if ((Type == pkgCache::Dep::Conflicts ||
 673               Type == pkgCache::Dep::DpkgBreaks ||
 674               Type == pkgCache::Dep::Replaces) &&
 675              NewDepends(Ver, Package,
 676                         (pkgArch != "none") ? "none" : _config->Find("APT::Architecture"),
 677                         Version,Op,Type) == false)
 678             return false;
 679       }
 680       if (Start == Stop)
 681          break;
 682    }
 683    return true;
 684 }
 685                                                                         /*}}}*/
 686 // ListParser::ParseProvides - Parse the provides list                  /*{{{*/
 687 // ---------------------------------------------------------------------
 688 /* */
 689 bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
 690 {
 691    const char *Start;
 692    const char *Stop;
 693    if (Section.Find("Provides",Start,Stop) == true)
 694    {
 695       string Package;
 696       string Version;
 697       string const Arch = Ver.Arch();
 698       unsigned int Op;
 699
 700       while (1)
 701       {
 702          Start = ParseDepends(Start,Stop,Package,Version,Op);
 703          if (Start == 0)
 704             return _error->Error("Problem parsing Provides line");
 705          if (Op != pkgCache::Dep::NoOp) {
 706             _error->Warning("Ignoring Provides line with DepCompareOp for package %s", Package.c_str());
 707          } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
 708             if (NewProvidesAllArch(Ver, Package, Version) == false)
 709                return false;
 710          } else {
 711             if (NewProvides(Ver, Package, Arch, Version) == false)
 712                return false;
 713          }
 714
 715          if (Start == Stop)
 716             break;
 717       }
 718    }
 719
 720    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
 721    {
 722       string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
 723       return NewProvidesAllArch(Ver, Package, Ver.VerStr());
 724    }
 725    else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
 726       return NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr());
 727
 728    return true;
 729 }
 730                                                                         /*}}}*/
 731 // ListParser::NewProvides - add provides for all architectures         /*{{{*/
 732 bool debListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
 733                                 string const &Version) {
 734    for (std::vector<string>::const_iterator a = Architectures.begin();
 735         a != Architectures.end(); ++a)
 736    {
 737       if (NewProvides(Ver, Package, *a, Version) == false)
 738          return false;
 739    }
 740    return true;
 741 }
 742                                                                         /*}}}*/
 743 // ListParser::GrabWord - Matches a word and returns                    /*{{{*/
 744 // ---------------------------------------------------------------------
 745 /* Looks for a word in a list of words - for ParseStatus */
 746 bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
 747 {
 748    for (unsigned int C = 0; List[C].Str != 0; C++)
 749    {
 750       if (strcasecmp(Word.c_str(),List[C].Str) == 0)
 751       {
 752          Out = List[C].Val;
 753          return true;
 754       }
 755    }
 756    return false;
 757 }
 758                                                                         /*}}}*/
 759 // ListParser::Step - Move to the next section in the file              /*{{{*/
 760 // ---------------------------------------------------------------------
 761 /* This has to be carefull to only process the correct architecture */
 762 bool debListParser::Step()
 763 {
 764    iOffset = Tags.Offset();
 765    while (Tags.Step(Section) == true)
 766    {
 767       /* See if this is the correct Architecture, if it isn't then we
 768          drop the whole section. A missing arch tag only happens (in theory)
 769          inside the Status file, so that is a positive return */
 770       string const Architecture = Section.FindS("Architecture");
 771
 772       if (Arch.empty() == true || Arch == "any" || MultiArchEnabled == false)
 773       {
 774          if (APT::Configuration::checkArchitecture(Architecture) == true)
 775             return true;
 776          /* parse version stanzas without an architecture only in the status file
 777             (and as misfortune bycatch flat-archives) */
 778          if ((Arch.empty() == true || Arch == "any") && Architecture.empty() == true)
 779             return true;
 780       }
 781       else
 782       {
 783          if (Architecture == Arch)
 784             return true;
 785
 786          if (Architecture == "all" && Arch == _config->Find("APT::Architecture"))
 787             return true;
 788       }
 789
 790       iOffset = Tags.Offset();
 791    }
 792    return false;
 793 }
 794                                                                         /*}}}*/
 795 // ListParser::LoadReleaseInfo - Load the release information           /*{{{*/
 796 // ---------------------------------------------------------------------
 797 /* */
 798 bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
 799                                     FileFd &File, string component)
 800 {
 801    // apt-secure does no longer download individual (per-section) Release
 802    // file. to provide Component pinning we use the section name now
 803    map_ptrloc const storage = WriteUniqString(component);
 804    FileI->Component = storage;
 805
 806    pkgTagFile TagFile(&File, File.Size());
 807    pkgTagSection Section;
 808    if (_error->PendingError() == true || TagFile.Step(Section) == false)
 809       return false;
 810
 811    std::string data;
 812    #define APT_INRELEASE(TAG, STORE) \
 813    data = Section.FindS(TAG); \
 814    if (data.empty() == false) \
 815    { \
 816       map_ptrloc const storage = WriteUniqString(data); \
 817       STORE = storage; \
 818    }
 819    APT_INRELEASE("Suite", FileI->Archive)
 820    APT_INRELEASE("Component", FileI->Component)
 821    APT_INRELEASE("Version", FileI->Version)
 822    APT_INRELEASE("Origin", FileI->Origin)
 823    APT_INRELEASE("Codename", FileI->Codename)
 824    APT_INRELEASE("Label", FileI->Label)
 825    #undef APT_INRELEASE
 826    Section.FindFlag("NotAutomatic", FileI->Flags, pkgCache::Flag::NotAutomatic);
 827    Section.FindFlag("ButAutomaticUpgrades", FileI->Flags, pkgCache::Flag::ButAutomaticUpgrades);
 828
 829    return !_error->PendingError();
 830 }
 831                                                                         /*}}}*/
 832 // ListParser::GetPrio - Convert the priority from a string             /*{{{*/
 833 // ---------------------------------------------------------------------
 834 /* */
 835 unsigned char debListParser::GetPrio(string Str)
 836 {
 837    unsigned char Out;
 838    if (GrabWord(Str,PrioList,Out) == false)
 839       Out = pkgCache::State::Extra;
 840
 841    return Out;
 842 }
 843                                                                         /*}}}*/