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