| 1 | // -*- mode: cpp; mode: fold -*- |
| 2 | // Description /*{{{*/ |
| 3 | // $Id: packagemanager.cc,v 1.30 2003/04/27 03:04:15 doogie Exp $ |
| 4 | /* ###################################################################### |
| 5 | |
| 6 | Package Manager - Abstacts the package manager |
| 7 | |
| 8 | More work is needed in the area of transitioning provides, ie exim |
| 9 | replacing smail. This can cause interesing side effects. |
| 10 | |
| 11 | Other cases involving conflicts+replaces should be tested. |
| 12 | |
| 13 | ##################################################################### */ |
| 14 | /*}}}*/ |
| 15 | // Include Files /*{{{*/ |
| 16 | #include<config.h> |
| 17 | |
| 18 | #include <apt-pkg/packagemanager.h> |
| 19 | #include <apt-pkg/orderlist.h> |
| 20 | #include <apt-pkg/depcache.h> |
| 21 | #include <apt-pkg/error.h> |
| 22 | #include <apt-pkg/version.h> |
| 23 | #include <apt-pkg/acquire-item.h> |
| 24 | #include <apt-pkg/algorithms.h> |
| 25 | #include <apt-pkg/configuration.h> |
| 26 | #include <apt-pkg/sptr.h> |
| 27 | |
| 28 | #include <apti18n.h> |
| 29 | #include <iostream> |
| 30 | #include <fcntl.h> |
| 31 | /*}}}*/ |
| 32 | using namespace std; |
| 33 | |
| 34 | bool pkgPackageManager::SigINTStop = false; |
| 35 | |
| 36 | // PM::PackageManager - Constructor /*{{{*/ |
| 37 | // --------------------------------------------------------------------- |
| 38 | /* */ |
| 39 | pkgPackageManager::pkgPackageManager(pkgDepCache *pCache) : Cache(*pCache), |
| 40 | List(NULL), Res(Incomplete) |
| 41 | { |
| 42 | FileNames = new string[Cache.Head().PackageCount]; |
| 43 | Debug = _config->FindB("Debug::pkgPackageManager",false); |
| 44 | NoImmConfigure = !_config->FindB("APT::Immediate-Configure",true); |
| 45 | ImmConfigureAll = _config->FindB("APT::Immediate-Configure-All",false); |
| 46 | } |
| 47 | /*}}}*/ |
| 48 | // PM::PackageManager - Destructor /*{{{*/ |
| 49 | // --------------------------------------------------------------------- |
| 50 | /* */ |
| 51 | pkgPackageManager::~pkgPackageManager() |
| 52 | { |
| 53 | delete List; |
| 54 | delete [] FileNames; |
| 55 | } |
| 56 | /*}}}*/ |
| 57 | // PM::GetArchives - Queue the archives for download /*{{{*/ |
| 58 | // --------------------------------------------------------------------- |
| 59 | /* */ |
| 60 | bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources, |
| 61 | pkgRecords *Recs) |
| 62 | { |
| 63 | if (CreateOrderList() == false) |
| 64 | return false; |
| 65 | |
| 66 | bool const ordering = |
| 67 | _config->FindB("PackageManager::UnpackAll",true) ? |
| 68 | List->OrderUnpack() : List->OrderCritical(); |
| 69 | if (ordering == false) |
| 70 | return _error->Error("Internal ordering error"); |
| 71 | |
| 72 | for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I) |
| 73 | { |
| 74 | PkgIterator Pkg(Cache,*I); |
| 75 | FileNames[Pkg->ID] = string(); |
| 76 | |
| 77 | // Skip packages to erase |
| 78 | if (Cache[Pkg].Delete() == true) |
| 79 | continue; |
| 80 | |
| 81 | // Skip Packages that need configure only. |
| 82 | if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && |
| 83 | Cache[Pkg].Keep() == true) |
| 84 | continue; |
| 85 | |
| 86 | // Skip already processed packages |
| 87 | if (List->IsNow(Pkg) == false) |
| 88 | continue; |
| 89 | |
| 90 | new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache), |
| 91 | FileNames[Pkg->ID]); |
| 92 | } |
| 93 | |
| 94 | return true; |
| 95 | } |
| 96 | /*}}}*/ |
| 97 | // PM::FixMissing - Keep all missing packages /*{{{*/ |
| 98 | // --------------------------------------------------------------------- |
| 99 | /* This is called to correct the installation when packages could not |
| 100 | be downloaded. */ |
| 101 | bool pkgPackageManager::FixMissing() |
| 102 | { |
| 103 | pkgDepCache::ActionGroup group(Cache); |
| 104 | pkgProblemResolver Resolve(&Cache); |
| 105 | List->SetFileList(FileNames); |
| 106 | |
| 107 | bool Bad = false; |
| 108 | for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
| 109 | { |
| 110 | if (List->IsMissing(I) == false) |
| 111 | continue; |
| 112 | |
| 113 | // Okay, this file is missing and we need it. Mark it for keep |
| 114 | Bad = true; |
| 115 | Cache.MarkKeep(I, false, false); |
| 116 | } |
| 117 | |
| 118 | // We have to empty the list otherwise it will not have the new changes |
| 119 | delete List; |
| 120 | List = 0; |
| 121 | |
| 122 | if (Bad == false) |
| 123 | return true; |
| 124 | |
| 125 | // Now downgrade everything that is broken |
| 126 | return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0; |
| 127 | } |
| 128 | /*}}}*/ |
| 129 | // PM::ImmediateAdd - Add the immediate flag recursivly /*{{{*/ |
| 130 | // --------------------------------------------------------------------- |
| 131 | /* This adds the immediate flag to the pkg and recursively to the |
| 132 | dependendies |
| 133 | */ |
| 134 | void pkgPackageManager::ImmediateAdd(PkgIterator I, bool UseInstallVer, unsigned const int &Depth) |
| 135 | { |
| 136 | DepIterator D; |
| 137 | |
| 138 | if(UseInstallVer) |
| 139 | { |
| 140 | if(Cache[I].InstallVer == 0) |
| 141 | return; |
| 142 | D = Cache[I].InstVerIter(Cache).DependsList(); |
| 143 | } else { |
| 144 | if (I->CurrentVer == 0) |
| 145 | return; |
| 146 | D = I.CurrentVer().DependsList(); |
| 147 | } |
| 148 | |
| 149 | for ( /* nothing */ ; D.end() == false; ++D) |
| 150 | if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends) |
| 151 | { |
| 152 | if(!List->IsFlag(D.TargetPkg(), pkgOrderList::Immediate)) |
| 153 | { |
| 154 | if(Debug) |
| 155 | clog << OutputInDepth(Depth) << "ImmediateAdd(): Adding Immediate flag to " << D.TargetPkg() << " cause of " << D.DepType() << " " << I.Name() << endl; |
| 156 | List->Flag(D.TargetPkg(),pkgOrderList::Immediate); |
| 157 | ImmediateAdd(D.TargetPkg(), UseInstallVer, Depth + 1); |
| 158 | } |
| 159 | } |
| 160 | return; |
| 161 | } |
| 162 | /*}}}*/ |
| 163 | // PM::CreateOrderList - Create the ordering class /*{{{*/ |
| 164 | // --------------------------------------------------------------------- |
| 165 | /* This populates the ordering list with all the packages that are |
| 166 | going to change. */ |
| 167 | bool pkgPackageManager::CreateOrderList() |
| 168 | { |
| 169 | if (List != 0) |
| 170 | return true; |
| 171 | |
| 172 | delete List; |
| 173 | List = new pkgOrderList(&Cache); |
| 174 | |
| 175 | if (Debug && ImmConfigureAll) |
| 176 | clog << "CreateOrderList(): Adding Immediate flag for all packages because of APT::Immediate-Configure-All" << endl; |
| 177 | |
| 178 | // Generate the list of affected packages and sort it |
| 179 | for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
| 180 | { |
| 181 | // Ignore no-version packages |
| 182 | if (I->VersionList == 0) |
| 183 | continue; |
| 184 | |
| 185 | // Mark the package and its dependends for immediate configuration |
| 186 | if ((((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) && |
| 187 | NoImmConfigure == false) || ImmConfigureAll) |
| 188 | { |
| 189 | if(Debug && !ImmConfigureAll) |
| 190 | clog << "CreateOrderList(): Adding Immediate flag for " << I.Name() << endl; |
| 191 | List->Flag(I,pkgOrderList::Immediate); |
| 192 | |
| 193 | if (!ImmConfigureAll) { |
| 194 | // Look for other install packages to make immediate configurea |
| 195 | ImmediateAdd(I, true); |
| 196 | |
| 197 | // And again with the current version. |
| 198 | ImmediateAdd(I, false); |
| 199 | } |
| 200 | } |
| 201 | |
| 202 | // Not interesting |
| 203 | if ((Cache[I].Keep() == true || |
| 204 | Cache[I].InstVerIter(Cache) == I.CurrentVer()) && |
| 205 | I.State() == pkgCache::PkgIterator::NeedsNothing && |
| 206 | (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall && |
| 207 | (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete || |
| 208 | (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge)) |
| 209 | continue; |
| 210 | |
| 211 | // Append it to the list |
| 212 | List->push_back(I); |
| 213 | } |
| 214 | |
| 215 | return true; |
| 216 | } |
| 217 | /*}}}*/ |
| 218 | // PM::DepAlwaysTrue - Returns true if this dep is irrelevent /*{{{*/ |
| 219 | // --------------------------------------------------------------------- |
| 220 | /* The restriction on provides is to eliminate the case when provides |
| 221 | are transitioning between valid states [ie exim to smail] */ |
| 222 | bool pkgPackageManager::DepAlwaysTrue(DepIterator D) |
| 223 | { |
| 224 | if (D.TargetPkg()->ProvidesList != 0) |
| 225 | return false; |
| 226 | |
| 227 | if ((Cache[D] & pkgDepCache::DepInstall) != 0 && |
| 228 | (Cache[D] & pkgDepCache::DepNow) != 0) |
| 229 | return true; |
| 230 | return false; |
| 231 | } |
| 232 | /*}}}*/ |
| 233 | // PM::CheckRConflicts - Look for reverse conflicts /*{{{*/ |
| 234 | // --------------------------------------------------------------------- |
| 235 | /* This looks over the reverses for a conflicts line that needs early |
| 236 | removal. */ |
| 237 | bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D, |
| 238 | const char *Ver) |
| 239 | { |
| 240 | for (;D.end() == false; ++D) |
| 241 | { |
| 242 | if (D->Type != pkgCache::Dep::Conflicts && |
| 243 | D->Type != pkgCache::Dep::Obsoletes) |
| 244 | continue; |
| 245 | |
| 246 | // The package hasnt been changed |
| 247 | if (List->IsNow(Pkg) == false) |
| 248 | continue; |
| 249 | |
| 250 | // Ignore self conflicts, ignore conflicts from irrelevent versions |
| 251 | if (D.IsIgnorable(Pkg) || D.ParentVer() != D.ParentPkg().CurrentVer()) |
| 252 | continue; |
| 253 | |
| 254 | if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false) |
| 255 | continue; |
| 256 | |
| 257 | if (EarlyRemove(D.ParentPkg()) == false) |
| 258 | return _error->Error("Reverse conflicts early remove for package '%s' failed", |
| 259 | Pkg.Name()); |
| 260 | } |
| 261 | return true; |
| 262 | } |
| 263 | /*}}}*/ |
| 264 | // PM::ConfigureAll - Run the all out configuration /*{{{*/ |
| 265 | // --------------------------------------------------------------------- |
| 266 | /* This configures every package. It is assumed they are all unpacked and |
| 267 | that the final configuration is valid. This is also used to catch packages |
| 268 | that have not been configured when using ImmConfigureAll */ |
| 269 | bool pkgPackageManager::ConfigureAll() |
| 270 | { |
| 271 | pkgOrderList OList(&Cache); |
| 272 | |
| 273 | // Populate the order list |
| 274 | for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I) |
| 275 | if (List->IsFlag(pkgCache::PkgIterator(Cache,*I), |
| 276 | pkgOrderList::UnPacked) == true) |
| 277 | OList.push_back(*I); |
| 278 | |
| 279 | if (OList.OrderConfigure() == false) |
| 280 | return false; |
| 281 | |
| 282 | std::string const conf = _config->Find("PackageManager::Configure","all"); |
| 283 | bool const ConfigurePkgs = (conf == "all"); |
| 284 | |
| 285 | // Perform the configuring |
| 286 | for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); ++I) |
| 287 | { |
| 288 | PkgIterator Pkg(Cache,*I); |
| 289 | |
| 290 | /* Check if the package has been configured, this can happen if SmartConfigure |
| 291 | calls its self */ |
| 292 | if (List->IsFlag(Pkg,pkgOrderList::Configured)) continue; |
| 293 | |
| 294 | if (ConfigurePkgs == true && SmartConfigure(Pkg, 0) == false) { |
| 295 | if (ImmConfigureAll) |
| 296 | _error->Error(_("Could not perform immediate configuration on '%s'. " |
| 297 | "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),1); |
| 298 | else |
| 299 | _error->Error("Internal error, packages left unconfigured. %s",Pkg.Name()); |
| 300 | return false; |
| 301 | } |
| 302 | |
| 303 | List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); |
| 304 | } |
| 305 | |
| 306 | return true; |
| 307 | } |
| 308 | /*}}}*/ |
| 309 | // PM::SmartConfigure - Perform immediate configuration of the pkg /*{{{*/ |
| 310 | // --------------------------------------------------------------------- |
| 311 | /* This function tries to put the system in a state where Pkg can be configured. |
| 312 | This involves checking each of Pkg's dependanies and unpacking and |
| 313 | configuring packages where needed. |
| 314 | |
| 315 | Note on failure: This method can fail, without causing any problems. |
| 316 | This can happen when using Immediate-Configure-All, SmartUnPack may call |
| 317 | SmartConfigure, it may fail because of a complex dependancy situation, but |
| 318 | a error will only be reported if ConfigureAll fails. This is why some of the |
| 319 | messages this function reports on failure (return false;) as just warnings |
| 320 | only shown when debuging*/ |
| 321 | bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth) |
| 322 | { |
| 323 | // If this is true, only check and correct and dependencies without the Loop flag |
| 324 | bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop); |
| 325 | |
| 326 | if (Debug) { |
| 327 | VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer); |
| 328 | clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.Name() << " (" << InstallVer.VerStr() << ")"; |
| 329 | if (PkgLoop) |
| 330 | clog << " (Only Correct Dependencies)"; |
| 331 | clog << endl; |
| 332 | } |
| 333 | |
| 334 | VerIterator const instVer = Cache[Pkg].InstVerIter(Cache); |
| 335 | |
| 336 | /* Because of the ordered list, most dependencies should be unpacked, |
| 337 | however if there is a loop (A depends on B, B depends on A) this will not |
| 338 | be the case, so check for dependencies before configuring. */ |
| 339 | bool Bad = false; |
| 340 | for (DepIterator D = instVer.DependsList(); |
| 341 | D.end() == false; ) |
| 342 | { |
| 343 | // Compute a single dependency element (glob or) |
| 344 | pkgCache::DepIterator Start; |
| 345 | pkgCache::DepIterator End; |
| 346 | D.GlobOr(Start,End); |
| 347 | |
| 348 | if (End->Type == pkgCache::Dep::Depends) |
| 349 | Bad = true; |
| 350 | |
| 351 | // Check for dependanices that have not been unpacked, probably due to loops. |
| 352 | while (End->Type == pkgCache::Dep::Depends) { |
| 353 | PkgIterator DepPkg; |
| 354 | VerIterator InstallVer; |
| 355 | SPtrArray<Version *> VList = Start.AllTargets(); |
| 356 | |
| 357 | // Check through each version of each package that could satisfy this dependancy |
| 358 | for (Version **I = VList; *I != 0; I++) { |
| 359 | VerIterator Ver(Cache,*I); |
| 360 | DepPkg = Ver.ParentPkg(); |
| 361 | InstallVer = VerIterator(Cache,Cache[DepPkg].InstallVer); |
| 362 | |
| 363 | // Check if the current version of the package is avalible and will satisfy this dependancy |
| 364 | if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true && |
| 365 | !List->IsFlag(DepPkg,pkgOrderList::Removed) && DepPkg.State() == PkgIterator::NeedsNothing) |
| 366 | { |
| 367 | Bad = false; |
| 368 | break; |
| 369 | } |
| 370 | |
| 371 | // Check if the version that is going to be installed will satisfy the dependancy |
| 372 | if (Cache[DepPkg].InstallVer == *I) { |
| 373 | if (List->IsFlag(DepPkg,pkgOrderList::UnPacked)) { |
| 374 | if (List->IsFlag(DepPkg,pkgOrderList::Loop) && PkgLoop) { |
| 375 | // This dependancy has already been dealt with by another SmartConfigure on Pkg |
| 376 | Bad = false; |
| 377 | break; |
| 378 | } else if (List->IsFlag(Pkg,pkgOrderList::Loop)) { |
| 379 | /* Check for a loop to prevent one forming |
| 380 | If A depends on B and B depends on A, SmartConfigure will |
| 381 | just hop between them if this is not checked. Dont remove the |
| 382 | loop flag after finishing however as loop is already set. |
| 383 | This means that there is another SmartConfigure call for this |
| 384 | package and it will remove the loop flag */ |
| 385 | Bad = !SmartConfigure(DepPkg, Depth + 1); |
| 386 | } else { |
| 387 | /* Check for a loop to prevent one forming |
| 388 | If A depends on B and B depends on A, SmartConfigure will |
| 389 | just hop between them if this is not checked */ |
| 390 | List->Flag(Pkg,pkgOrderList::Loop); |
| 391 | Bad = !SmartConfigure(DepPkg, Depth + 1); |
| 392 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 393 | } |
| 394 | // If SmartConfigure was succesfull, Bad is false, so break |
| 395 | if (!Bad) break; |
| 396 | } else if (List->IsFlag(DepPkg,pkgOrderList::Configured)) { |
| 397 | Bad = false; |
| 398 | break; |
| 399 | } |
| 400 | } |
| 401 | } |
| 402 | |
| 403 | /* If the dependany is still not satisfied, try, if possible, unpacking a package to satisfy it */ |
| 404 | if (InstallVer != 0 && Bad) { |
| 405 | if (List->IsNow(DepPkg)) { |
| 406 | Bad = false; |
| 407 | if (List->IsFlag(Pkg,pkgOrderList::Loop)) |
| 408 | { |
| 409 | if (Debug) |
| 410 | std::clog << OutputInDepth(Depth) << "Package " << Pkg << " loops in SmartConfigure" << std::endl; |
| 411 | } |
| 412 | else |
| 413 | { |
| 414 | List->Flag(Pkg,pkgOrderList::Loop); |
| 415 | if (Debug) |
| 416 | cout << OutputInDepth(Depth) << "Unpacking " << DepPkg.Name() << " to avoid loop" << endl; |
| 417 | SmartUnPack(DepPkg, true, Depth + 1); |
| 418 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 419 | } |
| 420 | } |
| 421 | } |
| 422 | |
| 423 | if (Start==End) { |
| 424 | if (Bad && Debug && List->IsFlag(DepPkg,pkgOrderList::Loop) == false) |
| 425 | std::clog << OutputInDepth(Depth) << "Could not satisfy dependencies for " << Pkg.Name() << std::endl; |
| 426 | break; |
| 427 | } else { |
| 428 | Start++; |
| 429 | } |
| 430 | } |
| 431 | } |
| 432 | |
| 433 | if (Bad) { |
| 434 | if (Debug) |
| 435 | _error->Warning(_("Could not configure '%s'. "),Pkg.Name()); |
| 436 | return false; |
| 437 | } |
| 438 | |
| 439 | if (PkgLoop) return true; |
| 440 | |
| 441 | static std::string const conf = _config->Find("PackageManager::Configure","all"); |
| 442 | static bool const ConfigurePkgs = (conf == "all" || conf == "smart"); |
| 443 | |
| 444 | if (List->IsFlag(Pkg,pkgOrderList::Configured)) |
| 445 | return _error->Error("Internal configure error on '%s'.", Pkg.Name()); |
| 446 | |
| 447 | if (ConfigurePkgs == true && Configure(Pkg) == false) |
| 448 | return false; |
| 449 | |
| 450 | List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); |
| 451 | |
| 452 | if ((Cache[Pkg].InstVerIter(Cache)->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same) |
| 453 | for (PkgIterator P = Pkg.Group().PackageList(); |
| 454 | P.end() == false; P = Pkg.Group().NextPkg(P)) |
| 455 | { |
| 456 | if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true || |
| 457 | Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer && |
| 458 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)) |
| 459 | continue; |
| 460 | SmartConfigure(P, (Depth +1)); |
| 461 | } |
| 462 | |
| 463 | // Sanity Check |
| 464 | if (List->IsFlag(Pkg,pkgOrderList::Configured) == false) |
| 465 | return _error->Error(_("Could not configure '%s'. "),Pkg.Name()); |
| 466 | |
| 467 | return true; |
| 468 | } |
| 469 | /*}}}*/ |
| 470 | // PM::EarlyRemove - Perform removal of packages before their time /*{{{*/ |
| 471 | // --------------------------------------------------------------------- |
| 472 | /* This is called to deal with conflicts arising from unpacking */ |
| 473 | bool pkgPackageManager::EarlyRemove(PkgIterator Pkg) |
| 474 | { |
| 475 | if (List->IsNow(Pkg) == false) |
| 476 | return true; |
| 477 | |
| 478 | // Already removed it |
| 479 | if (List->IsFlag(Pkg,pkgOrderList::Removed) == true) |
| 480 | return true; |
| 481 | |
| 482 | // Woops, it will not be re-installed! |
| 483 | if (List->IsFlag(Pkg,pkgOrderList::InList) == false) |
| 484 | return false; |
| 485 | |
| 486 | // Essential packages get special treatment |
| 487 | bool IsEssential = false; |
| 488 | if ((Pkg->Flags & pkgCache::Flag::Essential) != 0 || |
| 489 | (Pkg->Flags & pkgCache::Flag::Important) != 0) |
| 490 | IsEssential = true; |
| 491 | |
| 492 | /* Check for packages that are the dependents of essential packages and |
| 493 | promote them too */ |
| 494 | if (Pkg->CurrentVer != 0) |
| 495 | { |
| 496 | for (DepIterator D = Pkg.RevDependsList(); D.end() == false && |
| 497 | IsEssential == false; ++D) |
| 498 | if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends) |
| 499 | if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0 || |
| 500 | (D.ParentPkg()->Flags & pkgCache::Flag::Important) != 0) |
| 501 | IsEssential = true; |
| 502 | } |
| 503 | |
| 504 | if (IsEssential == true) |
| 505 | { |
| 506 | if (_config->FindB("APT::Force-LoopBreak",false) == false) |
| 507 | return _error->Error(_("This installation run will require temporarily " |
| 508 | "removing the essential package %s due to a " |
| 509 | "Conflicts/Pre-Depends loop. This is often bad, " |
| 510 | "but if you really want to do it, activate the " |
| 511 | "APT::Force-LoopBreak option."),Pkg.Name()); |
| 512 | } |
| 513 | |
| 514 | bool Res = SmartRemove(Pkg); |
| 515 | if (Cache[Pkg].Delete() == false) |
| 516 | List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States); |
| 517 | |
| 518 | return Res; |
| 519 | } |
| 520 | /*}}}*/ |
| 521 | // PM::SmartRemove - Removal Helper /*{{{*/ |
| 522 | // --------------------------------------------------------------------- |
| 523 | /* */ |
| 524 | bool pkgPackageManager::SmartRemove(PkgIterator Pkg) |
| 525 | { |
| 526 | if (List->IsNow(Pkg) == false) |
| 527 | return true; |
| 528 | |
| 529 | List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); |
| 530 | |
| 531 | return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge); |
| 532 | } |
| 533 | /*}}}*/ |
| 534 | // PM::SmartUnPack - Install helper /*{{{*/ |
| 535 | // --------------------------------------------------------------------- |
| 536 | /* This puts the system in a state where it can Unpack Pkg, if Pkg is allready |
| 537 | unpacked, or when it has been unpacked, if Immediate==true it configures it. */ |
| 538 | bool pkgPackageManager::SmartUnPack(PkgIterator Pkg) |
| 539 | { |
| 540 | return SmartUnPack(Pkg, true, 0); |
| 541 | } |
| 542 | bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int const Depth) |
| 543 | { |
| 544 | bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop); |
| 545 | |
| 546 | if (Debug) { |
| 547 | clog << OutputInDepth(Depth) << "SmartUnPack " << Pkg.Name(); |
| 548 | VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer); |
| 549 | if (Pkg.CurrentVer() == 0) |
| 550 | cout << " (install version " << InstallVer.VerStr() << ")"; |
| 551 | else |
| 552 | cout << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")"; |
| 553 | if (PkgLoop) |
| 554 | cout << " (Only Perform PreUnpack Checks)"; |
| 555 | cout << endl; |
| 556 | } |
| 557 | |
| 558 | VerIterator const instVer = Cache[Pkg].InstVerIter(Cache); |
| 559 | |
| 560 | /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked. |
| 561 | It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should |
| 562 | avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with |
| 563 | complex dependancy structures, trying to configure some packages while breaking the loops can complicate things . |
| 564 | This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured), |
| 565 | or by the ConfigureAll call at the end of the for loop in OrderInstall. */ |
| 566 | for (DepIterator D = instVer.DependsList(); |
| 567 | D.end() == false; ) |
| 568 | { |
| 569 | // Compute a single dependency element (glob or) |
| 570 | pkgCache::DepIterator Start; |
| 571 | pkgCache::DepIterator End; |
| 572 | D.GlobOr(Start,End); |
| 573 | |
| 574 | while (End->Type == pkgCache::Dep::PreDepends) |
| 575 | { |
| 576 | if (Debug) |
| 577 | clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.Name() << std::endl; |
| 578 | |
| 579 | // Look for possible ok targets. |
| 580 | SPtrArray<Version *> VList = Start.AllTargets(); |
| 581 | bool Bad = true; |
| 582 | for (Version **I = VList; *I != 0 && Bad == true; I++) |
| 583 | { |
| 584 | VerIterator Ver(Cache,*I); |
| 585 | PkgIterator Pkg = Ver.ParentPkg(); |
| 586 | |
| 587 | // See if the current version is ok |
| 588 | if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true && |
| 589 | Pkg.State() == PkgIterator::NeedsNothing) |
| 590 | { |
| 591 | Bad = false; |
| 592 | if (Debug) |
| 593 | clog << OutputInDepth(Depth) << "Found ok package " << Pkg.Name() << endl; |
| 594 | continue; |
| 595 | } |
| 596 | } |
| 597 | |
| 598 | // Look for something that could be configured. |
| 599 | for (Version **I = VList; *I != 0 && Bad == true; I++) |
| 600 | { |
| 601 | VerIterator Ver(Cache,*I); |
| 602 | PkgIterator Pkg = Ver.ParentPkg(); |
| 603 | |
| 604 | // Not the install version |
| 605 | if (Cache[Pkg].InstallVer != *I || |
| 606 | (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing)) |
| 607 | continue; |
| 608 | |
| 609 | if (List->IsFlag(Pkg,pkgOrderList::Configured)) { |
| 610 | Bad = false; |
| 611 | continue; |
| 612 | } |
| 613 | |
| 614 | // check if it needs unpack or if if configure is enough |
| 615 | if (!List->IsFlag(Pkg,pkgOrderList::UnPacked)) |
| 616 | { |
| 617 | if (Debug) |
| 618 | clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << Pkg.Name() << endl; |
| 619 | // SmartUnpack with the ImmediateFlag to ensure its really ready |
| 620 | Bad = !SmartUnPack(Pkg, true, Depth + 1); |
| 621 | } else { |
| 622 | if (Debug) |
| 623 | clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << Pkg.Name() << endl; |
| 624 | Bad = !SmartConfigure(Pkg, Depth + 1); |
| 625 | } |
| 626 | } |
| 627 | |
| 628 | /* If this or element did not match then continue on to the |
| 629 | next or element until a matching element is found */ |
| 630 | if (Bad == true) |
| 631 | { |
| 632 | // This triggers if someone make a pre-depends/depend loop. |
| 633 | if (Start == End) |
| 634 | return _error->Error("Couldn't configure pre-depend %s for %s, " |
| 635 | "probably a dependency cycle.", |
| 636 | End.TargetPkg().Name(),Pkg.Name()); |
| 637 | ++Start; |
| 638 | } |
| 639 | else |
| 640 | break; |
| 641 | } |
| 642 | |
| 643 | if (End->Type == pkgCache::Dep::Conflicts || |
| 644 | End->Type == pkgCache::Dep::Obsoletes) |
| 645 | { |
| 646 | /* Look for conflicts. Two packages that are both in the install |
| 647 | state cannot conflict so we don't check.. */ |
| 648 | SPtrArray<Version *> VList = End.AllTargets(); |
| 649 | for (Version **I = VList; *I != 0; I++) |
| 650 | { |
| 651 | VerIterator Ver(Cache,*I); |
| 652 | PkgIterator ConflictPkg = Ver.ParentPkg(); |
| 653 | VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer); |
| 654 | |
| 655 | // See if the current version is conflicting |
| 656 | if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg)) |
| 657 | { |
| 658 | cout << OutputInDepth(Depth) << Pkg.Name() << " conflicts with " << ConflictPkg.Name() << endl; |
| 659 | /* If a loop is not present or has not yet been detected, attempt to unpack packages |
| 660 | to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */ |
| 661 | if (!List->IsFlag(ConflictPkg,pkgOrderList::Loop)) { |
| 662 | if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) { |
| 663 | if (Debug) |
| 664 | cout << OutputInDepth(Depth) << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.Name() << " to prevent conflict" << endl; |
| 665 | List->Flag(Pkg,pkgOrderList::Loop); |
| 666 | SmartUnPack(ConflictPkg,false, Depth + 1); |
| 667 | // Remove loop to allow it to be used later if needed |
| 668 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 669 | } else { |
| 670 | if (EarlyRemove(ConflictPkg) == false) |
| 671 | return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name()); |
| 672 | } |
| 673 | } else { |
| 674 | if (!List->IsFlag(ConflictPkg,pkgOrderList::Removed)) { |
| 675 | if (Debug) |
| 676 | cout << OutputInDepth(Depth) << "Because of conficts knot, removing " << ConflictPkg.Name() << " to conflict violation" << endl; |
| 677 | if (EarlyRemove(ConflictPkg) == false) |
| 678 | return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name()); |
| 679 | } |
| 680 | } |
| 681 | } |
| 682 | } |
| 683 | } |
| 684 | |
| 685 | // Check for breaks |
| 686 | if (End->Type == pkgCache::Dep::DpkgBreaks) { |
| 687 | SPtrArray<Version *> VList = End.AllTargets(); |
| 688 | for (Version **I = VList; *I != 0; I++) |
| 689 | { |
| 690 | VerIterator Ver(Cache,*I); |
| 691 | PkgIterator BrokenPkg = Ver.ParentPkg(); |
| 692 | if (BrokenPkg.CurrentVer() != Ver) |
| 693 | { |
| 694 | if (Debug) |
| 695 | std::clog << OutputInDepth(Depth) << " Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl; |
| 696 | continue; |
| 697 | } |
| 698 | |
| 699 | // Check if it needs to be unpacked |
| 700 | if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false && |
| 701 | List->IsNow(BrokenPkg)) { |
| 702 | if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) && PkgLoop) { |
| 703 | // This dependancy has already been dealt with by another SmartUnPack on Pkg |
| 704 | break; |
| 705 | } else { |
| 706 | // Found a break, so see if we can unpack the package to avoid it |
| 707 | // but do not set loop if another SmartUnPack already deals with it |
| 708 | VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer); |
| 709 | bool circle = false; |
| 710 | for (pkgCache::DepIterator D = InstallVer.DependsList(); D.end() == false; ++D) |
| 711 | { |
| 712 | if (D->Type != pkgCache::Dep::PreDepends) |
| 713 | continue; |
| 714 | SPtrArray<Version *> VL = D.AllTargets(); |
| 715 | for (Version **I = VL; *I != 0; ++I) |
| 716 | { |
| 717 | VerIterator V(Cache,*I); |
| 718 | PkgIterator P = V.ParentPkg(); |
| 719 | // we are checking for installation as an easy 'protection' against or-groups and (unchosen) providers |
| 720 | if (P->CurrentVer == 0 || P != Pkg || (P.CurrentVer() != V && Cache[P].InstallVer != V)) |
| 721 | continue; |
| 722 | circle = true; |
| 723 | break; |
| 724 | } |
| 725 | if (circle == true) |
| 726 | break; |
| 727 | } |
| 728 | if (circle == true) |
| 729 | { |
| 730 | if (Debug) |
| 731 | cout << OutputInDepth(Depth) << " Avoiding " << End << " avoided as " << BrokenPkg.FullName() << " has a pre-depends on " << Pkg.FullName() << std::endl; |
| 732 | continue; |
| 733 | } |
| 734 | else |
| 735 | { |
| 736 | if (Debug) |
| 737 | { |
| 738 | cout << OutputInDepth(Depth) << " Unpacking " << BrokenPkg.FullName() << " to avoid " << End; |
| 739 | if (PkgLoop == true) |
| 740 | cout << " (Looping)"; |
| 741 | cout << std::endl; |
| 742 | } |
| 743 | if (PkgLoop == false) |
| 744 | List->Flag(Pkg,pkgOrderList::Loop); |
| 745 | SmartUnPack(BrokenPkg, false, Depth + 1); |
| 746 | if (PkgLoop == false) |
| 747 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 748 | } |
| 749 | } |
| 750 | } else { |
| 751 | // Check if a package needs to be removed |
| 752 | if (Cache[BrokenPkg].Delete() == true && !List->IsFlag(BrokenPkg,pkgOrderList::Configured)) |
| 753 | { |
| 754 | if (Debug) |
| 755 | cout << OutputInDepth(Depth) << " Removing " << BrokenPkg.Name() << " to avoid " << End << endl; |
| 756 | SmartRemove(BrokenPkg); |
| 757 | } |
| 758 | } |
| 759 | } |
| 760 | } |
| 761 | } |
| 762 | |
| 763 | // Check for reverse conflicts. |
| 764 | if (CheckRConflicts(Pkg,Pkg.RevDependsList(), |
| 765 | instVer.VerStr()) == false) |
| 766 | return false; |
| 767 | |
| 768 | for (PrvIterator P = instVer.ProvidesList(); |
| 769 | P.end() == false; ++P) |
| 770 | if (Pkg->Group != P.OwnerPkg()->Group) |
| 771 | CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion()); |
| 772 | |
| 773 | if (PkgLoop) |
| 774 | return true; |
| 775 | |
| 776 | List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States); |
| 777 | |
| 778 | if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same) |
| 779 | { |
| 780 | /* Do lockstep M-A:same unpacking in two phases: |
| 781 | First unpack all installed architectures, then the not installed. |
| 782 | This way we avoid that M-A: enabled packages are installed before |
| 783 | their older non-M-A enabled packages are replaced by newer versions */ |
| 784 | bool const installed = Pkg->CurrentVer != 0; |
| 785 | if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false) |
| 786 | return false; |
| 787 | for (PkgIterator P = Pkg.Group().PackageList(); |
| 788 | P.end() == false; P = Pkg.Group().NextPkg(P)) |
| 789 | { |
| 790 | if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true || |
| 791 | Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer && |
| 792 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)) |
| 793 | continue; |
| 794 | if (SmartUnPack(P, false, Depth + 1) == false) |
| 795 | return false; |
| 796 | } |
| 797 | if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false) |
| 798 | return false; |
| 799 | for (PkgIterator P = Pkg.Group().PackageList(); |
| 800 | P.end() == false; P = Pkg.Group().NextPkg(P)) |
| 801 | { |
| 802 | if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true || |
| 803 | Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer && |
| 804 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)) |
| 805 | continue; |
| 806 | if (SmartUnPack(P, false, Depth + 1) == false) |
| 807 | return false; |
| 808 | } |
| 809 | } |
| 810 | // packages which are already unpacked don't need to be unpacked again |
| 811 | else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false) |
| 812 | return false; |
| 813 | |
| 814 | if (Immediate == true) { |
| 815 | // Perform immedate configuration of the package. |
| 816 | if (SmartConfigure(Pkg, Depth + 1) == false) |
| 817 | _error->Warning(_("Could not perform immediate configuration on '%s'. " |
| 818 | "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),2); |
| 819 | } |
| 820 | |
| 821 | return true; |
| 822 | } |
| 823 | /*}}}*/ |
| 824 | // PM::OrderInstall - Installation ordering routine /*{{{*/ |
| 825 | // --------------------------------------------------------------------- |
| 826 | /* */ |
| 827 | pkgPackageManager::OrderResult pkgPackageManager::OrderInstall() |
| 828 | { |
| 829 | if (CreateOrderList() == false) |
| 830 | return Failed; |
| 831 | |
| 832 | Reset(); |
| 833 | |
| 834 | if (Debug == true) |
| 835 | clog << "Beginning to order" << endl; |
| 836 | |
| 837 | bool const ordering = |
| 838 | _config->FindB("PackageManager::UnpackAll",true) ? |
| 839 | List->OrderUnpack(FileNames) : List->OrderCritical(); |
| 840 | if (ordering == false) |
| 841 | { |
| 842 | _error->Error("Internal ordering error"); |
| 843 | return Failed; |
| 844 | } |
| 845 | |
| 846 | if (Debug == true) |
| 847 | clog << "Done ordering" << endl; |
| 848 | |
| 849 | bool DoneSomething = false; |
| 850 | for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I) |
| 851 | { |
| 852 | PkgIterator Pkg(Cache,*I); |
| 853 | |
| 854 | if (List->IsNow(Pkg) == false) |
| 855 | { |
| 856 | if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) { |
| 857 | if (SmartConfigure(Pkg, 0) == false && Debug) |
| 858 | _error->Warning("Internal Error, Could not configure %s",Pkg.Name()); |
| 859 | // FIXME: The above warning message might need changing |
| 860 | } else { |
| 861 | if (Debug == true) |
| 862 | clog << "Skipping already done " << Pkg.Name() << endl; |
| 863 | } |
| 864 | continue; |
| 865 | |
| 866 | } |
| 867 | |
| 868 | if (List->IsMissing(Pkg) == true) |
| 869 | { |
| 870 | if (Debug == true) |
| 871 | clog << "Sequence completed at " << Pkg.Name() << endl; |
| 872 | if (DoneSomething == false) |
| 873 | { |
| 874 | _error->Error("Internal Error, ordering was unable to handle the media swap"); |
| 875 | return Failed; |
| 876 | } |
| 877 | return Incomplete; |
| 878 | } |
| 879 | |
| 880 | // Sanity check |
| 881 | if (Cache[Pkg].Keep() == true && |
| 882 | Pkg.State() == pkgCache::PkgIterator::NeedsNothing && |
| 883 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall) |
| 884 | { |
| 885 | _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name()); |
| 886 | return Failed; |
| 887 | } |
| 888 | |
| 889 | // Perform a delete or an install |
| 890 | if (Cache[Pkg].Delete() == true) |
| 891 | { |
| 892 | if (SmartRemove(Pkg) == false) |
| 893 | return Failed; |
| 894 | } |
| 895 | else |
| 896 | if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false) |
| 897 | return Failed; |
| 898 | DoneSomething = true; |
| 899 | |
| 900 | if (ImmConfigureAll) { |
| 901 | /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the |
| 902 | "PreUnpack Checks" section */ |
| 903 | if (!ConfigureAll()) |
| 904 | return Failed; |
| 905 | } |
| 906 | } |
| 907 | |
| 908 | // Final run through the configure phase |
| 909 | if (ConfigureAll() == false) |
| 910 | return Failed; |
| 911 | |
| 912 | // Sanity check |
| 913 | for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I) |
| 914 | { |
| 915 | if (List->IsFlag(*I,pkgOrderList::Configured) == false) |
| 916 | { |
| 917 | _error->Error("Internal error, packages left unconfigured. %s", |
| 918 | PkgIterator(Cache,*I).Name()); |
| 919 | return Failed; |
| 920 | } |
| 921 | } |
| 922 | |
| 923 | return Completed; |
| 924 | } |
| 925 | /*}}}*/ |
| 926 | // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/ |
| 927 | // --------------------------------------------------------------------- |
| 928 | pkgPackageManager::OrderResult |
| 929 | pkgPackageManager::DoInstallPostFork(int statusFd) |
| 930 | { |
| 931 | if(statusFd > 0) |
| 932 | // FIXME: use SetCloseExec here once it taught about throwing |
| 933 | // exceptions instead of doing _exit(100) on failure |
| 934 | fcntl(statusFd,F_SETFD,FD_CLOEXEC); |
| 935 | bool goResult = Go(statusFd); |
| 936 | if(goResult == false) |
| 937 | return Failed; |
| 938 | |
| 939 | return Res; |
| 940 | }; |
| 941 | |
| 942 | // PM::DoInstall - Does the installation /*{{{*/ |
| 943 | // --------------------------------------------------------------------- |
| 944 | /* This uses the filenames in FileNames and the information in the |
| 945 | DepCache to perform the installation of packages.*/ |
| 946 | pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd) |
| 947 | { |
| 948 | if(DoInstallPreFork() == Failed) |
| 949 | return Failed; |
| 950 | |
| 951 | return DoInstallPostFork(statusFd); |
| 952 | } |
| 953 | /*}}}*/ |