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