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)
 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, hold, hold-reinstreq
 342    status = not-installed, unpacked, half-configured,
 343             half-installed, config-files, post-inst-failed,
 344             removal-failed, installed
 345
 346    Some of the above are obsolete (I think?) flag = hold-* and
 347    status = post-inst-failed, removal-failed at least.
 348  */
 349 bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
 350                                 pkgCache::VerIterator &Ver)
 351 {
 352    const char *Start;
 353    const char *Stop;
 354    if (Section.Find("Status",Start,Stop) == false)
 355       return true;
 356
 357    // UsePackage() is responsible for setting the flag in the default case
 358    bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed";
 359    if (essential == true &&
 360        Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
 361       return false;
 362
 363    // Isolate the first word
 364    const char *I = Start;
 365    for(; I < Stop && *I != ' '; I++);
 366    if (I >= Stop || *I != ' ')
 367       return _error->Error("Malformed Status line");
 368
 369    // Process the want field
 370    WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
 371                           {"install",pkgCache::State::Install},
 372                           {"hold",pkgCache::State::Hold},
 373                           {"deinstall",pkgCache::State::DeInstall},
 374                           {"purge",pkgCache::State::Purge},
 375                           {NULL, 0}};
 376    if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
 377       return _error->Error("Malformed 1st word in the Status line");
 378
 379    // Isloate the next word
 380    I++;
 381    Start = I;
 382    for(; I < Stop && *I != ' '; I++);
 383    if (I >= Stop || *I != ' ')
 384       return _error->Error("Malformed status line, no 2nd word");
 385
 386    // Process the flag field
 387    WordList FlagList[] = {{"ok",pkgCache::State::Ok},
 388                           {"reinstreq",pkgCache::State::ReInstReq},
 389                           {"hold",pkgCache::State::HoldInst},
 390                           {"hold-reinstreq",pkgCache::State::HoldReInstReq},
 391                           {NULL, 0}};
 392    if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
 393       return _error->Error("Malformed 2nd word in the Status line");
 394
 395    // Isloate the last word
 396    I++;
 397    Start = I;
 398    for(; I < Stop && *I != ' '; I++);
 399    if (I != Stop)
 400       return _error->Error("Malformed Status line, no 3rd word");
 401
 402    // Process the flag field
 403    WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
 404                             {"unpacked",pkgCache::State::UnPacked},
 405                             {"half-configured",pkgCache::State::HalfConfigured},
 406                             {"installed",pkgCache::State::Installed},
 407                             {"half-installed",pkgCache::State::HalfInstalled},
 408                             {"config-files",pkgCache::State::ConfigFiles},
 409                             {"triggers-awaited",pkgCache::State::TriggersAwaited},
 410                             {"triggers-pending",pkgCache::State::TriggersPending},
 411                             {"post-inst-failed",pkgCache::State::HalfConfigured},
 412                             {"removal-failed",pkgCache::State::HalfInstalled},
 413                             {NULL, 0}};
 414    if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
 415       return _error->Error("Malformed 3rd word in the Status line");
 416
 417    /* A Status line marks the package as indicating the current
 418       version as well. Only if it is actually installed.. Otherwise
 419       the interesting dpkg handling of the status file creates bogus
 420       entries. */
 421    if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
 422          Pkg->CurrentState == pkgCache::State::ConfigFiles))
 423    {
 424       if (Ver.end() == true)
 425          _error->Warning("Encountered status field in a non-version description");
 426       else
 427          Pkg->CurrentVer = Ver.Index();
 428    }
 429
 430    return true;
 431 }
 432
 433 const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
 434 {
 435    // Determine the operator
 436    switch (*I)
 437    {
 438       case '<':
 439       I++;
 440       if (*I == '=')
 441       {
 442          I++;
 443          Op = pkgCache::Dep::LessEq;
 444          break;
 445       }
 446
 447       if (*I == '<')
 448       {
 449          I++;
 450          Op = pkgCache::Dep::Less;
 451          break;
 452       }
 453
 454       // < is the same as <= and << is really Cs < for some reason
 455       Op = pkgCache::Dep::LessEq;
 456       break;
 457
 458       case '>':
 459       I++;
 460       if (*I == '=')
 461       {
 462          I++;
 463          Op = pkgCache::Dep::GreaterEq;
 464          break;
 465       }
 466
 467       if (*I == '>')
 468       {
 469          I++;
 470          Op = pkgCache::Dep::Greater;
 471          break;
 472       }
 473
 474       // > is the same as >= and >> is really Cs > for some reason
 475       Op = pkgCache::Dep::GreaterEq;
 476       break;
 477
 478       case '=':
 479       Op = pkgCache::Dep::Equals;
 480       I++;
 481       break;
 482
 483       // HACK around bad package definitions
 484       default:
 485       Op = pkgCache::Dep::Equals;
 486       break;
 487    }
 488    return I;
 489 }
 490                                                                         /*}}}*/
 491 // ListParser::ParseDepends - Parse a dependency element                /*{{{*/
 492 // ---------------------------------------------------------------------
 493 /* This parses the dependency elements out of a standard string in place,
 494    bit by bit. */
 495 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 496                std::string &Package,std::string &Ver,unsigned int &Op)
 497    { return ParseDepends(Start, Stop, Package, Ver, Op, false, true, false); }
 498 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 499                std::string &Package,std::string &Ver,unsigned int &Op,
 500                bool const &ParseArchFlags)
 501    { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, true, false); }
 502 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 503                std::string &Package,std::string &Ver,unsigned int &Op,
 504                bool const &ParseArchFlags, bool const &StripMultiArch)
 505    { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, StripMultiArch, false); }
 506 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 507                                         string &Package,string &Ver,
 508                                         unsigned int &Op, bool const &ParseArchFlags,
 509                                         bool const &StripMultiArch,
 510                                         bool const &ParseRestrictionsList)
 511 {
 512    // Strip off leading space
 513    for (;Start != Stop && isspace(*Start) != 0; ++Start);
 514
 515    // Parse off the package name
 516    const char *I = Start;
 517    for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
 518         *I != ',' && *I != '|' && *I != '[' && *I != ']' &&
 519         *I != '<' && *I != '>'; ++I);
 520
 521    // Malformed, no '('
 522    if (I != Stop && *I == ')')
 523       return 0;
 524
 525    if (I == Start)
 526       return 0;
 527
 528    // Stash the package name
 529    Package.assign(Start,I - Start);
 530
 531    // We don't want to confuse library users which can't handle MultiArch
 532    string const arch = _config->Find("APT::Architecture");
 533    if (StripMultiArch == true) {
 534       size_t const found = Package.rfind(':');
 535       if (found != string::npos &&
 536           (strcmp(Package.c_str() + found, ":any") == 0 ||
 537            strcmp(Package.c_str() + found, ":native") == 0 ||
 538            strcmp(Package.c_str() + found + 1, arch.c_str()) == 0))
 539          Package = Package.substr(0,found);
 540    }
 541
 542    // Skip white space to the '('
 543    for (;I != Stop && isspace(*I) != 0 ; I++);
 544
 545    // Parse a version
 546    if (I != Stop && *I == '(')
 547    {
 548       // Skip the '('
 549       for (I++; I != Stop && isspace(*I) != 0 ; I++);
 550       if (I + 3 >= Stop)
 551          return 0;
 552       I = ConvertRelation(I,Op);
 553
 554       // Skip whitespace
 555       for (;I != Stop && isspace(*I) != 0; I++);
 556       Start = I;
 557       I = (const char*) memchr(I, ')', Stop - I);
 558       if (I == NULL || Start == I)
 559          return 0;
 560
 561       // Skip trailing whitespace
 562       const char *End = I;
 563       for (; End > Start && isspace(End[-1]); End--);
 564
 565       Ver.assign(Start,End-Start);
 566       I++;
 567    }
 568    else
 569    {
 570       Ver.clear();
 571       Op = pkgCache::Dep::NoOp;
 572    }
 573
 574    // Skip whitespace
 575    for (;I != Stop && isspace(*I) != 0; I++);
 576
 577    if (ParseArchFlags == true)
 578    {
 579       APT::CacheFilter::PackageArchitectureMatchesSpecification matchesArch(arch, false);
 580
 581       // Parse an architecture
 582       if (I != Stop && *I == '[')
 583       {
 584          ++I;
 585          // malformed
 586          if (unlikely(I == Stop))
 587             return 0;
 588
 589          const char *End = I;
 590          bool Found = false;
 591          bool NegArch = false;
 592          while (I != Stop)
 593          {
 594             // look for whitespace or ending ']'
 595             for (;End != Stop && !isspace(*End) && *End != ']'; ++End);
 596
 597             if (unlikely(End == Stop))
 598                return 0;
 599
 600             if (*I == '!')
 601             {
 602                NegArch = true;
 603                ++I;
 604             }
 605
 606             std::string arch(I, End);
 607             if (arch.empty() == false && matchesArch(arch.c_str()) == true)
 608             {
 609                Found = true;
 610                if (I[-1] != '!')
 611                   NegArch = false;
 612                // we found a match, so fast-forward to the end of the wildcards
 613                for (; End != Stop && *End != ']'; ++End);
 614             }
 615
 616             if (*End++ == ']') {
 617                I = End;
 618                break;
 619             }
 620
 621             I = End;
 622             for (;I != Stop && isspace(*I) != 0; I++);
 623          }
 624
 625          if (NegArch == true)
 626             Found = !Found;
 627
 628          if (Found == false)
 629             Package = ""; /* not for this arch */
 630       }
 631
 632       // Skip whitespace
 633       for (;I != Stop && isspace(*I) != 0; I++);
 634    }
 635
 636    if (ParseRestrictionsList == true)
 637    {
 638       // Parse a restrictions list
 639       if (I != Stop && *I == '<')
 640       {
 641          ++I;
 642          // malformed
 643          if (unlikely(I == Stop))
 644             return 0;
 645
 646          std::vector<string> const profiles = APT::Configuration::getBuildProfiles();
 647
 648          const char *End = I;
 649          bool Found = false;
 650          bool NegRestriction = false;
 651          while (I != Stop)
 652          {
 653             // look for whitespace or ending '>'
 654             for (;End != Stop && !isspace(*End) && *End != '>'; ++End);
 655
 656             if (unlikely(End == Stop))
 657                return 0;
 658
 659             if (*I == '!')
 660             {
 661                NegRestriction = true;
 662                ++I;
 663             }
 664
 665             std::string restriction(I, End);
 666
 667             std::string prefix = "profile.";
 668             // only support for "profile" prefix, ignore others
 669             if (restriction.size() > prefix.size() &&
 670                   restriction.substr(0, prefix.size()) == prefix)
 671             {
 672                // get the name of the profile
 673                restriction = restriction.substr(prefix.size());
 674
 675                if (restriction.empty() == false && profiles.empty() == false &&
 676                      std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
 677                {
 678                   Found = true;
 679                   if (I[-1] != '!')
 680                      NegRestriction = false;
 681                   // we found a match, so fast-forward to the end of the wildcards
 682                   for (; End != Stop && *End != '>'; ++End);
 683                }
 684             }
 685
 686             if (*End++ == '>') {
 687                I = End;
 688                break;
 689             }
 690
 691             I = End;
 692             for (;I != Stop && isspace(*I) != 0; I++);
 693          }
 694
 695          if (NegRestriction == true)
 696             Found = !Found;
 697
 698          if (Found == false)
 699             Package = ""; /* not for this restriction */
 700       }
 701
 702       // Skip whitespace
 703       for (;I != Stop && isspace(*I) != 0; I++);
 704    }
 705
 706    if (I != Stop && *I == '|')
 707       Op |= pkgCache::Dep::Or;
 708
 709    if (I == Stop || *I == ',' || *I == '|')
 710    {
 711       if (I != Stop)
 712          for (I++; I != Stop && isspace(*I) != 0; I++);
 713       return I;
 714    }
 715
 716    return 0;
 717 }
 718                                                                         /*}}}*/
 719 // ListParser::ParseDepends - Parse a dependency list                   /*{{{*/
 720 // ---------------------------------------------------------------------
 721 /* This is the higher level depends parser. It takes a tag and generates
 722    a complete depends tree for the given version. */
 723 bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
 724                                  const char *Tag,unsigned int Type)
 725 {
 726    const char *Start;
 727    const char *Stop;
 728    if (Section.Find(Tag,Start,Stop) == false)
 729       return true;
 730
 731    string const pkgArch = Ver.Arch();
 732
 733    while (1)
 734    {
 735       string Package;
 736       string Version;
 737       unsigned int Op;
 738
 739       Start = ParseDepends(Start, Stop, Package, Version, Op, false, false, false);
 740       if (Start == 0)
 741          return _error->Error("Problem parsing dependency %s",Tag);
 742       size_t const found = Package.rfind(':');
 743
 744       // If negative is unspecific it needs to apply on all architectures
 745       if (MultiArchEnabled == true && found == string::npos &&
 746           (Type == pkgCache::Dep::Conflicts ||
 747            Type == pkgCache::Dep::DpkgBreaks ||
 748            Type == pkgCache::Dep::Replaces))
 749       {
 750          for (std::vector<std::string>::const_iterator a = Architectures.begin();
 751               a != Architectures.end(); ++a)
 752             if (NewDepends(Ver,Package,*a,Version,Op,Type) == false)
 753                return false;
 754          if (NewDepends(Ver,Package,"none",Version,Op,Type) == false)
 755             return false;
 756       }
 757       else if (MultiArchEnabled == true && found != string::npos &&
 758                strcmp(Package.c_str() + found, ":any") != 0)
 759       {
 760          string Arch = Package.substr(found+1, string::npos);
 761          Package = Package.substr(0, found);
 762          // Such dependencies are not supposed to be accepted …
 763          // … but this is probably the best thing to do.
 764          if (Arch == "native")
 765             Arch = _config->Find("APT::Architecture");
 766          if (NewDepends(Ver,Package,Arch,Version,Op,Type) == false)
 767             return false;
 768       }
 769       else
 770       {
 771          if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
 772             return false;
 773          if ((Type == pkgCache::Dep::Conflicts ||
 774               Type == pkgCache::Dep::DpkgBreaks ||
 775               Type == pkgCache::Dep::Replaces) &&
 776              NewDepends(Ver, Package,
 777                         (pkgArch != "none") ? "none" : _config->Find("APT::Architecture"),
 778                         Version,Op,Type) == false)
 779             return false;
 780       }
 781       if (Start == Stop)
 782          break;
 783    }
 784    return true;
 785 }
 786                                                                         /*}}}*/
 787 // ListParser::ParseProvides - Parse the provides list                  /*{{{*/
 788 // ---------------------------------------------------------------------
 789 /* */
 790 bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
 791 {
 792    const char *Start;
 793    const char *Stop;
 794    if (Section.Find("Provides",Start,Stop) == true)
 795    {
 796       string Package;
 797       string Version;
 798       string const Arch = Ver.Arch();
 799       unsigned int Op;
 800
 801       while (1)
 802       {
 803          Start = ParseDepends(Start,Stop,Package,Version,Op);
 804          if (Start == 0)
 805             return _error->Error("Problem parsing Provides line");
 806          if (Op != pkgCache::Dep::NoOp) {
 807             _error->Warning("Ignoring Provides line with DepCompareOp for package %s", Package.c_str());
 808          } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
 809             if (NewProvidesAllArch(Ver, Package, Version) == false)
 810                return false;
 811          } else {
 812             if (NewProvides(Ver, Package, Arch, Version) == false)
 813                return false;
 814          }
 815
 816          if (Start == Stop)
 817             break;
 818       }
 819    }
 820
 821    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
 822    {
 823       string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
 824       return NewProvidesAllArch(Ver, Package, Ver.VerStr());
 825    }
 826    else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
 827       return NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr());
 828
 829    return true;
 830 }
 831                                                                         /*}}}*/
 832 // ListParser::NewProvides - add provides for all architectures         /*{{{*/
 833 bool debListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
 834                                 string const &Version) {
 835    for (std::vector<string>::const_iterator a = Architectures.begin();
 836         a != Architectures.end(); ++a)
 837    {
 838       if (NewProvides(Ver, Package, *a, Version) == false)
 839          return false;
 840    }
 841    return true;
 842 }
 843                                                                         /*}}}*/
 844 // ListParser::GrabWord - Matches a word and returns                    /*{{{*/
 845 // ---------------------------------------------------------------------
 846 /* Looks for a word in a list of words - for ParseStatus */
 847 bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
 848 {
 849    for (unsigned int C = 0; List[C].Str != 0; C++)
 850    {
 851       if (strcasecmp(Word.c_str(),List[C].Str) == 0)
 852       {
 853          Out = List[C].Val;
 854          return true;
 855       }
 856    }
 857    return false;
 858 }
 859                                                                         /*}}}*/
 860 // ListParser::Step - Move to the next section in the file              /*{{{*/
 861 // ---------------------------------------------------------------------
 862 /* This has to be careful to only process the correct architecture */
 863 bool debListParser::Step()
 864 {
 865    iOffset = Tags.Offset();
 866    while (Tags.Step(Section) == true)
 867    {
 868       /* See if this is the correct Architecture, if it isn't then we
 869          drop the whole section. A missing arch tag only happens (in theory)
 870          inside the Status file, so that is a positive return */
 871       string const Architecture = Section.FindS("Architecture");
 872
 873       if (Arch.empty() == true || Arch == "any" || MultiArchEnabled == false)
 874       {
 875          if (APT::Configuration::checkArchitecture(Architecture) == true)
 876             return true;
 877          /* parse version stanzas without an architecture only in the status file
 878             (and as misfortune bycatch flat-archives) */
 879          if ((Arch.empty() == true || Arch == "any") && Architecture.empty() == true)
 880             return true;
 881       }
 882       else
 883       {
 884          if (Architecture == Arch)
 885             return true;
 886
 887          if (Architecture == "all" && Arch == _config->Find("APT::Architecture"))
 888             return true;
 889       }
 890
 891       iOffset = Tags.Offset();
 892    }
 893    return false;
 894 }
 895                                                                         /*}}}*/
 896 // ListParser::LoadReleaseInfo - Load the release information           /*{{{*/
 897 // ---------------------------------------------------------------------
 898 /* */
 899 bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
 900                                     FileFd &File, string component)
 901 {
 902    // apt-secure does no longer download individual (per-section) Release
 903    // file. to provide Component pinning we use the section name now
 904    map_ptrloc const storage = WriteUniqString(component);
 905    FileI->Component = storage;
 906
 907    pkgTagFile TagFile(&File, File.Size());
 908    pkgTagSection Section;
 909    if (_error->PendingError() == true || TagFile.Step(Section) == false)
 910       return false;
 911
 912    std::string data;
 913    #define APT_INRELEASE(TAG, STORE) \
 914    data = Section.FindS(TAG); \
 915    if (data.empty() == false) \
 916    { \
 917       map_ptrloc const storage = WriteUniqString(data); \
 918       STORE = storage; \
 919    }
 920    APT_INRELEASE("Suite", FileI->Archive)
 921    APT_INRELEASE("Component", FileI->Component)
 922    APT_INRELEASE("Version", FileI->Version)
 923    APT_INRELEASE("Origin", FileI->Origin)
 924    APT_INRELEASE("Codename", FileI->Codename)
 925    APT_INRELEASE("Label", FileI->Label)
 926    #undef APT_INRELEASE
 927    Section.FindFlag("NotAutomatic", FileI->Flags, pkgCache::Flag::NotAutomatic);
 928    Section.FindFlag("ButAutomaticUpgrades", FileI->Flags, pkgCache::Flag::ButAutomaticUpgrades);
 929
 930    return !_error->PendingError();
 931 }
 932                                                                         /*}}}*/
 933 // ListParser::GetPrio - Convert the priority from a string             /*{{{*/
 934 // ---------------------------------------------------------------------
 935 /* */
 936 unsigned char debListParser::GetPrio(string Str)
 937 {
 938    unsigned char Out;
 939    if (GrabWord(Str,PrioList,Out) == false)
 940       Out = pkgCache::State::Extra;
 941
 942    return Out;
 943 }
 944                                                                         /*}}}*/
 945 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
 946 bool debListParser::SameVersion(unsigned short const Hash,              /*{{{*/
 947       pkgCache::VerIterator const &Ver)
 948 {
 949    if (pkgCacheGenerator::ListParser::SameVersion(Hash, Ver) == false)
 950       return false;
 951    // status file has no (Download)Size, but all others are fair game
 952    // status file is parsed last, so the first version we encounter is
 953    // probably also the version we have downloaded
 954    unsigned long long const Size = Section.FindULL("Size");
 955    if (Size != 0 && Size != Ver->Size)
 956       return false;
 957    // available everywhere, but easier to check here than to include in VersionHash
 958    unsigned char MultiArch = ParseMultiArch(false);
 959    if (MultiArch != Ver->MultiArch)
 960       return false;
 961    // for all practical proposes (we can check): same version
 962    return true;
 963 }
 964                                                                         /*}}}*/
 965 #endif