// -*- mode: cpp; mode: fold -*- // Description /*{{{*/ // $Id: policy.cc,v 1.10 2003/08/12 00:17:37 mdz Exp $ /* ###################################################################### Package Version Policy implementation This is just a really simple wrapper around pkgVersionMatch with some added goodies to manage the list of things.. Priority Table: 1000 -> inf = Downgradeable priorities 1000 = The 'no downgrade' pseduo-status file 100 -> 1000 = Standard priorities 990 = Config file override package files 989 = Start for preference auto-priorities 500 = Default package files 100 = The status file 0 -> 100 = NotAutomatic sources like experimental -inf -> 0 = Never selected ##################################################################### */ /*}}}*/ // Include Files /*{{{*/ #include <apt-pkg/policy.h> #include <apt-pkg/configuration.h> #include <apt-pkg/tagfile.h> #include <apt-pkg/strutl.h> #include <apt-pkg/fileutl.h> #include <apt-pkg/error.h> #include <apt-pkg/sptr.h> #include <apti18n.h> #include <iostream> #include <sstream> /*}}}*/ using namespace std; // Policy::Init - Startup and bind to a cache /*{{{*/ // --------------------------------------------------------------------- /* Set the defaults for operation. The default mode with no loaded policy file matches the V0 policy engine. */ pkgPolicy::pkgPolicy(pkgCache *Owner) : Pins(0), PFPriority(0), Cache(Owner) { PFPriority = new signed short[Owner->Head().PackageFileCount]; Pins = new Pin[Owner->Head().PackageCount]; for (unsigned long I = 0; I != Owner->Head().PackageCount; I++) Pins[I].Type = pkgVersionMatch::None; // The config file has a master override. string DefRel = _config->Find("APT::Default-Release"); if (DefRel.empty() == false) CreatePin(pkgVersionMatch::Release,"",DefRel,990); InitDefaults(); } /*}}}*/ // Policy::InitDefaults - Compute the default selections /*{{{*/ // --------------------------------------------------------------------- /* */ bool pkgPolicy::InitDefaults() { // Initialize the priorities based on the status of the package file for (pkgCache::PkgFileIterator I = Cache->FileBegin(); I != Cache->FileEnd(); I++) { PFPriority[I->ID] = 500; if ((I->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource) PFPriority[I->ID] = 100; else if ((I->Flags & pkgCache::Flag::NotAutomatic) == pkgCache::Flag::NotAutomatic) PFPriority[I->ID] = 1; } // Apply the defaults.. SPtrArray<bool> Fixed = new bool[Cache->HeaderP->PackageFileCount]; memset(Fixed,0,sizeof(*Fixed)*Cache->HeaderP->PackageFileCount); signed Cur = 989; StatusOverride = false; for (vector<Pin>::const_iterator I = Defaults.begin(); I != Defaults.end(); I++, Cur--) { pkgVersionMatch Match(I->Data,I->Type); for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F != Cache->FileEnd(); F++) { if (Match.FileMatch(F) == true && Fixed[F->ID] == false) { if (I->Priority != 0 && I->Priority > 0) Cur = I->Priority; if (I->Priority < 0) PFPriority[F->ID] = I->Priority; else PFPriority[F->ID] = Cur; if (PFPriority[F->ID] > 1000) StatusOverride = true; Fixed[F->ID] = true; } } } if (_config->FindB("Debug::pkgPolicy",false) == true) for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F != Cache->FileEnd(); F++) std::clog << "Prio of " << F.FileName() << ' ' << PFPriority[F->ID] << std::endl; return true; } /*}}}*/ // Policy::GetCandidateVer - Get the candidate install version /*{{{*/ // --------------------------------------------------------------------- /* Evaluate the package pins and the default list to deteremine what the best package is. */ pkgCache::VerIterator pkgPolicy::GetCandidateVer(pkgCache::PkgIterator const &Pkg) { // Look for a package pin and evaluate it. signed Max = GetPriority(Pkg); pkgCache::VerIterator Pref = GetMatch(Pkg); // Alternatives in case we can not find our package pin (Bug#512318). signed MaxAlt = 0; pkgCache::VerIterator PrefAlt; // no package = no candidate version if (Pkg.end() == true) return Pref; // packages with a pin lower than 0 have no newer candidate than the current version if (Max < 0) return Pkg.CurrentVer(); /* Falling through to the default version.. Setting Max to zero effectively excludes everything <= 0 which are the non-automatic priorities.. The status file is given a prio of 100 which will exclude not-automatic sources, except in a single shot not-installed mode. The second pseduo-status file is at prio 1000, above which will permit the user to force-downgrade things. The user pin is subject to the same priority rules as default selections. Thus there are two ways to create a pin - a pin that tracks the default when the default is taken away, and a permanent pin that stays at that setting. */ for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; Ver++) { /* Lets see if this version is the installed version */ bool instVer = (Pkg.CurrentVer() == Ver); if (Ver.Pseudo() == true && instVer == false) { pkgCache::PkgIterator const allPkg = Ver.ParentPkg().Group().FindPkg("all"); if (allPkg->CurrentVer != 0 && allPkg.CurrentVer()->Hash == Ver->Hash && strcmp(allPkg.CurVersion(), Ver.VerStr()) == 0) instVer = true; } for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false; VF++) { /* If this is the status file, and the current version is not the version in the status file (ie it is not installed, or somesuch) then it is not a candidate for installation, ever. This weeds out bogus entries that may be due to config-file states, or other. */ if ((VF.File()->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource && instVer == false) continue; signed Prio = PFPriority[VF.File()->ID]; if (Prio > Max) { Pref = Ver; Max = Prio; } if (Prio > MaxAlt) { PrefAlt = Ver; MaxAlt = Prio; } } if (instVer == true && Max < 1000) { /* Elevate our current selection (or the status file itself) to the Pseudo-status priority. */ if (Pref.end() == true) Pref = Ver; Max = 1000; // Fast path optimize. if (StatusOverride == false) break; } } // If we do not find our candidate, use the one with the highest pin. // This means that if there is a version available with pin > 0; there // will always be a candidate (Closes: #512318) if (!Pref.IsGood() && MaxAlt > 0) Pref = PrefAlt; return Pref; } /*}}}*/ // Policy::CreatePin - Create an entry in the pin table.. /*{{{*/ // --------------------------------------------------------------------- /* For performance we have 3 tables, the default table, the main cache table (hashed to the cache). A blank package name indicates the pin belongs to the default table. Order of insertion matters here, the earlier defaults override later ones. */ void pkgPolicy::CreatePin(pkgVersionMatch::MatchType Type,string Name, string Data,signed short Priority) { if (Name.empty() == true) { Pin *P = &*Defaults.insert(Defaults.end(),PkgPin()); P->Type = Type; P->Priority = Priority; P->Data = Data; return; } // Get a spot to put the pin pkgCache::GrpIterator Grp = Cache->FindGrp(Name); for (pkgCache::PkgIterator Pkg = Grp.FindPkg("any"); Pkg.end() != true; Pkg = Grp.NextPkg(Pkg)) { Pin *P = 0; if (Pkg.end() == false) P = Pins + Pkg->ID; else { // Check the unmatched table for (vector<PkgPin>::iterator I = Unmatched.begin(); I != Unmatched.end() && P == 0; I++) if (I->Pkg == Name) P = &*I; if (P == 0) P = &*Unmatched.insert(Unmatched.end(),PkgPin()); } P->Type = Type; P->Priority = Priority; P->Data = Data; } } /*}}}*/ // Policy::GetMatch - Get the matching version for a package pin /*{{{*/ // --------------------------------------------------------------------- /* */ pkgCache::VerIterator pkgPolicy::GetMatch(pkgCache::PkgIterator const &Pkg) { const Pin &PPkg = Pins[Pkg->ID]; if (PPkg.Type == pkgVersionMatch::None) return pkgCache::VerIterator(*Pkg.Cache()); pkgVersionMatch Match(PPkg.Data,PPkg.Type); return Match.Find(Pkg); } /*}}}*/ // Policy::GetPriority - Get the priority of the package pin /*{{{*/ // --------------------------------------------------------------------- /* */ signed short pkgPolicy::GetPriority(pkgCache::PkgIterator const &Pkg) { if (Pins[Pkg->ID].Type != pkgVersionMatch::None) { // In this case 0 means default priority if (Pins[Pkg->ID].Priority == 0) return 989; return Pins[Pkg->ID].Priority; } return 0; } /*}}}*/ // PreferenceSection class - Overriding the default TrimRecord method /*{{{*/ // --------------------------------------------------------------------- /* The preference file is a user generated file so the parser should therefore be a bit more friendly by allowing comments and new lines all over the place rather than forcing a special format */ class PreferenceSection : public pkgTagSection { void TrimRecord(bool BeforeRecord, const char* &End) { for (; Stop < End && (Stop[0] == '\n' || Stop[0] == '\r' || Stop[0] == '#'); Stop++) if (Stop[0] == '#') Stop = (const char*) memchr(Stop,'\n',End-Stop); } }; /*}}}*/ // ReadPinDir - Load the pin files from this dir into a Policy /*{{{*/ // --------------------------------------------------------------------- /* This will load each pin file in the given dir into a Policy. If the given dir is empty the dir set in Dir::Etc::PreferencesParts is used. Note also that this method will issue a warning if the dir does not exists but it will return true in this case! */ bool ReadPinDir(pkgPolicy &Plcy,string Dir) { if (Dir.empty() == true) Dir = _config->FindDir("Dir::Etc::PreferencesParts"); if (DirectoryExists(Dir) == false) { _error->WarningE("DirectoryExists",_("Unable to read %s"),Dir.c_str()); return true; } vector<string> const List = GetListOfFilesInDir(Dir, "pref", true, true); // Read the files for (vector<string>::const_iterator I = List.begin(); I != List.end(); I++) if (ReadPinFile(Plcy, *I) == false) return false; return true; } /*}}}*/ // ReadPinFile - Load the pin file into a Policy /*{{{*/ // --------------------------------------------------------------------- /* I'd like to see the preferences file store more than just pin information but right now that is the only stuff I have to store. Later there will have to be some kind of combined super parser to get the data into all the right classes.. */ bool ReadPinFile(pkgPolicy &Plcy,string File) { if (File.empty() == true) File = _config->FindFile("Dir::Etc::Preferences"); if (FileExists(File) == false) return true; FileFd Fd(File,FileFd::ReadOnly); pkgTagFile TF(&Fd); if (_error->PendingError() == true) return false; PreferenceSection Tags; while (TF.Step(Tags) == true) { string Name = Tags.FindS("Package"); if (Name.empty() == true) return _error->Error(_("Invalid record in the preferences file %s, no Package header"), File.c_str()); if (Name == "*") Name = string(); const char *Start; const char *End; if (Tags.Find("Pin",Start,End) == false) continue; const char *Word = Start; for (; Word != End && isspace(*Word) == 0; Word++); // Parse the type.. pkgVersionMatch::MatchType Type; if (stringcasecmp(Start,Word,"version") == 0 && Name.empty() == false) Type = pkgVersionMatch::Version; else if (stringcasecmp(Start,Word,"release") == 0) Type = pkgVersionMatch::Release; else if (stringcasecmp(Start,Word,"origin") == 0) Type = pkgVersionMatch::Origin; else { _error->Warning(_("Did not understand pin type %s"),string(Start,Word).c_str()); continue; } for (; Word != End && isspace(*Word) != 0; Word++); short int priority = Tags.FindI("Pin-Priority", 0); if (priority == 0) { _error->Warning(_("No priority (or zero) specified for pin")); continue; } istringstream s(Name); string pkg; while(!s.eof()) { s >> pkg; Plcy.CreatePin(Type, pkg, string(Word,End),priority); }; } Plcy.InitDefaults(); return true; } /*}}}*/