apt-pkg/depcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: depcache.cc,v 1.25 2001/05/27 05:36:04 jgg Exp $
   4 /* ######################################################################
   5
   6    Dependency Cache - Caches Dependency information.
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #ifdef __GNUG__
  12 #pragma implementation "apt-pkg/depcache.h"
  13 #endif
  14 #include <apt-pkg/depcache.h>
  15 #include <apt-pkg/version.h>
  16 #include <apt-pkg/error.h>
  17 #include <apt-pkg/sptr.h>
  18 #include <apt-pkg/algorithms.h>
  19
  20 #include <apt-pkg/fileutl.h>
  21 #include <apt-pkg/configuration.h>
  22 #include <apt-pkg/pkgsystem.h>
  23 #include <apt-pkg/tagfile.h>
  24
  25 #include <iostream>
  26 #include <sstream>
  27 #include <set>
  28
  29 #include <apti18n.h>
  30
  31 pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) :
  32   cache(cache), released(false)
  33 {
  34   ++cache.group_level;
  35 }
  36
  37 void pkgDepCache::ActionGroup::release()
  38 {
  39   if(!released)
  40     {
  41       if(cache.group_level == 0)
  42         std::cerr << "W: Unbalanced action groups, expect badness" << std::endl;
  43       else
  44         {
  45           --cache.group_level;
  46
  47           if(cache.group_level == 0)
  48             cache.MarkAndSweep();
  49         }
  50
  51       released = false;
  52     }
  53 }
  54
  55 pkgDepCache::ActionGroup::~ActionGroup()
  56 {
  57   release();
  58 }
  59
  60 // DepCache::pkgDepCache - Constructors                                 /*{{{*/
  61 // ---------------------------------------------------------------------
  62 /* */
  63 pkgDepCache::pkgDepCache(pkgCache *pCache,Policy *Plcy) :
  64   group_level(0), Cache(pCache), PkgState(0), DepState(0)
  65 {
  66    delLocalPolicy = 0;
  67    LocalPolicy = Plcy;
  68    if (LocalPolicy == 0)
  69       delLocalPolicy = LocalPolicy = new Policy;
  70 }
  71                                                                         /*}}}*/
  72 // DepCache::~pkgDepCache - Destructor                                  /*{{{*/
  73 // ---------------------------------------------------------------------
  74 /* */
  75 pkgDepCache::~pkgDepCache()
  76 {
  77    delete [] PkgState;
  78    delete [] DepState;
  79    delete delLocalPolicy;
  80 }
  81                                                                         /*}}}*/
  82 // DepCache::Init - Generate the initial extra structures.              /*{{{*/
  83 // ---------------------------------------------------------------------
  84 /* This allocats the extension buffers and initializes them. */
  85 bool pkgDepCache::Init(OpProgress *Prog)
  86 {
  87    // Suppress mark updates during this operation (just in case) and
  88    // run a mark operation when Init terminates.
  89    ActionGroup actions(*this);
  90
  91    delete [] PkgState;
  92    delete [] DepState;
  93    PkgState = new StateCache[Head().PackageCount];
  94    DepState = new unsigned char[Head().DependsCount];
  95    memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount);
  96    memset(DepState,0,sizeof(*DepState)*Head().DependsCount);
  97
  98    if (Prog != 0)
  99    {
 100       Prog->OverallProgress(0,2*Head().PackageCount,Head().PackageCount,
 101                             _("Building dependency tree"));
 102       Prog->SubProgress(Head().PackageCount,_("Candidate versions"));
 103    }
 104
 105    /* Set the current state of everything. In this state all of the
 106       packages are kept exactly as is. See AllUpgrade */
 107    int Done = 0;
 108    for (PkgIterator I = PkgBegin(); I.end() != true; I++,Done++)
 109    {
 110       if (Prog != 0)
 111          Prog->Progress(Done);
 112
 113       // Find the proper cache slot
 114       StateCache &State = PkgState[I->ID];
 115       State.iFlags = 0;
 116
 117       // Figure out the install version
 118       State.CandidateVer = GetCandidateVer(I);
 119       State.InstallVer = I.CurrentVer();
 120       State.Mode = ModeKeep;
 121
 122       State.Update(I,*this);
 123    }
 124
 125    if (Prog != 0)
 126    {
 127
 128       Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount,
 129                             Head().PackageCount,
 130                             _("Building dependency tree"));
 131       Prog->SubProgress(Head().PackageCount,_("Dependency generation"));
 132    }
 133
 134    Update(Prog);
 135
 136    if(Prog != 0)
 137       Prog->Done();
 138
 139    return true;
 140 }
 141                                                                         /*}}}*/
 142
 143 bool pkgDepCache::readStateFile(OpProgress *Prog)
 144 {
 145    FileFd state_file;
 146    string state = _config->FindDir("Dir::State") + "extended_states";
 147    if(FileExists(state)) {
 148       state_file.Open(state, FileFd::ReadOnly);
 149       int file_size = state_file.Size();
 150       if(Prog != NULL)
 151          Prog->OverallProgress(0, file_size, 1,
 152                                _("Reading state information"));
 153
 154       pkgTagFile tagfile(&state_file);
 155       pkgTagSection section;
 156       int amt=0;
 157       while(tagfile.Step(section)) {
 158          string pkgname = section.FindS("Package");
 159          pkgCache::PkgIterator pkg=Cache->FindPkg(pkgname);
 160          // Silently ignore unknown packages and packages with no actual
 161          // version.
 162          if(!pkg.end() && !pkg.VersionList().end()) {
 163             short reason = section.FindI("Auto-Installed", 0);
 164             if(reason > 0)
 165                PkgState[pkg->ID].Flags  |= Flag::Auto;
 166             if(_config->FindB("Debug::pkgAutoRemove",false))
 167                std::cout << "Auto-Installed : " << pkgname << std::endl;
 168             amt+=section.size();
 169             if(Prog != NULL)
 170                Prog->OverallProgress(amt, file_size, 1,
 171                                      _("Reading state information"));
 172          }
 173          if(Prog != NULL)
 174             Prog->OverallProgress(file_size, file_size, 1,
 175                                   _("Reading state information"));
 176       }
 177    }
 178
 179    return true;
 180 }
 181
 182 bool pkgDepCache::writeStateFile(OpProgress *prog)
 183 {
 184    if(_config->FindB("Debug::pkgAutoRemove",false))
 185       std::clog << "pkgDepCache::writeStateFile()" << std::endl;
 186
 187    FileFd StateFile;
 188    string state = _config->FindDir("Dir::State") + "extended_states";
 189
 190    // if it does not exist, create a empty one
 191    if(!FileExists(state))
 192    {
 193       StateFile.Open(state, FileFd::WriteEmpty);
 194       StateFile.Close();
 195    }
 196
 197    // open it
 198    if(!StateFile.Open(state, FileFd::ReadOnly))
 199       return _error->Error(_("Failed to open StateFile %s"),
 200                            state.c_str());
 201
 202    FILE *OutFile;
 203    string outfile = state + ".tmp";
 204    if((OutFile = fopen(outfile.c_str(),"w")) == NULL)
 205       return _error->Error(_("Failed to write temporary StateFile %s"),
 206                            outfile.c_str());
 207
 208    // first merge with the existing sections
 209    pkgTagFile tagfile(&StateFile);
 210    pkgTagSection section;
 211    std::set<string> pkgs_seen;
 212    const char *nullreorderlist[] = {0};
 213    while(tagfile.Step(section)) {
 214          string pkgname = section.FindS("Package");
 215          // Silently ignore unknown packages and packages with no actual
 216          // version.
 217          pkgCache::PkgIterator pkg=Cache->FindPkg(pkgname);
 218          if(pkg.end() || pkg.VersionList().end())
 219             continue;
 220          bool oldAuto = section.FindI("Auto-Installed");
 221          bool newAuto = (PkgState[pkg->ID].Flags & Flag::Auto);
 222          if(_config->FindB("Debug::pkgAutoRemove",false))
 223             std::clog << "Update exisiting AutoInstall info: "
 224                       << pkg.Name() << std::endl;
 225          TFRewriteData rewrite[2];
 226          rewrite[0].Tag = "Auto-Installed";
 227          rewrite[0].Rewrite = newAuto ? "1" : "0";
 228          rewrite[0].NewTag = 0;
 229          rewrite[1].Tag = 0;
 230          TFRewrite(OutFile, section, nullreorderlist, rewrite);
 231          fprintf(OutFile,"\n");
 232          pkgs_seen.insert(pkgname);
 233    }
 234
 235    // then write the ones we have not seen yet
 236    std::ostringstream ostr;
 237    for(pkgCache::PkgIterator pkg=Cache->PkgBegin(); !pkg.end(); pkg++) {
 238       if(PkgState[pkg->ID].Flags & Flag::Auto) {
 239          if (pkgs_seen.find(pkg.Name()) != pkgs_seen.end()) {
 240             if(_config->FindB("Debug::pkgAutoRemove",false))
 241                std::clog << "Skipping already written " << pkg.Name() << std::endl;
 242             continue;
 243          }
 244          if(_config->FindB("Debug::pkgAutoRemove",false))
 245             std::clog << "Writing new AutoInstall: "
 246                       << pkg.Name() << std::endl;
 247          ostr.str(string(""));
 248          ostr << "Package: " << pkg.Name()
 249               << "\nAuto-Installed: 1\n\n";
 250          fprintf(OutFile,ostr.str().c_str());
 251          fprintf(OutFile,"\n");
 252       }
 253    }
 254    fclose(OutFile);
 255
 256    // move the outfile over the real file
 257    rename(outfile.c_str(), state.c_str());
 258
 259    return true;
 260 }
 261
 262 // DepCache::CheckDep - Checks a single dependency                      /*{{{*/
 263 // ---------------------------------------------------------------------
 264 /* This first checks the dependency against the main target package and
 265    then walks along the package provides list and checks if each provides
 266    will be installed then checks the provides against the dep. Res will be
 267    set to the package which was used to satisfy the dep. */
 268 bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
 269 {
 270    Res = Dep.TargetPkg();
 271
 272    /* Check simple depends. A depends -should- never self match but
 273       we allow it anyhow because dpkg does. Technically it is a packaging
 274       bug. Conflicts may never self match */
 275    if (Dep.TargetPkg() != Dep.ParentPkg() ||
 276        (Dep->Type != Dep::Conflicts && Dep->Type != Dep::DpkgBreaks && Dep->Type != Dep::Obsoletes))
 277    {
 278       PkgIterator Pkg = Dep.TargetPkg();
 279       // Check the base package
 280       if (Type == NowVersion && Pkg->CurrentVer != 0)
 281          if (VS().CheckDep(Pkg.CurrentVer().VerStr(),Dep->CompareOp,
 282                                  Dep.TargetVer()) == true)
 283             return true;
 284
 285       if (Type == InstallVersion && PkgState[Pkg->ID].InstallVer != 0)
 286          if (VS().CheckDep(PkgState[Pkg->ID].InstVerIter(*this).VerStr(),
 287                                  Dep->CompareOp,Dep.TargetVer()) == true)
 288             return true;
 289
 290       if (Type == CandidateVersion && PkgState[Pkg->ID].CandidateVer != 0)
 291          if (VS().CheckDep(PkgState[Pkg->ID].CandidateVerIter(*this).VerStr(),
 292                                  Dep->CompareOp,Dep.TargetVer()) == true)
 293             return true;
 294    }
 295
 296    if (Dep->Type == Dep::Obsoletes)
 297       return false;
 298
 299    // Check the providing packages
 300    PrvIterator P = Dep.TargetPkg().ProvidesList();
 301    PkgIterator Pkg = Dep.ParentPkg();
 302    for (; P.end() != true; P++)
 303    {
 304       /* Provides may never be applied against the same package if it is
 305          a conflicts. See the comment above. */
 306       if (P.OwnerPkg() == Pkg &&
 307           (Dep->Type == Dep::Conflicts || Dep->Type == Dep::DpkgBreaks))
 308          continue;
 309
 310       // Check if the provides is a hit
 311       if (Type == NowVersion)
 312       {
 313          if (P.OwnerPkg().CurrentVer() != P.OwnerVer())
 314             continue;
 315       }
 316
 317       if (Type == InstallVersion)
 318       {
 319          StateCache &State = PkgState[P.OwnerPkg()->ID];
 320          if (State.InstallVer != (Version *)P.OwnerVer())
 321             continue;
 322       }
 323
 324       if (Type == CandidateVersion)
 325       {
 326          StateCache &State = PkgState[P.OwnerPkg()->ID];
 327          if (State.CandidateVer != (Version *)P.OwnerVer())
 328             continue;
 329       }
 330
 331       // Compare the versions.
 332       if (VS().CheckDep(P.ProvideVersion(),Dep->CompareOp,Dep.TargetVer()) == true)
 333       {
 334          Res = P.OwnerPkg();
 335          return true;
 336       }
 337    }
 338
 339    return false;
 340 }
 341                                                                         /*}}}*/
 342 // DepCache::AddSizes - Add the packages sizes to the counters          /*{{{*/
 343 // ---------------------------------------------------------------------
 344 /* Call with Mult = -1 to preform the inverse opration */
 345 void pkgDepCache::AddSizes(const PkgIterator &Pkg,signed long Mult)
 346 {
 347    StateCache &P = PkgState[Pkg->ID];
 348
 349    if (Pkg->VersionList == 0)
 350       return;
 351
 352    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
 353        P.Keep() == true)
 354       return;
 355
 356    // Compute the size data
 357    if (P.NewInstall() == true)
 358    {
 359       iUsrSize += (signed)(Mult*P.InstVerIter(*this)->InstalledSize);
 360       iDownloadSize += (signed)(Mult*P.InstVerIter(*this)->Size);
 361       return;
 362    }
 363
 364    // Upgrading
 365    if (Pkg->CurrentVer != 0 &&
 366        (P.InstallVer != (Version *)Pkg.CurrentVer() ||
 367         (P.iFlags & ReInstall) == ReInstall) && P.InstallVer != 0)
 368    {
 369       iUsrSize += (signed)(Mult*((signed)P.InstVerIter(*this)->InstalledSize -
 370                         (signed)Pkg.CurrentVer()->InstalledSize));
 371       iDownloadSize += (signed)(Mult*P.InstVerIter(*this)->Size);
 372       return;
 373    }
 374
 375    // Reinstall
 376    if (Pkg.State() == pkgCache::PkgIterator::NeedsUnpack &&
 377        P.Delete() == false)
 378    {
 379       iDownloadSize += (signed)(Mult*P.InstVerIter(*this)->Size);
 380       return;
 381    }
 382
 383    // Removing
 384    if (Pkg->CurrentVer != 0 && P.InstallVer == 0)
 385    {
 386       iUsrSize -= (signed)(Mult*Pkg.CurrentVer()->InstalledSize);
 387       return;
 388    }
 389 }
 390                                                                         /*}}}*/
 391 // DepCache::AddStates - Add the package to the state counter           /*{{{*/
 392 // ---------------------------------------------------------------------
 393 /* This routine is tricky to use, you must make sure that it is never
 394    called twice for the same package. This means the Remove/Add section
 395    should be as short as possible and not encompass any code that will
 396    calld Remove/Add itself. Remember, dependencies can be circular so
 397    while processing a dep for Pkg it is possible that Add/Remove
 398    will be called on Pkg */
 399 void pkgDepCache::AddStates(const PkgIterator &Pkg,int Add)
 400 {
 401    StateCache &State = PkgState[Pkg->ID];
 402
 403    // The Package is broken (either minimal dep or policy dep)
 404    if ((State.DepState & DepInstMin) != DepInstMin)
 405       iBrokenCount += Add;
 406    if ((State.DepState & DepInstPolicy) != DepInstPolicy)
 407       iPolicyBrokenCount += Add;
 408
 409    // Bad state
 410    if (Pkg.State() != PkgIterator::NeedsNothing)
 411       iBadCount += Add;
 412
 413    // Not installed
 414    if (Pkg->CurrentVer == 0)
 415    {
 416       if (State.Mode == ModeDelete &&
 417           (State.iFlags | Purge) == Purge && Pkg.Purge() == false)
 418          iDelCount += Add;
 419
 420       if (State.Mode == ModeInstall)
 421          iInstCount += Add;
 422       return;
 423    }
 424
 425    // Installed, no upgrade
 426    if (State.Status == 0)
 427    {
 428       if (State.Mode == ModeDelete)
 429          iDelCount += Add;
 430       else
 431          if ((State.iFlags & ReInstall) == ReInstall)
 432             iInstCount += Add;
 433
 434       return;
 435    }
 436
 437    // Alll 3 are possible
 438    if (State.Mode == ModeDelete)
 439       iDelCount += Add;
 440    if (State.Mode == ModeKeep)
 441       iKeepCount += Add;
 442    if (State.Mode == ModeInstall)
 443       iInstCount += Add;
 444 }
 445                                                                         /*}}}*/
 446 // DepCache::BuildGroupOrs - Generate the Or group dep data             /*{{{*/
 447 // ---------------------------------------------------------------------
 448 /* The or group results are stored in the last item of the or group. This
 449    allows easy detection of the state of a whole or'd group. */
 450 void pkgDepCache::BuildGroupOrs(VerIterator const &V)
 451 {
 452    unsigned char Group = 0;
 453
 454    for (DepIterator D = V.DependsList(); D.end() != true; D++)
 455    {
 456       // Build the dependency state.
 457       unsigned char &State = DepState[D->ID];
 458
 459       /* Invert for Conflicts. We have to do this twice to get the
 460          right sense for a conflicts group */
 461       if (D->Type == Dep::Conflicts ||
 462           D->Type == Dep::DpkgBreaks ||
 463           D->Type == Dep::Obsoletes)
 464          State = ~State;
 465
 466       // Add to the group if we are within an or..
 467       State &= 0x7;
 468       Group |= State;
 469       State |= Group << 3;
 470       if ((D->CompareOp & Dep::Or) != Dep::Or)
 471          Group = 0;
 472
 473       // Invert for Conflicts
 474       if (D->Type == Dep::Conflicts ||
 475           D->Type == Dep::DpkgBreaks ||
 476           D->Type == Dep::Obsoletes)
 477          State = ~State;
 478    }
 479 }
 480                                                                         /*}}}*/
 481 // DepCache::VersionState - Perform a pass over a dependency list       /*{{{*/
 482 // ---------------------------------------------------------------------
 483 /* This is used to run over a dependency list and determine the dep
 484    state of the list, filtering it through both a Min check and a Policy
 485    check. The return result will have SetMin/SetPolicy low if a check
 486    fails. It uses the DepState cache for it's computations. */
 487 unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
 488                                        unsigned char SetMin,
 489                                        unsigned char SetPolicy)
 490 {
 491    unsigned char Dep = 0xFF;
 492
 493    while (D.end() != true)
 494    {
 495       // Compute a single dependency element (glob or)
 496       DepIterator Start = D;
 497       unsigned char State = 0;
 498       for (bool LastOR = true; D.end() == false && LastOR == true; D++)
 499       {
 500          State |= DepState[D->ID];
 501          LastOR = (D->CompareOp & Dep::Or) == Dep::Or;
 502       }
 503
 504       // Minimum deps that must be satisfied to have a working package
 505       if (Start.IsCritical() == true)
 506          if ((State & Check) != Check)
 507             Dep &= ~SetMin;
 508
 509       // Policy deps that must be satisfied to install the package
 510       if (IsImportantDep(Start) == true &&
 511           (State & Check) != Check)
 512          Dep &= ~SetPolicy;
 513    }
 514
 515    return Dep;
 516 }
 517                                                                         /*}}}*/
 518 // DepCache::DependencyState - Compute the 3 results for a dep          /*{{{*/
 519 // ---------------------------------------------------------------------
 520 /* This is the main dependency computation bit. It computes the 3 main
 521    results for a dependencys, Now, Install and Candidate. Callers must
 522    invert the result if dealing with conflicts. */
 523 unsigned char pkgDepCache::DependencyState(DepIterator &D)
 524 {
 525    unsigned char State = 0;
 526
 527    if (CheckDep(D,NowVersion) == true)
 528       State |= DepNow;
 529    if (CheckDep(D,InstallVersion) == true)
 530       State |= DepInstall;
 531    if (CheckDep(D,CandidateVersion) == true)
 532       State |= DepCVer;
 533
 534    return State;
 535 }
 536                                                                         /*}}}*/
 537 // DepCache::UpdateVerState - Compute the Dep member of the state       /*{{{*/
 538 // ---------------------------------------------------------------------
 539 /* This determines the combined dependency representation of a package
 540    for its two states now and install. This is done by using the pre-generated
 541    dependency information. */
 542 void pkgDepCache::UpdateVerState(PkgIterator Pkg)
 543 {
 544    // Empty deps are always true
 545    StateCache &State = PkgState[Pkg->ID];
 546    State.DepState = 0xFF;
 547
 548    // Check the Current state
 549    if (Pkg->CurrentVer != 0)
 550    {
 551       DepIterator D = Pkg.CurrentVer().DependsList();
 552       State.DepState &= VersionState(D,DepNow,DepNowMin,DepNowPolicy);
 553    }
 554
 555    /* Check the candidate state. We do not compare against the whole as
 556       a candidate state but check the candidate version against the
 557       install states */
 558    if (State.CandidateVer != 0)
 559    {
 560       DepIterator D = State.CandidateVerIter(*this).DependsList();
 561       State.DepState &= VersionState(D,DepInstall,DepCandMin,DepCandPolicy);
 562    }
 563
 564    // Check target state which can only be current or installed
 565    if (State.InstallVer != 0)
 566    {
 567       DepIterator D = State.InstVerIter(*this).DependsList();
 568       State.DepState &= VersionState(D,DepInstall,DepInstMin,DepInstPolicy);
 569    }
 570 }
 571                                                                         /*}}}*/
 572 // DepCache::Update - Figure out all the state information              /*{{{*/
 573 // ---------------------------------------------------------------------
 574 /* This will figure out the state of all the packages and all the
 575    dependencies based on the current policy. */
 576 void pkgDepCache::Update(OpProgress *Prog)
 577 {
 578    iUsrSize = 0;
 579    iDownloadSize = 0;
 580    iDelCount = 0;
 581    iInstCount = 0;
 582    iKeepCount = 0;
 583    iBrokenCount = 0;
 584    iBadCount = 0;
 585
 586    // Perform the depends pass
 587    int Done = 0;
 588    for (PkgIterator I = PkgBegin(); I.end() != true; I++,Done++)
 589    {
 590       if (Prog != 0 && Done%20 == 0)
 591          Prog->Progress(Done);
 592       for (VerIterator V = I.VersionList(); V.end() != true; V++)
 593       {
 594          unsigned char Group = 0;
 595
 596          for (DepIterator D = V.DependsList(); D.end() != true; D++)
 597          {
 598             // Build the dependency state.
 599             unsigned char &State = DepState[D->ID];
 600             State = DependencyState(D);
 601
 602             // Add to the group if we are within an or..
 603             Group |= State;
 604             State |= Group << 3;
 605             if ((D->CompareOp & Dep::Or) != Dep::Or)
 606                Group = 0;
 607
 608             // Invert for Conflicts
 609             if (D->Type == Dep::Conflicts ||
 610                 D->Type == Dep::DpkgBreaks ||
 611                 D->Type == Dep::Obsoletes)
 612                State = ~State;
 613          }
 614       }
 615
 616       // Compute the pacakge dependency state and size additions
 617       AddSizes(I);
 618       UpdateVerState(I);
 619       AddStates(I);
 620    }
 621
 622    if (Prog != 0)
 623       Prog->Progress(Done);
 624
 625    readStateFile(Prog);
 626 }
 627                                                                         /*}}}*/
 628 // DepCache::Update - Update the deps list of a package                 /*{{{*/
 629 // ---------------------------------------------------------------------
 630 /* This is a helper for update that only does the dep portion of the scan.
 631    It is mainly meant to scan reverse dependencies. */
 632 void pkgDepCache::Update(DepIterator D)
 633 {
 634    // Update the reverse deps
 635    for (;D.end() != true; D++)
 636    {
 637       unsigned char &State = DepState[D->ID];
 638       State = DependencyState(D);
 639
 640       // Invert for Conflicts
 641       if (D->Type == Dep::Conflicts ||
 642           D->Type == Dep::DpkgBreaks ||
 643           D->Type == Dep::Obsoletes)
 644          State = ~State;
 645
 646       RemoveStates(D.ParentPkg());
 647       BuildGroupOrs(D.ParentVer());
 648       UpdateVerState(D.ParentPkg());
 649       AddStates(D.ParentPkg());
 650    }
 651 }
 652                                                                         /*}}}*/
 653 // DepCache::Update - Update the related deps of a package              /*{{{*/
 654 // ---------------------------------------------------------------------
 655 /* This is called whenever the state of a package changes. It updates
 656    all cached dependencies related to this package. */
 657 void pkgDepCache::Update(PkgIterator const &Pkg)
 658 {
 659    // Recompute the dep of the package
 660    RemoveStates(Pkg);
 661    UpdateVerState(Pkg);
 662    AddStates(Pkg);
 663
 664    // Update the reverse deps
 665    Update(Pkg.RevDependsList());
 666
 667    // Update the provides map for the current ver
 668    if (Pkg->CurrentVer != 0)
 669       for (PrvIterator P = Pkg.CurrentVer().ProvidesList();
 670            P.end() != true; P++)
 671          Update(P.ParentPkg().RevDependsList());
 672
 673    // Update the provides map for the candidate ver
 674    if (PkgState[Pkg->ID].CandidateVer != 0)
 675       for (PrvIterator P = PkgState[Pkg->ID].CandidateVerIter(*this).ProvidesList();
 676            P.end() != true; P++)
 677          Update(P.ParentPkg().RevDependsList());
 678 }
 679
 680                                                                         /*}}}*/
 681
 682 // DepCache::MarkKeep - Put the package in the keep state               /*{{{*/
 683 // ---------------------------------------------------------------------
 684 /* */
 685 void pkgDepCache::MarkKeep(PkgIterator const &Pkg, bool Soft, bool FromUser)
 686 {
 687    // Simplifies other routines.
 688    if (Pkg.end() == true)
 689       return;
 690
 691    /* Reject an attempt to keep a non-source broken installed package, those
 692       must be upgraded */
 693    if (Pkg.State() == PkgIterator::NeedsUnpack &&
 694        Pkg.CurrentVer().Downloadable() == false)
 695       return;
 696
 697    /** \todo Can this be moved later in the method? */
 698    ActionGroup group(*this);
 699
 700    /* We changed the soft state all the time so the UI is a bit nicer
 701       to use */
 702    StateCache &P = PkgState[Pkg->ID];
 703    if (Soft == true)
 704       P.iFlags |= AutoKept;
 705    else
 706       P.iFlags &= ~AutoKept;
 707
 708    // Check that it is not already kept
 709    if (P.Mode == ModeKeep)
 710       return;
 711
 712    // We dont even try to keep virtual packages..
 713    if (Pkg->VersionList == 0)
 714       return;
 715
 716    if(FromUser && !P.Marked)
 717      P.Flags &= ~Flag::Auto;
 718    RemoveSizes(Pkg);
 719    RemoveStates(Pkg);
 720
 721    P.Mode = ModeKeep;
 722    if (Pkg->CurrentVer == 0)
 723       P.InstallVer = 0;
 724    else
 725       P.InstallVer = Pkg.CurrentVer();
 726
 727    AddStates(Pkg);
 728
 729    Update(Pkg);
 730
 731    AddSizes(Pkg);
 732 }
 733                                                                         /*}}}*/
 734 // DepCache::MarkDelete - Put the package in the delete state           /*{{{*/
 735 // ---------------------------------------------------------------------
 736 /* */
 737 void pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge)
 738 {
 739    // Simplifies other routines.
 740    if (Pkg.end() == true)
 741       return;
 742
 743    ActionGroup group(*this);
 744
 745    // Check that it is not already marked for delete
 746    StateCache &P = PkgState[Pkg->ID];
 747    P.iFlags &= ~(AutoKept | Purge);
 748    if (rPurge == true)
 749       P.iFlags |= Purge;
 750
 751    if ((P.Mode == ModeDelete || P.InstallVer == 0) &&
 752        (Pkg.Purge() == true || rPurge == false))
 753       return;
 754
 755    // We dont even try to delete virtual packages..
 756    if (Pkg->VersionList == 0)
 757       return;
 758
 759    RemoveSizes(Pkg);
 760    RemoveStates(Pkg);
 761
 762    if (Pkg->CurrentVer == 0 && (Pkg.Purge() == true || rPurge == false))
 763       P.Mode = ModeKeep;
 764    else
 765       P.Mode = ModeDelete;
 766    P.InstallVer = 0;
 767
 768    AddStates(Pkg);
 769    Update(Pkg);
 770    AddSizes(Pkg);
 771 }
 772                                                                         /*}}}*/
 773 // DepCache::MarkInstall - Put the package in the install state         /*{{{*/
 774 // ---------------------------------------------------------------------
 775 /* */
 776 void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
 777                               unsigned long Depth, bool FromUser,
 778                               bool ForceImportantDeps)
 779 {
 780    if (Depth > 100)
 781       return;
 782
 783    // Simplifies other routines.
 784    if (Pkg.end() == true)
 785       return;
 786
 787    ActionGroup group(*this);
 788
 789    /* Check that it is not already marked for install and that it can be
 790       installed */
 791    StateCache &P = PkgState[Pkg->ID];
 792    P.iFlags &= ~AutoKept;
 793    if ((P.InstPolicyBroken() == false && P.InstBroken() == false) &&
 794        (P.Mode == ModeInstall ||
 795         P.CandidateVer == (Version *)Pkg.CurrentVer()))
 796    {
 797       if (P.CandidateVer == (Version *)Pkg.CurrentVer() && P.InstallVer == 0)
 798          MarkKeep(Pkg, false, FromUser);
 799       return;
 800    }
 801
 802    // See if there is even any possible instalation candidate
 803    if (P.CandidateVer == 0)
 804       return;
 805    // We dont even try to install virtual packages..
 806    if (Pkg->VersionList == 0)
 807       return;
 808    /* Target the candidate version and remove the autoflag. We reset the
 809       autoflag below if this was called recursively. Otherwise the user
 810       should have the ability to de-auto a package by changing its state */
 811    RemoveSizes(Pkg);
 812    RemoveStates(Pkg);
 813
 814    P.Mode = ModeInstall;
 815    P.InstallVer = P.CandidateVer;
 816
 817    if(FromUser)
 818      {
 819        // Set it to manual if it's a new install or cancelling the
 820        // removal of a garbage package.
 821        if(P.Status == 2 || (!Pkg.CurrentVer().end() && !P.Marked))
 822          P.Flags &= ~Flag::Auto;
 823      }
 824    else
 825      {
 826        // Set it to auto if this is a new install.
 827        if(P.Status == 2)
 828          P.Flags |= Flag::Auto;
 829      }
 830    if (P.CandidateVer == (Version *)Pkg.CurrentVer())
 831       P.Mode = ModeKeep;
 832
 833    AddStates(Pkg);
 834    Update(Pkg);
 835    AddSizes(Pkg);
 836
 837    if (AutoInst == false)
 838       return;
 839
 840    DepIterator Dep = P.InstVerIter(*this).DependsList();
 841    for (; Dep.end() != true;)
 842    {
 843       // Grok or groups
 844       DepIterator Start = Dep;
 845       bool Result = true;
 846       unsigned Ors = 0;
 847       for (bool LastOR = true; Dep.end() == false && LastOR == true; Dep++,Ors++)
 848       {
 849          LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or;
 850
 851          if ((DepState[Dep->ID] & DepInstall) == DepInstall)
 852             Result = false;
 853       }
 854
 855       // Dep is satisfied okay.
 856       if (Result == false)
 857          continue;
 858
 859       /* Check if this dep should be consider for install. If it is a user
 860          defined important dep and we are installed a new package then
 861          it will be installed. Otherwise we only check for important
 862          deps that have changed from the installed version
 863       */
 864       if (IsImportantDep(Start) == false)
 865          continue;
 866
 867       /* check if any ImportantDep() (but not Critial) where added
 868        * since we installed the package
 869        */
 870       bool isNewImportantDep = false;
 871       if(!ForceImportantDeps && !Start.IsCritical())
 872       {
 873          bool found=false;
 874          VerIterator instVer = Pkg.CurrentVer();
 875          if(!instVer.end())
 876             for (DepIterator D = instVer.DependsList(); D.end() != true; D++)
 877             {
 878                //FIXME: deal better with or-groups(?)
 879                DepIterator LocalStart = D;
 880
 881                if(IsImportantDep(D) && Start.TargetPkg() == D.TargetPkg())
 882                   found=true;
 883             }
 884          // this is a new dep if it was not found to be already
 885          // a important dep of the installed pacakge
 886          isNewImportantDep = !found;
 887       }
 888       if(isNewImportantDep)
 889          if(_config->FindB("Debug::pkgDepCache::AutoInstall",false) == true)
 890             std::clog << "new important dependency: "
 891                       << Start.TargetPkg().Name() << std::endl;
 892
 893       // skip important deps if the package is already installed
 894       if (Pkg->CurrentVer != 0 && Start.IsCritical() == false
 895           && !isNewImportantDep && !ForceImportantDeps)
 896          continue;
 897
 898       /* If we are in an or group locate the first or that can
 899          succeed. We have already cached this.. */
 900       for (; Ors > 1 && (DepState[Start->ID] & DepCVer) != DepCVer; Ors--)
 901          Start++;
 902
 903       /* This bit is for processing the possibilty of an install/upgrade
 904          fixing the problem */
 905       SPtrArray<Version *> List = Start.AllTargets();
 906       if (Start->Type != Dep::DpkgBreaks &&
 907           (DepState[Start->ID] & DepCVer) == DepCVer)
 908       {
 909          // Right, find the best version to install..
 910          Version **Cur = List;
 911          PkgIterator P = Start.TargetPkg();
 912          PkgIterator InstPkg(*Cache,0);
 913
 914          // See if there are direct matches (at the start of the list)
 915          for (; *Cur != 0 && (*Cur)->ParentPkg == P.Index(); Cur++)
 916          {
 917             PkgIterator Pkg(*Cache,Cache->PkgP + (*Cur)->ParentPkg);
 918             if (PkgState[Pkg->ID].CandidateVer != *Cur)
 919                continue;
 920             InstPkg = Pkg;
 921             break;
 922          }
 923
 924          // Select the highest priority providing package
 925          if (InstPkg.end() == true)
 926          {
 927             pkgPrioSortList(*Cache,Cur);
 928             for (; *Cur != 0; Cur++)
 929             {
 930                PkgIterator Pkg(*Cache,Cache->PkgP + (*Cur)->ParentPkg);
 931                if (PkgState[Pkg->ID].CandidateVer != *Cur)
 932                   continue;
 933                InstPkg = Pkg;
 934                break;
 935             }
 936          }
 937
 938          if (InstPkg.end() == false)
 939          {
 940             if(_config->FindB("Debug::pkgDepCache::AutoInstall",false) == true)
 941                std::clog << "Installing " << InstPkg.Name()
 942                          << " as dep of " << Pkg.Name()
 943                          << std::endl;
 944             MarkInstall(InstPkg,true,Depth + 1, false, ForceImportantDeps);
 945
 946             // Set the autoflag, after MarkInstall because MarkInstall unsets it
 947             if (P->CurrentVer == 0)
 948                PkgState[InstPkg->ID].Flags |= Flag::Auto;
 949          }
 950          continue;
 951       }
 952
 953       /* For conflicts we just de-install the package and mark as auto,
 954          Conflicts may not have or groups.  For dpkg's Breaks we try to
 955          upgrade the package. */
 956       if (Start->Type == Dep::Conflicts || Start->Type == Dep::Obsoletes ||
 957           Start->Type == Dep::DpkgBreaks)
 958       {
 959          for (Version **I = List; *I != 0; I++)
 960          {
 961             VerIterator Ver(*this,*I);
 962             PkgIterator Pkg = Ver.ParentPkg();
 963
 964             if (Start->Type != Dep::DpkgBreaks)
 965                MarkDelete(Pkg);
 966             else
 967                if (PkgState[Pkg->ID].CandidateVer != *I)
 968                   MarkInstall(Pkg,true,Depth + 1, false, ForceImportantDeps);
 969          }
 970          continue;
 971       }
 972    }
 973 }
 974                                                                         /*}}}*/
 975 // DepCache::SetReInstall - Set the reinstallation flag                 /*{{{*/
 976 // ---------------------------------------------------------------------
 977 /* */
 978 void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
 979 {
 980    ActionGroup group(*this);
 981
 982    RemoveSizes(Pkg);
 983    RemoveStates(Pkg);
 984
 985    StateCache &P = PkgState[Pkg->ID];
 986    if (To == true)
 987       P.iFlags |= ReInstall;
 988    else
 989       P.iFlags &= ~ReInstall;
 990
 991    AddStates(Pkg);
 992    AddSizes(Pkg);
 993 }
 994                                                                         /*}}}*/
 995 // DepCache::SetCandidateVersion - Change the candidate version         /*{{{*/
 996 // ---------------------------------------------------------------------
 997 /* */
 998 void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)
 999 {
1000    ActionGroup group(*this);
1001
1002    pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
1003    StateCache &P = PkgState[Pkg->ID];
1004
1005    RemoveSizes(Pkg);
1006    RemoveStates(Pkg);
1007
1008    if (P.CandidateVer == P.InstallVer)
1009       P.InstallVer = (Version *)TargetVer;
1010    P.CandidateVer = (Version *)TargetVer;
1011    P.Update(Pkg,*this);
1012
1013    AddStates(Pkg);
1014    Update(Pkg);
1015    AddSizes(Pkg);
1016 }
1017
1018 void pkgDepCache::MarkAuto(const PkgIterator &Pkg, bool Auto)
1019 {
1020   StateCache &state = PkgState[Pkg->ID];
1021
1022   ActionGroup group(*this);
1023
1024   if(Auto)
1025     state.Flags |= Flag::Auto;
1026   else
1027     state.Flags &= ~Flag::Auto;
1028 }
1029                                                                         /*}}}*/
1030 // StateCache::Update - Compute the various static display things       /*{{{*/
1031 // ---------------------------------------------------------------------
1032 /* This is called whenever the Candidate version changes. */
1033 void pkgDepCache::StateCache::Update(PkgIterator Pkg,pkgCache &Cache)
1034 {
1035    // Some info
1036    VerIterator Ver = CandidateVerIter(Cache);
1037
1038    // Use a null string or the version string
1039    if (Ver.end() == true)
1040       CandVersion = "";
1041    else
1042       CandVersion = Ver.VerStr();
1043
1044    // Find the current version
1045    CurVersion = "";
1046    if (Pkg->CurrentVer != 0)
1047       CurVersion = Pkg.CurrentVer().VerStr();
1048
1049    // Strip off the epochs for display
1050    CurVersion = StripEpoch(CurVersion);
1051    CandVersion = StripEpoch(CandVersion);
1052
1053    // Figure out if its up or down or equal
1054    Status = Ver.CompareVer(Pkg.CurrentVer());
1055    if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)
1056      Status = 2;
1057 }
1058                                                                         /*}}}*/
1059 // StateCache::StripEpoch - Remove the epoch specifier from the version /*{{{*/
1060 // ---------------------------------------------------------------------
1061 /* */
1062 const char *pkgDepCache::StateCache::StripEpoch(const char *Ver)
1063 {
1064    if (Ver == 0)
1065       return 0;
1066
1067    // Strip any epoch
1068    for (const char *I = Ver; *I != 0; I++)
1069       if (*I == ':')
1070          return I + 1;
1071    return Ver;
1072 }
1073                                                                         /*}}}*/
1074
1075 // Policy::GetCandidateVer - Returns the Candidate install version      /*{{{*/
1076 // ---------------------------------------------------------------------
1077 /* The default just returns the highest available version that is not
1078    a source and automatic. */
1079 pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator Pkg)
1080 {
1081    /* Not source/not automatic versions cannot be a candidate version
1082       unless they are already installed */
1083    VerIterator Last(*(pkgCache *)this,0);
1084
1085    for (VerIterator I = Pkg.VersionList(); I.end() == false; I++)
1086    {
1087       if (Pkg.CurrentVer() == I)
1088          return I;
1089
1090       for (VerFileIterator J = I.FileList(); J.end() == false; J++)
1091       {
1092          if ((J.File()->Flags & Flag::NotSource) != 0)
1093             continue;
1094
1095          /* Stash the highest version of a not-automatic source, we use it
1096             if there is nothing better */
1097          if ((J.File()->Flags & Flag::NotAutomatic) != 0)
1098          {
1099             if (Last.end() == true)
1100                Last = I;
1101             continue;
1102          }
1103
1104          return I;
1105       }
1106    }
1107
1108    return Last;
1109 }
1110                                                                         /*}}}*/
1111                                                                         /*}}}*/
1112
1113 pkgDepCache::DefaultRootSetFunc::DefaultRootSetFunc()
1114   : constructedSuccessfully(false)
1115 {
1116   Configuration::Item const *Opts;
1117   Opts = _config->Tree("APT::NeverAutoRemove");
1118   if (Opts != 0 && Opts->Child != 0)
1119     {
1120       Opts = Opts->Child;
1121       for (; Opts != 0; Opts = Opts->Next)
1122         {
1123           if (Opts->Value.empty() == true)
1124             continue;
1125
1126           regex_t *p = new regex_t;
1127           if(regcomp(p,Opts->Value.c_str(),
1128                      REG_EXTENDED | REG_ICASE | REG_NOSUB) != 0)
1129             {
1130               regfree(p);
1131               delete p;
1132               _error->Error("Regex compilation error for APT::NeverAutoRemove");
1133               return;
1134             }
1135
1136           rootSetRegexp.push_back(p);
1137         }
1138     }
1139
1140   constructedSuccessfully = true;
1141 }
1142
1143 pkgDepCache::DefaultRootSetFunc::~DefaultRootSetFunc()
1144 {
1145   for(unsigned int i = 0; i < rootSetRegexp.size(); i++)
1146     {
1147       regfree(rootSetRegexp[i]);
1148       delete rootSetRegexp[i];
1149     }
1150 }
1151
1152
1153 bool pkgDepCache::DefaultRootSetFunc::InRootSet(const pkgCache::PkgIterator &pkg)
1154 {
1155    for(unsigned int i = 0; i < rootSetRegexp.size(); i++)
1156       if (regexec(rootSetRegexp[i], pkg.Name(), 0, 0, 0) == 0)
1157          return true;
1158
1159    return false;
1160 }
1161
1162 pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc()
1163 {
1164   DefaultRootSetFunc *f = new DefaultRootSetFunc;
1165   if(f->wasConstructedSuccessfully())
1166     return f;
1167   else
1168     {
1169       delete f;
1170       return NULL;
1171     }
1172 }
1173
1174 bool pkgDepCache::MarkFollowsRecommends()
1175 {
1176   return _config->FindB("APT::AutoRemove::RecommendsImportant", true);
1177 }
1178
1179 bool pkgDepCache::MarkFollowsSuggests()
1180 {
1181   return _config->FindB("APT::AutoRemove::SuggestsImportant", false);
1182 }
1183
1184 // the main mark algorithm
1185 bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
1186 {
1187    bool follow_recommends;
1188    bool follow_suggests;
1189
1190    // init the states
1191    for(PkgIterator p = PkgBegin(); !p.end(); ++p)
1192    {
1193       PkgState[p->ID].Marked  = false;
1194       PkgState[p->ID].Garbage = false;
1195
1196       // debug output
1197       if(_config->FindB("Debug::pkgAutoRemove",false)
1198          && PkgState[p->ID].Flags & Flag::Auto)
1199          std::clog << "AutoDep: " << p.Name() << std::endl;
1200    }
1201
1202    // init vars
1203    follow_recommends = MarkFollowsRecommends();
1204    follow_suggests   = MarkFollowsSuggests();
1205
1206
1207
1208    // do the mark part, this is the core bit of the algorithm
1209    for(PkgIterator p = PkgBegin(); !p.end(); ++p)
1210    {
1211       if(!(PkgState[p->ID].Flags & Flag::Auto) ||
1212           (p->Flags & Flag::Essential) ||
1213           userFunc.InRootSet(p))
1214
1215       {
1216          // the package is installed (and set to keep)
1217          if(PkgState[p->ID].Keep() && !p.CurrentVer().end())
1218             MarkPackage(p, p.CurrentVer(),
1219                         follow_recommends, follow_suggests);
1220          // the package is to be installed
1221          else if(PkgState[p->ID].Install())
1222             MarkPackage(p, PkgState[p->ID].InstVerIter(*this),
1223                         follow_recommends, follow_suggests);
1224       }
1225    }
1226
1227    return true;
1228 }
1229
1230 // mark a single package in Mark-and-Sweep
1231 void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
1232                               const pkgCache::VerIterator &ver,
1233                               bool follow_recommends,
1234                               bool follow_suggests)
1235 {
1236    pkgDepCache::StateCache &state = PkgState[pkg->ID];
1237    VerIterator candver            = state.CandidateVerIter(*this);
1238    VerIterator instver            = state.InstVerIter(*this);
1239
1240 #if 0
1241    // If a package was garbage-collected but is now being marked, we
1242    // should re-select it
1243    // For cases when a pkg is set to upgrade and this trigger the
1244    // removal of a no-longer used dependency.  if the pkg is set to
1245    // keep again later it will result in broken deps
1246    if(state.Delete() && state.RemoveReason = Unused)
1247    {
1248       if(ver==candver)
1249          mark_install(pkg, false, false, NULL);
1250       else if(ver==pkg.CurrentVer())
1251          MarkKeep(pkg, false, false);
1252
1253       instver=state.InstVerIter(*this);
1254    }
1255 #endif
1256
1257    // Ignore versions other than the InstVer, and ignore packages
1258    // that are already going to be removed or just left uninstalled.
1259    if(!(ver == instver && !instver.end()))
1260       return;
1261
1262    // if we are marked already we are done
1263    if(state.Marked)
1264       return;
1265
1266    //std::cout << "Setting Marked for: " << pkg.Name() << std::endl;
1267    state.Marked=true;
1268
1269    if(!ver.end())
1270    {
1271      for(DepIterator d = ver.DependsList(); !d.end(); ++d)
1272      {
1273         if(d->Type == Dep::Depends ||
1274            d->Type == Dep::PreDepends ||
1275            (follow_recommends &&
1276             d->Type == Dep::Recommends) ||
1277            (follow_suggests &&
1278             d->Type == Dep::Suggests))
1279         {
1280            // Try all versions of this package.
1281            for(VerIterator V = d.TargetPkg().VersionList();
1282                !V.end(); ++V)
1283            {
1284               if(_system->VS->CheckDep(V.VerStr(), d->CompareOp, d.TargetVer()))
1285               {
1286                  MarkPackage(V.ParentPkg(), V,
1287                              follow_recommends, follow_suggests);
1288               }
1289            }
1290            // Now try virtual packages
1291            for(PrvIterator prv=d.TargetPkg().ProvidesList();
1292                !prv.end(); ++prv)
1293            {
1294               if(_system->VS->CheckDep(prv.ProvideVersion(), d->CompareOp,
1295                                        d.TargetVer()))
1296               {
1297                  MarkPackage(prv.OwnerPkg(), prv.OwnerVer(),
1298                              follow_recommends, follow_suggests);
1299               }
1300            }
1301         }
1302      }
1303    }
1304 }
1305
1306 bool pkgDepCache::Sweep()
1307 {
1308    // do the sweep
1309    for(PkgIterator p=PkgBegin(); !p.end(); ++p)
1310   {
1311      StateCache &state=PkgState[p->ID];
1312
1313      // if it is not marked and it is installed, it's garbage
1314      if(!state.Marked && (!p.CurrentVer().end() || state.Install()) &&
1315         !state.Delete())
1316      {
1317         state.Garbage=true;
1318         if(_config->FindB("Debug::pkgAutoRemove",false))
1319            std::cout << "Garbage: " << p.Name() << std::endl;
1320      }
1321   }
1322
1323    return true;
1324 }
1325
1326 // Policy::IsImportantDep - True if the dependency is important         /*{{{*/
1327 // ---------------------------------------------------------------------
1328 /* */
1329 bool pkgDepCache::Policy::IsImportantDep(DepIterator Dep)
1330 {
1331    if(Dep.IsCritical())
1332       return true;
1333    else if(Dep->Type == pkgCache::Dep::Recommends)
1334       return  _config->FindB("APT::Install-Recommends", false);
1335    else if(Dep->Type == pkgCache::Dep::Suggests)
1336      return _config->FindB("APT::Install-Suggests", false);
1337
1338    return false;
1339 }
1340                                                                         /*}}}*/