]> git.saurik.com Git - apt.git/blame - apt-pkg/packagemanager.cc
fix compiler warning: suggest parentheses around && within || in cachedb
[apt.git] / apt-pkg / packagemanager.cc
CommitLineData
6c139d6e
AL
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
b9c0654c 3// $Id: packagemanager.cc,v 1.30 2003/04/27 03:04:15 doogie Exp $
6c139d6e
AL
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 /*{{{*/
094a497d
AL
16#include <apt-pkg/packagemanager.h>
17#include <apt-pkg/orderlist.h>
18#include <apt-pkg/depcache.h>
19#include <apt-pkg/error.h>
20#include <apt-pkg/version.h>
03e39e59 21#include <apt-pkg/acquire-item.h>
30e1eab5
AL
22#include <apt-pkg/algorithms.h>
23#include <apt-pkg/configuration.h>
b2e465d6
AL
24#include <apt-pkg/sptr.h>
25
26#include <apti18n.h>
5819a761 27#include <iostream>
1d6386f3 28#include <fcntl.h>
92fcbfc1 29 /*}}}*/
5819a761
AL
30using namespace std;
31
6c139d6e
AL
32// PM::PackageManager - Constructor /*{{{*/
33// ---------------------------------------------------------------------
34/* */
b2e465d6 35pkgPackageManager::pkgPackageManager(pkgDepCache *pCache) : Cache(*pCache)
6c139d6e
AL
36{
37 FileNames = new string[Cache.Head().PackageCount];
38 List = 0;
30e1eab5 39 Debug = _config->FindB("Debug::pkgPackageManager",false);
6c139d6e
AL
40}
41 /*}}}*/
42// PM::PackageManager - Destructor /*{{{*/
43// ---------------------------------------------------------------------
44/* */
45pkgPackageManager::~pkgPackageManager()
46{
47 delete List;
48 delete [] FileNames;
49}
50 /*}}}*/
03e39e59
AL
51// PM::GetArchives - Queue the archives for download /*{{{*/
52// ---------------------------------------------------------------------
53/* */
54bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources,
55 pkgRecords *Recs)
56{
7a1b1f8b
AL
57 if (CreateOrderList() == false)
58 return false;
59
5e312de7
DK
60 bool const ordering =
61 _config->FindB("PackageManager::UnpackAll",true) ?
62 List->OrderUnpack() : List->OrderCritical();
63 if (ordering == false)
7a1b1f8b
AL
64 return _error->Error("Internal ordering error");
65
66 for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
67 {
68 PkgIterator Pkg(Cache,*I);
281daf46
AL
69 FileNames[Pkg->ID] = string();
70
7a1b1f8b
AL
71 // Skip packages to erase
72 if (Cache[Pkg].Delete() == true)
03e39e59 73 continue;
d38b7b3d
AL
74
75 // Skip Packages that need configure only.
9dbb421f
AL
76 if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
77 Cache[Pkg].Keep() == true)
d38b7b3d 78 continue;
281daf46
AL
79
80 // Skip already processed packages
81 if (List->IsNow(Pkg) == false)
82 continue;
83
7a1b1f8b
AL
84 new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
85 FileNames[Pkg->ID]);
03e39e59 86 }
7a1b1f8b 87
03e39e59
AL
88 return true;
89}
90 /*}}}*/
6c139d6e
AL
91// PM::FixMissing - Keep all missing packages /*{{{*/
92// ---------------------------------------------------------------------
93/* This is called to correct the installation when packages could not
94 be downloaded. */
95bool pkgPackageManager::FixMissing()
bdae53f1 96{
e6756cde 97 pkgDepCache::ActionGroup group(Cache);
b2e465d6 98 pkgProblemResolver Resolve(&Cache);
2fd65468 99 List->SetFileList(FileNames);
e6756cde 100
9dbb421f 101 bool Bad = false;
6c139d6e
AL
102 for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
103 {
2fd65468 104 if (List->IsMissing(I) == false)
9dbb421f 105 continue;
2fd65468 106
9dbb421f
AL
107 // Okay, this file is missing and we need it. Mark it for keep
108 Bad = true;
74a05226 109 Cache.MarkKeep(I, false, false);
6c139d6e 110 }
bdae53f1
AL
111
112 // We have to empty the list otherwise it will not have the new changes
113 delete List;
114 List = 0;
6c139d6e 115
9dbb421f
AL
116 if (Bad == false)
117 return true;
118
6c139d6e 119 // Now downgrade everything that is broken
30e1eab5 120 return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;
6c139d6e
AL
121}
122 /*}}}*/
3a6d37fd
MV
123// PM::ImmediateAdd - Add the immediate flag recursivly /*{{{*/
124// ---------------------------------------------------------------------
125/* This adds the immediate flag to the pkg and recursively to the
126 dependendies
127 */
d183f850 128void pkgPackageManager::ImmediateAdd(PkgIterator I, bool UseInstallVer, unsigned const int &Depth)
3a6d37fd
MV
129{
130 DepIterator D;
131
132 if(UseInstallVer)
133 {
134 if(Cache[I].InstallVer == 0)
135 return;
136 D = Cache[I].InstVerIter(Cache).DependsList();
137 } else {
138 if (I->CurrentVer == 0)
139 return;
140 D = I.CurrentVer().DependsList();
141 }
142
143 for ( /* nothing */ ; D.end() == false; D++)
144 if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
145 {
146 if(!List->IsFlag(D.TargetPkg(), pkgOrderList::Immediate))
147 {
148 if(Debug)
d183f850 149 clog << OutputInDepth(Depth) << "ImmediateAdd(): Adding Immediate flag to " << D.TargetPkg() << " cause of " << D.DepType() << " " << I.Name() << endl;
3a6d37fd 150 List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
d183f850 151 ImmediateAdd(D.TargetPkg(), UseInstallVer, Depth + 1);
3a6d37fd
MV
152 }
153 }
154 return;
155}
156 /*}}}*/
7a1b1f8b
AL
157// PM::CreateOrderList - Create the ordering class /*{{{*/
158// ---------------------------------------------------------------------
159/* This populates the ordering list with all the packages that are
160 going to change. */
161bool pkgPackageManager::CreateOrderList()
162{
281daf46
AL
163 if (List != 0)
164 return true;
165
7a1b1f8b 166 delete List;
b2e465d6 167 List = new pkgOrderList(&Cache);
7a1b1f8b 168
5e312de7 169 static bool const NoImmConfigure = !_config->FindB("APT::Immediate-Configure",true);
079cc404 170
7a1b1f8b
AL
171 // Generate the list of affected packages and sort it
172 for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
173 {
e7b470ee
AL
174 // Ignore no-version packages
175 if (I->VersionList == 0)
176 continue;
177
138d4b3d
AL
178 // Mark the package and its dependends for immediate configuration
179 if (((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential ||
180 (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) &&
079cc404 181 NoImmConfigure == false)
7a1b1f8b 182 {
3a6d37fd
MV
183 if(Debug)
184 clog << "CreateOrderList(): Adding Immediate flag for " << I.Name() << endl;
7a1b1f8b 185 List->Flag(I,pkgOrderList::Immediate);
3a6d37fd
MV
186
187 // Look for other install packages to make immediate configurea
188 ImmediateAdd(I, true);
d38b7b3d
AL
189
190 // And again with the current version.
3a6d37fd 191 ImmediateAdd(I, false);
7a1b1f8b
AL
192 }
193
194 // Not interesting
195 if ((Cache[I].Keep() == true ||
196 Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
d556d1a1 197 I.State() == pkgCache::PkgIterator::NeedsNothing &&
d0c59649 198 (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall &&
d556d1a1
AL
199 (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
200 (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
7a1b1f8b
AL
201 continue;
202
203 // Append it to the list
138d4b3d 204 List->push_back(I);
7a1b1f8b
AL
205 }
206
207 return true;
208}
209 /*}}}*/
6c139d6e
AL
210// PM::DepAlwaysTrue - Returns true if this dep is irrelevent /*{{{*/
211// ---------------------------------------------------------------------
212/* The restriction on provides is to eliminate the case when provides
213 are transitioning between valid states [ie exim to smail] */
214bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
215{
216 if (D.TargetPkg()->ProvidesList != 0)
217 return false;
218
219 if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
220 (Cache[D] & pkgDepCache::DepNow) != 0)
221 return true;
222 return false;
223}
224 /*}}}*/
225// PM::CheckRConflicts - Look for reverse conflicts /*{{{*/
226// ---------------------------------------------------------------------
227/* This looks over the reverses for a conflicts line that needs early
228 removal. */
229bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
230 const char *Ver)
231{
232 for (;D.end() == false; D++)
233 {
b2e465d6
AL
234 if (D->Type != pkgCache::Dep::Conflicts &&
235 D->Type != pkgCache::Dep::Obsoletes)
6c139d6e 236 continue;
5af32db6
AL
237
238 // The package hasnt been changed
239 if (List->IsNow(Pkg) == false)
240 continue;
6c139d6e 241
5af32db6
AL
242 // Ignore self conflicts, ignore conflicts from irrelevent versions
243 if (D.ParentPkg() == Pkg || D.ParentVer() != D.ParentPkg().CurrentVer())
6c139d6e
AL
244 continue;
245
b2e465d6 246 if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
6c139d6e 247 continue;
b2e465d6 248
6c139d6e 249 if (EarlyRemove(D.ParentPkg()) == false)
5af32db6
AL
250 return _error->Error("Reverse conflicts early remove for package '%s' failed",
251 Pkg.Name());
252 }
6c139d6e
AL
253 return true;
254}
255 /*}}}*/
256// PM::ConfigureAll - Run the all out configuration /*{{{*/
257// ---------------------------------------------------------------------
258/* This configures every package. It is assumed they are all unpacked and
259 that the final configuration is valid. */
260bool pkgPackageManager::ConfigureAll()
261{
b2e465d6 262 pkgOrderList OList(&Cache);
6c139d6e
AL
263
264 // Populate the order list
265 for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
266 if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
267 pkgOrderList::UnPacked) == true)
268 OList.push_back(*I);
269
270 if (OList.OrderConfigure() == false)
271 return false;
5e312de7
DK
272
273 std::string const conf = _config->Find("PackageManager::Configure","all");
274 bool const ConfigurePkgs = (conf == "all");
275
6c139d6e
AL
276 // Perform the configuring
277 for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
278 {
279 PkgIterator Pkg(Cache,*I);
280
5e312de7 281 if (ConfigurePkgs == true && Configure(Pkg) == false)
6c139d6e
AL
282 return false;
283
284 List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
285 }
286
287 return true;
288}
289 /*}}}*/
290// PM::SmartConfigure - Perform immediate configuration of the pkg /*{{{*/
291// ---------------------------------------------------------------------
292/* This routine scheduals the configuration of the given package and all
293 of it's dependents. */
294bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
295{
b2e465d6 296 pkgOrderList OList(&Cache);
6c139d6e
AL
297
298 if (DepAdd(OList,Pkg) == false)
299 return false;
5e312de7
DK
300
301 static std::string const conf = _config->Find("PackageManager::Configure","all");
302 static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
303
304 if (ConfigurePkgs == true)
305 if (OList.OrderConfigure() == false)
306 return false;
307
6c139d6e
AL
308 // Perform the configuring
309 for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
310 {
311 PkgIterator Pkg(Cache,*I);
312
5e312de7 313 if (ConfigurePkgs == true && Configure(Pkg) == false)
6c139d6e
AL
314 return false;
315
316 List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
317 }
318
319 // Sanity Check
320 if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
321 return _error->Error("Internal error, could not immediate configure %s",Pkg.Name());
322
323 return true;
324}
325 /*}}}*/
326// PM::DepAdd - Add all dependents to the oder list /*{{{*/
327// ---------------------------------------------------------------------
328/* This recursively adds all dependents to the order list */
329bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
330{
331 if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
332 return true;
333 if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
334 return true;
335 if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
336 return false;
b2e465d6 337
6c139d6e
AL
338 // Put the package on the list
339 OList.push_back(Pkg);
340 OList.Flag(Pkg,pkgOrderList::Added);
341 Depth++;
342
343 // Check the dependencies to see if they are all satisfied.
344 bool Bad = false;
345 for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
346 {
b50b2c97 347 if (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends)
6c139d6e
AL
348 {
349 D++;
350 continue;
351 }
352
353 // Grok or groups
354 Bad = true;
355 for (bool LastOR = true; D.end() == false && LastOR == true; D++)
356 {
b50b2c97 357 LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
6c139d6e
AL
358
359 if (Bad == false)
360 continue;
361
b2e465d6 362 SPtrArray<Version *> VList = D.AllTargets();
6c139d6e
AL
363 for (Version **I = VList; *I != 0 && Bad == true; I++)
364 {
365 VerIterator Ver(Cache,*I);
366 PkgIterator Pkg = Ver.ParentPkg();
367
368 // See if the current version is ok
369 if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
370 Pkg.State() == PkgIterator::NeedsNothing)
371 {
372 Bad = false;
373 continue;
374 }
375
376 // Not the install version
377 if (Cache[Pkg].InstallVer != *I ||
378 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
379 continue;
b2e465d6 380
6c139d6e
AL
381 if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
382 Bad = !DepAdd(OList,Pkg,Depth);
383 if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
384 Bad = false;
385 }
6c139d6e
AL
386 }
387
388 if (Bad == true)
389 {
390 OList.Flag(Pkg,0,pkgOrderList::Added);
391 OList.pop_back();
392 Depth--;
393 return false;
394 }
395 }
396
397 Depth--;
398 return true;
399}
400 /*}}}*/
401// PM::EarlyRemove - Perform removal of packages before their time /*{{{*/
402// ---------------------------------------------------------------------
403/* This is called to deal with conflicts arising from unpacking */
404bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
405{
406 if (List->IsNow(Pkg) == false)
407 return true;
408
409 // Already removed it
410 if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
411 return true;
412
413 // Woops, it will not be re-installed!
414 if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
415 return false;
9d4c8f67
AL
416
417 // Essential packages get special treatment
5af32db6 418 bool IsEssential = false;
9d4c8f67 419 if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
5af32db6
AL
420 IsEssential = true;
421
422 /* Check for packages that are the dependents of essential packages and
423 promote them too */
424 if (Pkg->CurrentVer != 0)
425 {
426 for (DepIterator D = Pkg.RevDependsList(); D.end() == false &&
427 IsEssential == false; D++)
428 if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
429 if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0)
430 IsEssential = true;
431 }
432
433 if (IsEssential == true)
9d4c8f67
AL
434 {
435 if (_config->FindB("APT::Force-LoopBreak",false) == false)
b2e465d6
AL
436 return _error->Error(_("This installation run will require temporarily "
437 "removing the essential package %s due to a "
438 "Conflicts/Pre-Depends loop. This is often bad, "
439 "but if you really want to do it, activate the "
440 "APT::Force-LoopBreak option."),Pkg.Name());
9d4c8f67 441 }
6c139d6e
AL
442
443 bool Res = SmartRemove(Pkg);
444 if (Cache[Pkg].Delete() == false)
445 List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
446
447 return Res;
448}
449 /*}}}*/
450// PM::SmartRemove - Removal Helper /*{{{*/
451// ---------------------------------------------------------------------
452/* */
453bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
454{
455 if (List->IsNow(Pkg) == false)
456 return true;
457
458 List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
fc4b5c9f 459 return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
6c139d6e
AL
460}
461 /*}}}*/
462// PM::SmartUnPack - Install helper /*{{{*/
463// ---------------------------------------------------------------------
464/* This performs the task of handling pre-depends. */
465bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
466{
467 // Check if it is already unpacked
468 if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
469 Cache[Pkg].Keep() == true)
470 {
471 List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
472 if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
473 if (SmartConfigure(Pkg) == false)
f66a64c2
DK
474 return _error->Error(_("Could not perform immediate configuration for on already unpacked %s."
475 "Please see man 5 apt.conf under APT::Immediate-Configure for details."),Pkg.Name());
6c139d6e
AL
476 return true;
477 }
981d20eb 478
6c139d6e
AL
479 /* See if this packages install version has any predependencies
480 that are not met by 'now' packages. */
481 for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList();
421c8d10 482 D.end() == false; )
6c139d6e 483 {
421c8d10
AL
484 // Compute a single dependency element (glob or)
485 pkgCache::DepIterator Start;
486 pkgCache::DepIterator End;
487 D.GlobOr(Start,End);
488
489 while (End->Type == pkgCache::Dep::PreDepends)
6c139d6e
AL
490 {
491 // Look for possible ok targets.
b2e465d6 492 SPtrArray<Version *> VList = Start.AllTargets();
6c139d6e
AL
493 bool Bad = true;
494 for (Version **I = VList; *I != 0 && Bad == true; I++)
495 {
496 VerIterator Ver(Cache,*I);
497 PkgIterator Pkg = Ver.ParentPkg();
498
499 // See if the current version is ok
500 if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
501 Pkg.State() == PkgIterator::NeedsNothing)
502 {
503 Bad = false;
504 continue;
505 }
506 }
507
508 // Look for something that could be configured.
509 for (Version **I = VList; *I != 0 && Bad == true; I++)
510 {
511 VerIterator Ver(Cache,*I);
512 PkgIterator Pkg = Ver.ParentPkg();
513
514 // Not the install version
515 if (Cache[Pkg].InstallVer != *I ||
516 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
517 continue;
518
519 Bad = !SmartConfigure(Pkg);
520 }
1006601e 521
421c8d10 522 /* If this or element did not match then continue on to the
1006601e 523 next or element until a matching element is found */
421c8d10 524 if (Bad == true)
1006601e
AL
525 {
526 // This triggers if someone make a pre-depends/depend loop.
421c8d10 527 if (Start == End)
1006601e
AL
528 return _error->Error("Couldn't configure pre-depend %s for %s, "
529 "probably a dependency cycle.",
530 End.TargetPkg().Name(),Pkg.Name());
421c8d10
AL
531 Start++;
532 }
533 else
534 break;
6c139d6e
AL
535 }
536
b2e465d6
AL
537 if (End->Type == pkgCache::Dep::Conflicts ||
538 End->Type == pkgCache::Dep::Obsoletes)
6c139d6e
AL
539 {
540 /* Look for conflicts. Two packages that are both in the install
541 state cannot conflict so we don't check.. */
b2e465d6 542 SPtrArray<Version *> VList = End.AllTargets();
6c139d6e
AL
543 for (Version **I = VList; *I != 0; I++)
544 {
545 VerIterator Ver(Cache,*I);
546 PkgIterator Pkg = Ver.ParentPkg();
547
548 // See if the current version is conflicting
549 if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true)
550 {
551 if (EarlyRemove(Pkg) == false)
552 return _error->Error("Internal Error, Could not early remove %s",Pkg.Name());
553 }
554 }
6c139d6e
AL
555 }
556 }
557
558 // Check for reverse conflicts.
5af32db6
AL
559 if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
560 Cache[Pkg].InstVerIter(Cache).VerStr()) == false)
561 return false;
562
6c139d6e
AL
563 for (PrvIterator P = Cache[Pkg].InstVerIter(Cache).ProvidesList();
564 P.end() == false; P++)
565 CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
566
567 if (Install(Pkg,FileNames[Pkg->ID]) == false)
568 return false;
569
570 List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
571
572 // Perform immedate configuration of the package.
573 if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
574 if (SmartConfigure(Pkg) == false)
f66a64c2
DK
575 return _error->Error(_("Could not perform immediate configuration on %s."
576 "Please see man 5 apt.conf under APT::Immediate-Configure for details."),Pkg.Name());
6c139d6e
AL
577
578 return true;
579}
580 /*}}}*/
581// PM::OrderInstall - Installation ordering routine /*{{{*/
582// ---------------------------------------------------------------------
583/* */
281daf46 584pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
6c139d6e 585{
7a1b1f8b 586 if (CreateOrderList() == false)
281daf46
AL
587 return Failed;
588
589 Reset();
6c139d6e 590
30e1eab5 591 if (Debug == true)
5e312de7 592 clog << "Beginning to order" << endl;
6c139d6e 593
5e312de7
DK
594 bool const ordering =
595 _config->FindB("PackageManager::UnpackAll",true) ?
596 List->OrderUnpack(FileNames) : List->OrderCritical();
597 if (ordering == false)
281daf46
AL
598 {
599 _error->Error("Internal ordering error");
600 return Failed;
601 }
602
30e1eab5
AL
603 if (Debug == true)
604 clog << "Done ordering" << endl;
605
281daf46 606 bool DoneSomething = false;
6c139d6e
AL
607 for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
608 {
609 PkgIterator Pkg(Cache,*I);
281daf46
AL
610
611 if (List->IsNow(Pkg) == false)
612 {
613 if (Debug == true)
614 clog << "Skipping already done " << Pkg.Name() << endl;
615 continue;
616 }
617
2fd65468 618 if (List->IsMissing(Pkg) == true)
281daf46
AL
619 {
620 if (Debug == true)
a3eaf954 621 clog << "Sequence completed at " << Pkg.Name() << endl;
281daf46
AL
622 if (DoneSomething == false)
623 {
624 _error->Error("Internal Error, ordering was unable to handle the media swap");
625 return Failed;
626 }
627 return Incomplete;
628 }
6c139d6e
AL
629
630 // Sanity check
d0c59649
AL
631 if (Cache[Pkg].Keep() == true &&
632 Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
633 (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
281daf46 634 {
71a174ee 635 _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
281daf46
AL
636 return Failed;
637 }
6c139d6e
AL
638
639 // Perform a delete or an install
640 if (Cache[Pkg].Delete() == true)
641 {
642 if (SmartRemove(Pkg) == false)
281daf46 643 return Failed;
6c139d6e
AL
644 }
645 else
646 if (SmartUnPack(Pkg) == false)
281daf46
AL
647 return Failed;
648 DoneSomething = true;
6c139d6e 649 }
5e312de7 650
6c139d6e
AL
651 // Final run through the configure phase
652 if (ConfigureAll() == false)
281daf46 653 return Failed;
6c139d6e
AL
654
655 // Sanity check
656 for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
281daf46 657 {
6c139d6e 658 if (List->IsFlag(*I,pkgOrderList::Configured) == false)
281daf46
AL
659 {
660 _error->Error("Internal error, packages left unconfigured. %s",
661 PkgIterator(Cache,*I).Name());
662 return Failed;
663 }
664 }
665
666 return Completed;
6c139d6e
AL
667}
668 /*}}}*/
1d6386f3
MV
669// PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
670// ---------------------------------------------------------------------
671pkgPackageManager::OrderResult
672pkgPackageManager::DoInstallPostFork(int statusFd)
673{
674 if(statusFd > 0)
675 // FIXME: use SetCloseExec here once it taught about throwing
676 // exceptions instead of doing _exit(100) on failure
677 fcntl(statusFd,F_SETFD,FD_CLOEXEC);
678 bool goResult = Go(statusFd);
679 if(goResult == false)
680 return Failed;
681
1d6386f3
MV
682 return Res;
683};
684
2a7e07c7
MV
685// PM::DoInstall - Does the installation /*{{{*/
686// ---------------------------------------------------------------------
687/* This uses the filenames in FileNames and the information in the
688 DepCache to perform the installation of packages.*/
689pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
690{
691 if(DoInstallPreFork() == Failed)
692 return Failed;
693
7230ad48 694 return DoInstallPostFork(statusFd);
2a7e07c7
MV
695}
696 /*}}}*/