apt-pkg/deb/deblistparser.cc

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