diff options
Diffstat (limited to 'apt-pkg/packagemanager.cc')
| -rw-r--r-- | apt-pkg/packagemanager.cc | 548 |
1 files changed, 548 insertions, 0 deletions
diff --git a/apt-pkg/packagemanager.cc b/apt-pkg/packagemanager.cc new file mode 100644 index 000000000..ebf67b5ee --- /dev/null +++ b/apt-pkg/packagemanager.cc @@ -0,0 +1,548 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +// $Id: packagemanager.cc,v 1.1 1998/07/07 04:17:01 jgg Exp $ +/* ###################################################################### + + Package Manager - Abstacts the package manager + + More work is needed in the area of transitioning provides, ie exim + replacing smail. This can cause interesing side effects. + + Other cases involving conflicts+replaces should be tested. + + ##################################################################### */ + /*}}}*/ +// Include Files /*{{{*/ +#ifdef __GNUG__ +#pragma implementation "pkglib/packagemanager.h" +#endif +#include <pkglib/packagemanager.h> +#include <pkglib/orderlist.h> +#include <pkglib/depcache.h> +#include <pkglib/sourcelist.h> +#include <pkglib/aquire.h> +#include <pkglib/controlcache.h> +#include <pkglib/error.h> +#include <options.h> + /*}}}*/ + +// PM::PackageManager - Constructor /*{{{*/ +// --------------------------------------------------------------------- +/* */ +pkgPackageManager::pkgPackageManager(pkgDepCache &Cache) : Cache(Cache) +{ + FileNames = new string[Cache.Head().PackageCount]; + List = 0; +} + /*}}}*/ +// PM::PackageManager - Destructor /*{{{*/ +// --------------------------------------------------------------------- +/* */ +pkgPackageManager::~pkgPackageManager() +{ + delete List; + delete [] FileNames; +} + /*}}}*/ +// PM::GetArchives - Puts the install archives in the aquire list /*{{{*/ +// --------------------------------------------------------------------- +/* The Source list is used to convert the packages to install into + URNs which are then passed to Aquire to convert to FileNames. */ +bool pkgPackageManager::GetArchives(pkgSourceList &List,pkgAquire &Engine) +{ + pkgControlCache CCache(Cache); + if (_error->PendingError() == true) + return false; + + Engine.OutputDir(PKG_DEB_CA_ARCHIVES); + pkgCache::PkgIterator I = Cache.PkgBegin(); + for (;I.end() != true; I++) + { + // Not interesting + if ((Cache[I].InstallVer == (pkgCache::Version *)I.CurrentVer() && + I.State() != pkgCache::PkgIterator::NeedsUnpack) || + Cache[I].Delete() == true) + continue; + + // Cross match with the source list. + pkgSourceList::const_iterator Dist = List.MatchPkgFile(Cache[I].InstVerIter(Cache)); + if (Dist == List.end()) + { + _error->Warning("Couldn't locate an archive source for package %s",I.Name()); + continue; + } + + // Read in the info record + pkgSPkgCtrlInfo Inf = CCache[Cache[I].InstVerIter(Cache)]; + if (Inf.isNull() == true) + { + _error->Warning("Couldn't locate info for package %s",I.Name()); + continue; + } + + // Isolate the filename + string File = Inf->Find("Filename")->Value(); + if (File.empty() == true) + { + _error->Warning("Couldn't locate an archive for package %s",I.Name()); + continue; + } + + // Generate the get request. + string URI = Dist->ArchiveURI(File); + + // Output file + unsigned int Pos = File.rfind('/'); + if (Pos == File.length()) + return _error->Error("Malformed file line in package %s",I.Name()); + + // Null pos isnt used in present package files + if (Pos == string::npos) + Pos = 0; + else + Pos++; + + if (Engine.Get(URI,string(File,Pos), + Dist->ArchiveInfo(Cache[I].InstVerIter(Cache)), + Cache[I].InstVerIter(Cache)->Size, + Inf->Find("MD5sum")->Value(), + &FileNames[I->ID]) == false) + return false; + } + + return true; +} + /*}}}*/ +// PM::FixMissing - Keep all missing packages /*{{{*/ +// --------------------------------------------------------------------- +/* This is called to correct the installation when packages could not + be downloaded. */ +bool pkgPackageManager::FixMissing() +{ + unsigned char *Touch = new unsigned char[Cache.Head().PackageCount]; + for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++) + { + // Create the status list that ResolveConflicts needs + if ((Cache[I].DepState & pkgDepCache::DepNowMin) == pkgDepCache::DepNowMin) + Touch[I->ID] = (1 << 0) | (1 << 1); + else + Touch[I->ID] = 1 << 1; + + if (Cache[I].Keep() == true) + continue; + if (FileNames[I->ID].empty() == false || Cache[I].Delete() == true) + continue; + Cache.MarkKeep(I); + } + + // Now downgrade everything that is broken + Cache.ResolveConflicts(Touch); + delete [] Touch; + + return Cache.BrokenCount() == 0; +} + /*}}}*/ + +// PM::DepAlwaysTrue - Returns true if this dep is irrelevent /*{{{*/ +// --------------------------------------------------------------------- +/* The restriction on provides is to eliminate the case when provides + are transitioning between valid states [ie exim to smail] */ +bool pkgPackageManager::DepAlwaysTrue(DepIterator D) +{ + if (D.TargetPkg()->ProvidesList != 0) + return false; + + if ((Cache[D] & pkgDepCache::DepInstall) != 0 && + (Cache[D] & pkgDepCache::DepNow) != 0) + return true; + return false; +} + /*}}}*/ +// PM::CheckRConflicts - Look for reverse conflicts /*{{{*/ +// --------------------------------------------------------------------- +/* This looks over the reverses for a conflicts line that needs early + removal. */ +bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D, + const char *Ver) +{ + for (;D.end() == false; D++) + { + if (D->Type != pkgDEP_Conflicts) + continue; + + if (D.ParentPkg() == Pkg) + continue; + + if (pkgCheckDep(D.TargetVer(),Ver,D->CompareOp) == false) + continue; + + if (List->IsNow(Pkg) == false) + continue; + + if (EarlyRemove(D.ParentPkg()) == false) + return false; + } + return true; +} + /*}}}*/ +// PM::ConfigureAll - Run the all out configuration /*{{{*/ +// --------------------------------------------------------------------- +/* This configures every package. It is assumed they are all unpacked and + that the final configuration is valid. */ +bool pkgPackageManager::ConfigureAll() +{ + pkgOrderList OList(Cache); + + // Populate the order list + for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++) + if (List->IsFlag(pkgCache::PkgIterator(Cache,*I), + pkgOrderList::UnPacked) == true) + OList.push_back(*I); + + if (OList.OrderConfigure() == false) + return false; + + // Perform the configuring + for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++) + { + PkgIterator Pkg(Cache,*I); + + if (Configure(Pkg) == false) + return false; + + List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); + } + + return true; +} + /*}}}*/ +// PM::SmartConfigure - Perform immediate configuration of the pkg /*{{{*/ +// --------------------------------------------------------------------- +/* This routine scheduals the configuration of the given package and all + of it's dependents. */ +bool pkgPackageManager::SmartConfigure(PkgIterator Pkg) +{ + pkgOrderList OList(Cache); + + if (DepAdd(OList,Pkg) == false) + return false; + + if (OList.OrderConfigure() == false) + return false; + + // Perform the configuring + for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++) + { + PkgIterator Pkg(Cache,*I); + + if (Configure(Pkg) == false) + return false; + + List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); + } + + // Sanity Check + if (List->IsFlag(Pkg,pkgOrderList::Configured) == false) + return _error->Error("Internal error, could not immediate configure %s",Pkg.Name()); + + return true; +} + /*}}}*/ +// PM::DepAdd - Add all dependents to the oder list /*{{{*/ +// --------------------------------------------------------------------- +/* This recursively adds all dependents to the order list */ +bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth) +{ + if (OList.IsFlag(Pkg,pkgOrderList::Added) == true) + return true; + if (List->IsFlag(Pkg,pkgOrderList::Configured) == true) + return true; + if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false) + return false; + + + // Put the package on the list + OList.push_back(Pkg); + OList.Flag(Pkg,pkgOrderList::Added); + Depth++; + + // Check the dependencies to see if they are all satisfied. + bool Bad = false; + for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;) + { + if (D->Type != pkgDEP_Depends && D->Type != pkgDEP_PreDepends) + { + D++; + continue; + } + + // Grok or groups + Bad = true; + for (bool LastOR = true; D.end() == false && LastOR == true; D++) + { + LastOR = (D->CompareOp & pkgOP_OR) == pkgOP_OR; + + if (Bad == false) + continue; + + Version **VList = D.AllTargets(); + for (Version **I = VList; *I != 0 && Bad == true; I++) + { + VerIterator Ver(Cache,*I); + PkgIterator Pkg = Ver.ParentPkg(); + + // See if the current version is ok + if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true && + Pkg.State() == PkgIterator::NeedsNothing) + { + Bad = false; + continue; + } + + // Not the install version + if (Cache[Pkg].InstallVer != *I || + (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing)) + continue; + if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true) + Bad = !DepAdd(OList,Pkg,Depth); + if (List->IsFlag(Pkg,pkgOrderList::Configured) == true) + Bad = false; + } + delete [] VList; + } + + if (Bad == true) + { + OList.Flag(Pkg,0,pkgOrderList::Added); + OList.pop_back(); + Depth--; + return false; + } + } + + Depth--; + return true; +} + /*}}}*/ +// PM::EarlyRemove - Perform removal of packages before their time /*{{{*/ +// --------------------------------------------------------------------- +/* This is called to deal with conflicts arising from unpacking */ +bool pkgPackageManager::EarlyRemove(PkgIterator Pkg) +{ + if (List->IsNow(Pkg) == false) + return true; + + // Already removed it + if (List->IsFlag(Pkg,pkgOrderList::Removed) == true) + return true; + + // Woops, it will not be re-installed! + if (List->IsFlag(Pkg,pkgOrderList::InList) == false) + return false; + + bool Res = SmartRemove(Pkg); + if (Cache[Pkg].Delete() == false) + List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States); + + return Res; +} + /*}}}*/ +// PM::SmartRemove - Removal Helper /*{{{*/ +// --------------------------------------------------------------------- +/* */ +bool pkgPackageManager::SmartRemove(PkgIterator Pkg) +{ + if (List->IsNow(Pkg) == false) + return true; + + List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); + return Remove(Pkg); +} + /*}}}*/ +// PM::SmartUnPack - Install helper /*{{{*/ +// --------------------------------------------------------------------- +/* This performs the task of handling pre-depends. */ +bool pkgPackageManager::SmartUnPack(PkgIterator Pkg) +{ + // Check if it is already unpacked + if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && + Cache[Pkg].Keep() == true) + { + List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States); + if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true) + if (SmartConfigure(Pkg) == false) + return _error->Error("Internal Error, Could not perform immediate configuraton"); + return true; + } + + /* See if this packages install version has any predependencies + that are not met by 'now' packages. */ + for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); + D.end() == false; D++) + { + if (D->Type == pkgDEP_PreDepends) + { + // Look for possible ok targets. + Version **VList = D.AllTargets(); + bool Bad = true; + for (Version **I = VList; *I != 0 && Bad == true; I++) + { + VerIterator Ver(Cache,*I); + PkgIterator Pkg = Ver.ParentPkg(); + + // See if the current version is ok + if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true && + Pkg.State() == PkgIterator::NeedsNothing) + { + Bad = false; + continue; + } + } + + // Look for something that could be configured. + for (Version **I = VList; *I != 0 && Bad == true; I++) + { + VerIterator Ver(Cache,*I); + PkgIterator Pkg = Ver.ParentPkg(); + + // Not the install version + if (Cache[Pkg].InstallVer != *I || + (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing)) + continue; + + Bad = !SmartConfigure(Pkg); + } + + delete [] VList; + + if (Bad == true) + return _error->Error("Internal Error, Couldn't configure a pre-depend"); + + continue; + } + + if (D->Type == pkgDEP_Conflicts) + { + /* Look for conflicts. Two packages that are both in the install + state cannot conflict so we don't check.. */ + Version **VList = D.AllTargets(); + for (Version **I = VList; *I != 0; I++) + { + VerIterator Ver(Cache,*I); + PkgIterator Pkg = Ver.ParentPkg(); + + // See if the current version is conflicting + if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true) + { + if (EarlyRemove(Pkg) == false) + return _error->Error("Internal Error, Could not early remove %s",Pkg.Name()); + } + } + delete [] VList; + } + } + + // Check for reverse conflicts. + CheckRConflicts(Pkg,Pkg.RevDependsList(), + Cache[Pkg].InstVerIter(Cache).VerStr()); + for (PrvIterator P = Cache[Pkg].InstVerIter(Cache).ProvidesList(); + P.end() == false; P++) + CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion()); + + if (Install(Pkg,FileNames[Pkg->ID]) == false) + return false; + + List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States); + + // Perform immedate configuration of the package. + if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true) + if (SmartConfigure(Pkg) == false) + return _error->Error("Internal Error, Could not perform immediate configuraton"); + + return true; +} + /*}}}*/ +// PM::OrderInstall - Installation ordering routine /*{{{*/ +// --------------------------------------------------------------------- +/* */ +bool pkgPackageManager::OrderInstall() +{ + delete List; + List = new pkgOrderList(Cache); + + // Generate the list of affected packages and sort it + for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++) + { + // Consider all depends + if ((I->Flags & pkgFLAG_Essential) == pkgFLAG_Essential) + { + List->Flag(I,pkgOrderList::Immediate); + if (Cache[I].InstallVer != 0) + for (DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); + D.end() == false; D++) + if (D->Type == pkgDEP_Depends || D->Type == pkgDEP_PreDepends) + List->Flag(D.TargetPkg(),pkgOrderList::Immediate); + if (I->CurrentVer != 0) + for (DepIterator D = I.CurrentVer().DependsList(); + D.end() == false; D++) + if (D->Type == pkgDEP_Depends || D->Type == pkgDEP_PreDepends) + List->Flag(D.TargetPkg(),pkgOrderList::Immediate); + } + + // Not interesting + if ((Cache[I].Keep() == true || + Cache[I].InstVerIter(Cache) == I.CurrentVer()) && + I.State() == pkgCache::PkgIterator::NeedsNothing) + continue; + + // Append it to the list + List->push_back(I); + + if ((I->Flags & pkgFLAG_ImmediateConf) == pkgFLAG_ImmediateConf) + List->Flag(I,pkgOrderList::Immediate); + } + + if (List->OrderUnpack() == false) + return _error->Error("Internal ordering error"); + + for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++) + { + PkgIterator Pkg(Cache,*I); + + // Sanity check + if (Cache[Pkg].Keep() == true && Pkg.State() == pkgCache::PkgIterator::NeedsNothing) + return _error->Error("Internal Error, trying to manipulate a kept package"); + + // Perform a delete or an install + if (Cache[Pkg].Delete() == true) + { + if (SmartRemove(Pkg) == false) + return false; + } + else + if (SmartUnPack(Pkg) == false) + return false; + } + + // Final run through the configure phase + if (ConfigureAll() == false) + return false; + + // Sanity check + for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++) + if (List->IsFlag(*I,pkgOrderList::Configured) == false) + return _error->Error("Internal error, packages left unconfigured. %s", + PkgIterator(Cache,*I).Name()); + + return true; +} + /*}}}*/ +// PM::DoInstall - Does the installation /*{{{*/ +// --------------------------------------------------------------------- +/* This uses the filenames in FileNames and the information in the + DepCache to perform the installation of packages.*/ +bool pkgPackageManager::DoInstall() +{ + return OrderInstall() && Go(); +} + /*}}}*/ |