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