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