| 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.FullName() << 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.FullName() << 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.FullName().c_str()); |
| 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.FullName().c_str(),1); |
| 298 | else |
| 299 | _error->Error("Internal error, packages left unconfigured. %s",Pkg.FullName().c_str()); |
| 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 const PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop); |
| 325 | |
| 326 | if (Debug) { |
| 327 | VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer); |
| 328 | clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.FullName() << " (" << 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, Changed = false; |
| 340 | const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 500); |
| 341 | unsigned int i=0; |
| 342 | do |
| 343 | { |
| 344 | Changed = false; |
| 345 | for (DepIterator D = instVer.DependsList(); D.end() == false; ) |
| 346 | { |
| 347 | // Compute a single dependency element (glob or) |
| 348 | pkgCache::DepIterator Start, End; |
| 349 | D.GlobOr(Start,End); |
| 350 | |
| 351 | if (End->Type != pkgCache::Dep::Depends) |
| 352 | continue; |
| 353 | Bad = true; |
| 354 | |
| 355 | // Search for dependencies which are unpacked but aren't configured yet (maybe loops) |
| 356 | for (DepIterator Cur = Start; true; ++Cur) |
| 357 | { |
| 358 | SPtrArray<Version *> VList = Cur.AllTargets(); |
| 359 | |
| 360 | for (Version **I = VList; *I != 0; ++I) |
| 361 | { |
| 362 | VerIterator Ver(Cache,*I); |
| 363 | PkgIterator DepPkg = Ver.ParentPkg(); |
| 364 | |
| 365 | // Check if the current version of the package is available and will satisfy this dependency |
| 366 | if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true && |
| 367 | List->IsFlag(DepPkg,pkgOrderList::Removed) == false && |
| 368 | DepPkg.State() == PkgIterator::NeedsNothing) |
| 369 | { |
| 370 | Bad = false; |
| 371 | break; |
| 372 | } |
| 373 | |
| 374 | // Check if the version that is going to be installed will satisfy the dependency |
| 375 | if (Cache[DepPkg].InstallVer != *I) |
| 376 | continue; |
| 377 | |
| 378 | if (List->IsFlag(DepPkg,pkgOrderList::UnPacked)) |
| 379 | { |
| 380 | if (List->IsFlag(DepPkg,pkgOrderList::Loop) && PkgLoop) |
| 381 | { |
| 382 | // This dependency has already been dealt with by another SmartConfigure on Pkg |
| 383 | Bad = false; |
| 384 | break; |
| 385 | } |
| 386 | /* Check for a loop to prevent one forming |
| 387 | If A depends on B and B depends on A, SmartConfigure will |
| 388 | just hop between them if this is not checked. Dont remove the |
| 389 | loop flag after finishing however as loop is already set. |
| 390 | This means that there is another SmartConfigure call for this |
| 391 | package and it will remove the loop flag */ |
| 392 | if (PkgLoop == false) |
| 393 | List->Flag(Pkg,pkgOrderList::Loop); |
| 394 | if (SmartConfigure(DepPkg, Depth + 1) == true) |
| 395 | { |
| 396 | Bad = false; |
| 397 | if (List->IsFlag(DepPkg,pkgOrderList::Loop) == false) |
| 398 | Changed = true; |
| 399 | } |
| 400 | if (PkgLoop == false) |
| 401 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 402 | // If SmartConfigure was succesfull, Bad is false, so break |
| 403 | if (Bad == false) |
| 404 | break; |
| 405 | } |
| 406 | else if (List->IsFlag(DepPkg,pkgOrderList::Configured)) |
| 407 | { |
| 408 | Bad = false; |
| 409 | break; |
| 410 | } |
| 411 | } |
| 412 | if (Cur == End) |
| 413 | break; |
| 414 | } |
| 415 | |
| 416 | if (Bad == false) |
| 417 | continue; |
| 418 | |
| 419 | // Check for dependencies that have not been unpacked, probably due to loops. |
| 420 | for (DepIterator Cur = Start; true; ++Cur) |
| 421 | { |
| 422 | SPtrArray<Version *> VList = Cur.AllTargets(); |
| 423 | |
| 424 | for (Version **I = VList; *I != 0; ++I) |
| 425 | { |
| 426 | VerIterator Ver(Cache,*I); |
| 427 | PkgIterator DepPkg = Ver.ParentPkg(); |
| 428 | |
| 429 | // Check if the version that is going to be installed will satisfy the dependency |
| 430 | if (Cache[DepPkg].InstallVer != *I || List->IsNow(DepPkg) == false) |
| 431 | continue; |
| 432 | |
| 433 | if (PkgLoop == true) |
| 434 | { |
| 435 | if (Debug) |
| 436 | std::clog << OutputInDepth(Depth) << "Package " << Pkg << " loops in SmartConfigure" << std::endl; |
| 437 | Bad = false; |
| 438 | break; |
| 439 | } |
| 440 | else |
| 441 | { |
| 442 | if (Debug) |
| 443 | clog << OutputInDepth(Depth) << "Unpacking " << DepPkg.FullName() << " to avoid loop " << Cur << endl; |
| 444 | if (PkgLoop == false) |
| 445 | List->Flag(Pkg,pkgOrderList::Loop); |
| 446 | if (SmartUnPack(DepPkg, true, Depth + 1) == true) |
| 447 | { |
| 448 | Bad = false; |
| 449 | if (List->IsFlag(DepPkg,pkgOrderList::Loop) == false) |
| 450 | Changed = true; |
| 451 | } |
| 452 | if (PkgLoop == false) |
| 453 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 454 | if (Bad == false) |
| 455 | break; |
| 456 | } |
| 457 | } |
| 458 | |
| 459 | if (Cur == End) |
| 460 | break; |
| 461 | } |
| 462 | |
| 463 | if (Bad == true && Changed == false && Debug == true) |
| 464 | std::clog << OutputInDepth(Depth) << "Could not satisfy " << Start << std::endl; |
| 465 | } |
| 466 | if (i++ > max_loops) |
| 467 | return _error->Error("Internal error: MaxLoopCount reached in SmartUnPack for %s, aborting", Pkg.FullName().c_str()); |
| 468 | } while (Changed == true); |
| 469 | |
| 470 | if (Bad) { |
| 471 | if (Debug) |
| 472 | _error->Warning(_("Could not configure '%s'. "),Pkg.FullName().c_str()); |
| 473 | return false; |
| 474 | } |
| 475 | |
| 476 | if (PkgLoop) return true; |
| 477 | |
| 478 | static std::string const conf = _config->Find("PackageManager::Configure","all"); |
| 479 | static bool const ConfigurePkgs = (conf == "all" || conf == "smart"); |
| 480 | |
| 481 | if (List->IsFlag(Pkg,pkgOrderList::Configured)) |
| 482 | return _error->Error("Internal configure error on '%s'.", Pkg.FullName().c_str()); |
| 483 | |
| 484 | if (ConfigurePkgs == true && Configure(Pkg) == false) |
| 485 | return false; |
| 486 | |
| 487 | List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); |
| 488 | |
| 489 | if ((Cache[Pkg].InstVerIter(Cache)->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same) |
| 490 | for (PkgIterator P = Pkg.Group().PackageList(); |
| 491 | P.end() == false; P = Pkg.Group().NextPkg(P)) |
| 492 | { |
| 493 | if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true || |
| 494 | Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer && |
| 495 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)) |
| 496 | continue; |
| 497 | SmartConfigure(P, (Depth +1)); |
| 498 | } |
| 499 | |
| 500 | // Sanity Check |
| 501 | if (List->IsFlag(Pkg,pkgOrderList::Configured) == false) |
| 502 | return _error->Error(_("Could not configure '%s'. "),Pkg.FullName().c_str()); |
| 503 | |
| 504 | return true; |
| 505 | } |
| 506 | /*}}}*/ |
| 507 | // PM::EarlyRemove - Perform removal of packages before their time /*{{{*/ |
| 508 | // --------------------------------------------------------------------- |
| 509 | /* This is called to deal with conflicts arising from unpacking */ |
| 510 | bool pkgPackageManager::EarlyRemove(PkgIterator Pkg) |
| 511 | { |
| 512 | if (List->IsNow(Pkg) == false) |
| 513 | return true; |
| 514 | |
| 515 | // Already removed it |
| 516 | if (List->IsFlag(Pkg,pkgOrderList::Removed) == true) |
| 517 | return true; |
| 518 | |
| 519 | // Woops, it will not be re-installed! |
| 520 | if (List->IsFlag(Pkg,pkgOrderList::InList) == false) |
| 521 | return false; |
| 522 | |
| 523 | // Essential packages get special treatment |
| 524 | bool IsEssential = false; |
| 525 | if ((Pkg->Flags & pkgCache::Flag::Essential) != 0 || |
| 526 | (Pkg->Flags & pkgCache::Flag::Important) != 0) |
| 527 | IsEssential = true; |
| 528 | |
| 529 | /* Check for packages that are the dependents of essential packages and |
| 530 | promote them too */ |
| 531 | if (Pkg->CurrentVer != 0) |
| 532 | { |
| 533 | for (DepIterator D = Pkg.RevDependsList(); D.end() == false && |
| 534 | IsEssential == false; ++D) |
| 535 | if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends) |
| 536 | if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0 || |
| 537 | (D.ParentPkg()->Flags & pkgCache::Flag::Important) != 0) |
| 538 | IsEssential = true; |
| 539 | } |
| 540 | |
| 541 | if (IsEssential == true) |
| 542 | { |
| 543 | if (_config->FindB("APT::Force-LoopBreak",false) == false) |
| 544 | return _error->Error(_("This installation run will require temporarily " |
| 545 | "removing the essential package %s due to a " |
| 546 | "Conflicts/Pre-Depends loop. This is often bad, " |
| 547 | "but if you really want to do it, activate the " |
| 548 | "APT::Force-LoopBreak option."),Pkg.FullName().c_str()); |
| 549 | } |
| 550 | |
| 551 | bool Res = SmartRemove(Pkg); |
| 552 | if (Cache[Pkg].Delete() == false) |
| 553 | List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States); |
| 554 | |
| 555 | return Res; |
| 556 | } |
| 557 | /*}}}*/ |
| 558 | // PM::SmartRemove - Removal Helper /*{{{*/ |
| 559 | // --------------------------------------------------------------------- |
| 560 | /* */ |
| 561 | bool pkgPackageManager::SmartRemove(PkgIterator Pkg) |
| 562 | { |
| 563 | if (List->IsNow(Pkg) == false) |
| 564 | return true; |
| 565 | |
| 566 | List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States); |
| 567 | |
| 568 | return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge); |
| 569 | } |
| 570 | /*}}}*/ |
| 571 | // PM::SmartUnPack - Install helper /*{{{*/ |
| 572 | // --------------------------------------------------------------------- |
| 573 | /* This puts the system in a state where it can Unpack Pkg, if Pkg is allready |
| 574 | unpacked, or when it has been unpacked, if Immediate==true it configures it. */ |
| 575 | bool pkgPackageManager::SmartUnPack(PkgIterator Pkg) |
| 576 | { |
| 577 | return SmartUnPack(Pkg, true, 0); |
| 578 | } |
| 579 | bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int const Depth) |
| 580 | { |
| 581 | bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop); |
| 582 | |
| 583 | if (Debug) { |
| 584 | clog << OutputInDepth(Depth) << "SmartUnPack " << Pkg.FullName(); |
| 585 | VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer); |
| 586 | if (Pkg.CurrentVer() == 0) |
| 587 | clog << " (install version " << InstallVer.VerStr() << ")"; |
| 588 | else |
| 589 | clog << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")"; |
| 590 | if (PkgLoop) |
| 591 | clog << " (Only Perform PreUnpack Checks)"; |
| 592 | clog << endl; |
| 593 | } |
| 594 | |
| 595 | VerIterator const instVer = Cache[Pkg].InstVerIter(Cache); |
| 596 | |
| 597 | /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked. |
| 598 | It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should |
| 599 | avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with |
| 600 | complex dependancy structures, trying to configure some packages while breaking the loops can complicate things . |
| 601 | This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured), |
| 602 | or by the ConfigureAll call at the end of the for loop in OrderInstall. */ |
| 603 | bool Changed = false; |
| 604 | const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 500); |
| 605 | unsigned int i = 0; |
| 606 | do |
| 607 | { |
| 608 | Changed = false; |
| 609 | for (DepIterator D = instVer.DependsList(); D.end() == false; ) |
| 610 | { |
| 611 | // Compute a single dependency element (glob or) |
| 612 | pkgCache::DepIterator Start, End; |
| 613 | D.GlobOr(Start,End); |
| 614 | |
| 615 | if (End->Type == pkgCache::Dep::PreDepends) |
| 616 | { |
| 617 | bool Bad = true; |
| 618 | if (Debug) |
| 619 | clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.FullName() << std::endl; |
| 620 | |
| 621 | // Look for easy targets: packages that are already okay |
| 622 | for (DepIterator Cur = Start; Bad == true; ++Cur) |
| 623 | { |
| 624 | SPtrArray<Version *> VList = Start.AllTargets(); |
| 625 | for (Version **I = VList; *I != 0; ++I) |
| 626 | { |
| 627 | VerIterator Ver(Cache,*I); |
| 628 | PkgIterator Pkg = Ver.ParentPkg(); |
| 629 | |
| 630 | // See if the current version is ok |
| 631 | if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true && |
| 632 | Pkg.State() == PkgIterator::NeedsNothing) |
| 633 | { |
| 634 | Bad = false; |
| 635 | if (Debug) |
| 636 | clog << OutputInDepth(Depth) << "Found ok package " << Pkg.FullName() << endl; |
| 637 | break; |
| 638 | } |
| 639 | } |
| 640 | if (Cur == End) |
| 641 | break; |
| 642 | } |
| 643 | |
| 644 | // Look for something that could be configured. |
| 645 | for (DepIterator Cur = Start; Bad == true; ++Cur) |
| 646 | { |
| 647 | SPtrArray<Version *> VList = Start.AllTargets(); |
| 648 | for (Version **I = VList; *I != 0; ++I) |
| 649 | { |
| 650 | VerIterator Ver(Cache,*I); |
| 651 | PkgIterator Pkg = Ver.ParentPkg(); |
| 652 | |
| 653 | // Not the install version |
| 654 | if (Cache[Pkg].InstallVer != *I || |
| 655 | (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing)) |
| 656 | continue; |
| 657 | |
| 658 | if (List->IsFlag(Pkg,pkgOrderList::Configured)) |
| 659 | { |
| 660 | Bad = false; |
| 661 | break; |
| 662 | } |
| 663 | |
| 664 | // check if it needs unpack or if if configure is enough |
| 665 | if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false) |
| 666 | { |
| 667 | if (Debug) |
| 668 | clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << Pkg.FullName() << endl; |
| 669 | // SmartUnpack with the ImmediateFlag to ensure its really ready |
| 670 | if (SmartUnPack(Pkg, true, Depth + 1) == true) |
| 671 | { |
| 672 | Bad = false; |
| 673 | if (List->IsFlag(Pkg,pkgOrderList::Loop) == false) |
| 674 | Changed = true; |
| 675 | break; |
| 676 | } |
| 677 | } |
| 678 | else |
| 679 | { |
| 680 | if (Debug) |
| 681 | clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << Pkg.FullName() << endl; |
| 682 | if (SmartConfigure(Pkg, Depth + 1) == true) |
| 683 | { |
| 684 | Bad = false; |
| 685 | if (List->IsFlag(Pkg,pkgOrderList::Loop) == false) |
| 686 | Changed = true; |
| 687 | break; |
| 688 | } |
| 689 | } |
| 690 | } |
| 691 | } |
| 692 | |
| 693 | if (Bad == true) |
| 694 | { |
| 695 | if (Start == End) |
| 696 | return _error->Error("Couldn't configure pre-depend %s for %s, " |
| 697 | "probably a dependency cycle.", |
| 698 | End.TargetPkg().FullName().c_str(),Pkg.FullName().c_str()); |
| 699 | } |
| 700 | else |
| 701 | continue; |
| 702 | } |
| 703 | else if (End->Type == pkgCache::Dep::Conflicts || |
| 704 | End->Type == pkgCache::Dep::Obsoletes) |
| 705 | { |
| 706 | /* Look for conflicts. Two packages that are both in the install |
| 707 | state cannot conflict so we don't check.. */ |
| 708 | SPtrArray<Version *> VList = End.AllTargets(); |
| 709 | for (Version **I = VList; *I != 0; I++) |
| 710 | { |
| 711 | VerIterator Ver(Cache,*I); |
| 712 | PkgIterator ConflictPkg = Ver.ParentPkg(); |
| 713 | VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer); |
| 714 | |
| 715 | // See if the current version is conflicting |
| 716 | if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg)) |
| 717 | { |
| 718 | clog << OutputInDepth(Depth) << Pkg.FullName() << " conflicts with " << ConflictPkg.FullName() << endl; |
| 719 | /* If a loop is not present or has not yet been detected, attempt to unpack packages |
| 720 | to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */ |
| 721 | if (List->IsFlag(ConflictPkg,pkgOrderList::Loop) == false) |
| 722 | { |
| 723 | if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) |
| 724 | { |
| 725 | if (Debug) |
| 726 | clog << OutputInDepth(Depth) << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.FullName() << " to prevent conflict" << endl; |
| 727 | List->Flag(Pkg,pkgOrderList::Loop); |
| 728 | if (SmartUnPack(ConflictPkg,false, Depth + 1) == true) |
| 729 | if (List->IsFlag(ConflictPkg,pkgOrderList::Loop) == false) |
| 730 | Changed = true; |
| 731 | // Remove loop to allow it to be used later if needed |
| 732 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 733 | } |
| 734 | else if (EarlyRemove(ConflictPkg) == false) |
| 735 | return _error->Error("Internal Error, Could not early remove %s (1)",ConflictPkg.FullName().c_str()); |
| 736 | } |
| 737 | else if (List->IsFlag(ConflictPkg,pkgOrderList::Removed) == false) |
| 738 | { |
| 739 | if (Debug) |
| 740 | clog << OutputInDepth(Depth) << "Because of conficts knot, removing " << ConflictPkg.FullName() << " to conflict violation" << endl; |
| 741 | if (EarlyRemove(ConflictPkg) == false) |
| 742 | return _error->Error("Internal Error, Could not early remove %s (2)",ConflictPkg.FullName().c_str()); |
| 743 | } |
| 744 | } |
| 745 | } |
| 746 | } |
| 747 | else if (End->Type == pkgCache::Dep::DpkgBreaks) |
| 748 | { |
| 749 | SPtrArray<Version *> VList = End.AllTargets(); |
| 750 | for (Version **I = VList; *I != 0; ++I) |
| 751 | { |
| 752 | VerIterator Ver(Cache,*I); |
| 753 | PkgIterator BrokenPkg = Ver.ParentPkg(); |
| 754 | if (BrokenPkg.CurrentVer() != Ver) |
| 755 | { |
| 756 | if (Debug) |
| 757 | std::clog << OutputInDepth(Depth) << " Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl; |
| 758 | continue; |
| 759 | } |
| 760 | |
| 761 | // Check if it needs to be unpacked |
| 762 | if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false && |
| 763 | List->IsNow(BrokenPkg)) |
| 764 | { |
| 765 | if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) && PkgLoop) |
| 766 | { |
| 767 | // This dependancy has already been dealt with by another SmartUnPack on Pkg |
| 768 | break; |
| 769 | } |
| 770 | else |
| 771 | { |
| 772 | // Found a break, so see if we can unpack the package to avoid it |
| 773 | // but do not set loop if another SmartUnPack already deals with it |
| 774 | // Also, avoid it if the package we would unpack pre-depends on this one |
| 775 | VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer); |
| 776 | bool circle = false; |
| 777 | for (pkgCache::DepIterator D = InstallVer.DependsList(); D.end() == false; ++D) |
| 778 | { |
| 779 | if (D->Type != pkgCache::Dep::PreDepends) |
| 780 | continue; |
| 781 | SPtrArray<Version *> VL = D.AllTargets(); |
| 782 | for (Version **I = VL; *I != 0; ++I) |
| 783 | { |
| 784 | VerIterator V(Cache,*I); |
| 785 | PkgIterator P = V.ParentPkg(); |
| 786 | // we are checking for installation as an easy 'protection' against or-groups and (unchosen) providers |
| 787 | if (P->CurrentVer == 0 || P != Pkg || (P.CurrentVer() != V && Cache[P].InstallVer != V)) |
| 788 | continue; |
| 789 | circle = true; |
| 790 | break; |
| 791 | } |
| 792 | if (circle == true) |
| 793 | break; |
| 794 | } |
| 795 | if (circle == true) |
| 796 | { |
| 797 | if (Debug) |
| 798 | clog << OutputInDepth(Depth) << " Avoiding " << End << " avoided as " << BrokenPkg.FullName() << " has a pre-depends on " << Pkg.FullName() << std::endl; |
| 799 | continue; |
| 800 | } |
| 801 | else |
| 802 | { |
| 803 | if (Debug) |
| 804 | { |
| 805 | clog << OutputInDepth(Depth) << " Unpacking " << BrokenPkg.FullName() << " to avoid " << End; |
| 806 | if (PkgLoop == true) |
| 807 | clog << " (Looping)"; |
| 808 | clog << std::endl; |
| 809 | } |
| 810 | if (PkgLoop == false) |
| 811 | List->Flag(Pkg,pkgOrderList::Loop); |
| 812 | if (SmartUnPack(BrokenPkg, false, Depth + 1) == true) |
| 813 | { |
| 814 | if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) == false) |
| 815 | Changed = true; |
| 816 | } |
| 817 | if (PkgLoop == false) |
| 818 | List->RmFlag(Pkg,pkgOrderList::Loop); |
| 819 | } |
| 820 | } |
| 821 | } |
| 822 | // Check if a package needs to be removed |
| 823 | else if (Cache[BrokenPkg].Delete() == true && List->IsFlag(BrokenPkg,pkgOrderList::Configured) == false) |
| 824 | { |
| 825 | if (Debug) |
| 826 | clog << OutputInDepth(Depth) << " Removing " << BrokenPkg.FullName() << " to avoid " << End << endl; |
| 827 | SmartRemove(BrokenPkg); |
| 828 | } |
| 829 | } |
| 830 | } |
| 831 | } |
| 832 | if (i++ > max_loops) |
| 833 | return _error->Error("Internal error: APT::pkgPackageManager::MaxLoopCount reached in SmartConfigure for %s, aborting", Pkg.FullName().c_str()); |
| 834 | } while (Changed == true); |
| 835 | |
| 836 | // Check for reverse conflicts. |
| 837 | if (CheckRConflicts(Pkg,Pkg.RevDependsList(), |
| 838 | instVer.VerStr()) == false) |
| 839 | return false; |
| 840 | |
| 841 | for (PrvIterator P = instVer.ProvidesList(); |
| 842 | P.end() == false; ++P) |
| 843 | if (Pkg->Group != P.OwnerPkg()->Group) |
| 844 | CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion()); |
| 845 | |
| 846 | if (PkgLoop) |
| 847 | return true; |
| 848 | |
| 849 | List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States); |
| 850 | |
| 851 | if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same) |
| 852 | { |
| 853 | /* Do lockstep M-A:same unpacking in two phases: |
| 854 | First unpack all installed architectures, then the not installed. |
| 855 | This way we avoid that M-A: enabled packages are installed before |
| 856 | their older non-M-A enabled packages are replaced by newer versions */ |
| 857 | bool const installed = Pkg->CurrentVer != 0; |
| 858 | if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false) |
| 859 | return false; |
| 860 | for (PkgIterator P = Pkg.Group().PackageList(); |
| 861 | P.end() == false; P = Pkg.Group().NextPkg(P)) |
| 862 | { |
| 863 | if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true || |
| 864 | Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer && |
| 865 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)) |
| 866 | continue; |
| 867 | if (SmartUnPack(P, false, Depth + 1) == false) |
| 868 | return false; |
| 869 | } |
| 870 | if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false) |
| 871 | return false; |
| 872 | for (PkgIterator P = Pkg.Group().PackageList(); |
| 873 | P.end() == false; P = Pkg.Group().NextPkg(P)) |
| 874 | { |
| 875 | if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true || |
| 876 | Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer && |
| 877 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)) |
| 878 | continue; |
| 879 | if (SmartUnPack(P, false, Depth + 1) == false) |
| 880 | return false; |
| 881 | } |
| 882 | } |
| 883 | // packages which are already unpacked don't need to be unpacked again |
| 884 | else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false) |
| 885 | return false; |
| 886 | |
| 887 | if (Immediate == true) { |
| 888 | // Perform immedate configuration of the package. |
| 889 | if (SmartConfigure(Pkg, Depth + 1) == false) |
| 890 | _error->Warning(_("Could not perform immediate configuration on '%s'. " |
| 891 | "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2); |
| 892 | } |
| 893 | |
| 894 | return true; |
| 895 | } |
| 896 | /*}}}*/ |
| 897 | // PM::OrderInstall - Installation ordering routine /*{{{*/ |
| 898 | // --------------------------------------------------------------------- |
| 899 | /* */ |
| 900 | pkgPackageManager::OrderResult pkgPackageManager::OrderInstall() |
| 901 | { |
| 902 | if (CreateOrderList() == false) |
| 903 | return Failed; |
| 904 | |
| 905 | Reset(); |
| 906 | |
| 907 | if (Debug == true) |
| 908 | clog << "Beginning to order" << endl; |
| 909 | |
| 910 | bool const ordering = |
| 911 | _config->FindB("PackageManager::UnpackAll",true) ? |
| 912 | List->OrderUnpack(FileNames) : List->OrderCritical(); |
| 913 | if (ordering == false) |
| 914 | { |
| 915 | _error->Error("Internal ordering error"); |
| 916 | return Failed; |
| 917 | } |
| 918 | |
| 919 | if (Debug == true) |
| 920 | clog << "Done ordering" << endl; |
| 921 | |
| 922 | bool DoneSomething = false; |
| 923 | for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I) |
| 924 | { |
| 925 | PkgIterator Pkg(Cache,*I); |
| 926 | |
| 927 | if (List->IsNow(Pkg) == false) |
| 928 | { |
| 929 | if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) { |
| 930 | if (SmartConfigure(Pkg, 0) == false && Debug) |
| 931 | _error->Warning("Internal Error, Could not configure %s",Pkg.FullName().c_str()); |
| 932 | // FIXME: The above warning message might need changing |
| 933 | } else { |
| 934 | if (Debug == true) |
| 935 | clog << "Skipping already done " << Pkg.FullName() << endl; |
| 936 | } |
| 937 | continue; |
| 938 | |
| 939 | } |
| 940 | |
| 941 | if (List->IsMissing(Pkg) == true) |
| 942 | { |
| 943 | if (Debug == true) |
| 944 | clog << "Sequence completed at " << Pkg.FullName() << endl; |
| 945 | if (DoneSomething == false) |
| 946 | { |
| 947 | _error->Error("Internal Error, ordering was unable to handle the media swap"); |
| 948 | return Failed; |
| 949 | } |
| 950 | return Incomplete; |
| 951 | } |
| 952 | |
| 953 | // Sanity check |
| 954 | if (Cache[Pkg].Keep() == true && |
| 955 | Pkg.State() == pkgCache::PkgIterator::NeedsNothing && |
| 956 | (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall) |
| 957 | { |
| 958 | _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.FullName().c_str()); |
| 959 | return Failed; |
| 960 | } |
| 961 | |
| 962 | // Perform a delete or an install |
| 963 | if (Cache[Pkg].Delete() == true) |
| 964 | { |
| 965 | if (SmartRemove(Pkg) == false) |
| 966 | return Failed; |
| 967 | } |
| 968 | else |
| 969 | if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false) |
| 970 | return Failed; |
| 971 | DoneSomething = true; |
| 972 | |
| 973 | if (ImmConfigureAll) { |
| 974 | /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the |
| 975 | "PreUnpack Checks" section */ |
| 976 | if (!ConfigureAll()) |
| 977 | return Failed; |
| 978 | } |
| 979 | } |
| 980 | |
| 981 | // Final run through the configure phase |
| 982 | if (ConfigureAll() == false) |
| 983 | return Failed; |
| 984 | |
| 985 | // Sanity check |
| 986 | for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I) |
| 987 | { |
| 988 | if (List->IsFlag(*I,pkgOrderList::Configured) == false) |
| 989 | { |
| 990 | _error->Error("Internal error, packages left unconfigured. %s", |
| 991 | PkgIterator(Cache,*I).FullName().c_str()); |
| 992 | return Failed; |
| 993 | } |
| 994 | } |
| 995 | |
| 996 | return Completed; |
| 997 | } |
| 998 | /*}}}*/ |
| 999 | // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/ |
| 1000 | // --------------------------------------------------------------------- |
| 1001 | pkgPackageManager::OrderResult |
| 1002 | pkgPackageManager::DoInstallPostFork(int statusFd) |
| 1003 | { |
| 1004 | if(statusFd > 0) |
| 1005 | // FIXME: use SetCloseExec here once it taught about throwing |
| 1006 | // exceptions instead of doing _exit(100) on failure |
| 1007 | fcntl(statusFd,F_SETFD,FD_CLOEXEC); |
| 1008 | bool goResult = Go(statusFd); |
| 1009 | if(goResult == false) |
| 1010 | return Failed; |
| 1011 | |
| 1012 | return Res; |
| 1013 | }; |
| 1014 | |
| 1015 | // PM::DoInstall - Does the installation /*{{{*/ |
| 1016 | // --------------------------------------------------------------------- |
| 1017 | /* This uses the filenames in FileNames and the information in the |
| 1018 | DepCache to perform the installation of packages.*/ |
| 1019 | pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd) |
| 1020 | { |
| 1021 | if(DoInstallPreFork() == Failed) |
| 1022 | return Failed; |
| 1023 | |
| 1024 | return DoInstallPostFork(statusFd); |
| 1025 | } |
| 1026 | /*}}}*/ |