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