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