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