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