1 // -*- mode: cpp; mode: fold -*-
3 // $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
4 /* ######################################################################
6 apt-get - Cover for dpkg
8 This is an allout cover for dpkg implementing a safer front end. It is
9 based largely on libapt-pkg.
11 The syntax is different,
12 apt-get [opt] command [things]
14 update - Resyncronize the package files from their sources
15 upgrade - Smart-Download the newest versions of all packages
16 dselect-upgrade - Follows dselect's changes to the Status: field
17 and installes new and removes old packages
18 dist-upgrade - Powerfull upgrader designed to handle the issues with
20 install - Download and install a given package (by name, not by .deb)
21 check - Update the package cache and check for broken packages
22 clean - Erase the .debs downloaded to /var/cache/apt/archives and
25 ##################################################################### */
27 // Include Files /*{{{*/
28 #include <apt-pkg/error.h>
29 #include <apt-pkg/cmndline.h>
30 #include <apt-pkg/init.h>
31 #include <apt-pkg/depcache.h>
32 #include <apt-pkg/sourcelist.h>
33 #include <apt-pkg/algorithms.h>
34 #include <apt-pkg/acquire-item.h>
35 #include <apt-pkg/strutl.h>
36 #include <apt-pkg/clean.h>
37 #include <apt-pkg/srcrecords.h>
38 #include <apt-pkg/version.h>
39 #include <apt-pkg/cachefile.h>
40 #include <apt-pkg/sptr.h>
41 #include <apt-pkg/md5.h>
42 #include <apt-pkg/versionmatch.h>
47 #include "acqprogress.h"
54 #include <sys/ioctl.h>
56 #include <sys/statfs.h>
57 #include <sys/statvfs.h>
67 #define RAMFS_MAGIC 0x858458f6
74 ofstream
devnull("/dev/null");
75 unsigned int ScreenWidth
= 80 - 1; /* - 1 for the cursor */
77 // class CacheFile - Cover class for some dependency cache functions /*{{{*/
78 // ---------------------------------------------------------------------
80 class CacheFile
: public pkgCacheFile
82 static pkgCache
*SortCache
;
83 static int NameComp(const void *a
,const void *b
);
86 pkgCache::Package
**List
;
89 bool CheckDeps(bool AllowBroken
= false);
90 bool BuildCaches(bool WithLock
= true)
92 OpTextProgress
Prog(*_config
);
93 if (pkgCacheFile::BuildCaches(Prog
,WithLock
) == false)
97 bool Open(bool WithLock
= true)
99 OpTextProgress
Prog(*_config
);
100 if (pkgCacheFile::Open(Prog
,WithLock
) == false)
106 bool OpenForInstall()
108 if (_config
->FindB("APT::Get::Print-URIs") == true)
113 CacheFile() : List(0) {};
120 // YnPrompt - Yes No Prompt. /*{{{*/
121 // ---------------------------------------------------------------------
122 /* Returns true on a Yes.*/
123 bool YnPrompt(bool Default
=true)
125 if (_config
->FindB("APT::Get::Assume-Yes",false) == true)
127 c1out
<< _("Y") << endl
;
131 char response
[1024] = "";
132 cin
.getline(response
, sizeof(response
));
137 if (strlen(response
) == 0)
143 Res
= regcomp(&Pattern
, nl_langinfo(YESEXPR
),
144 REG_EXTENDED
|REG_ICASE
|REG_NOSUB
);
148 regerror(Res
,&Pattern
,Error
,sizeof(Error
));
149 return _error
->Error(_("Regex compilation error - %s"),Error
);
152 Res
= regexec(&Pattern
, response
, 0, NULL
, 0);
158 // AnalPrompt - Annoying Yes No Prompt. /*{{{*/
159 // ---------------------------------------------------------------------
160 /* Returns true on a Yes.*/
161 bool AnalPrompt(const char *Text
)
164 cin
.getline(Buf
,sizeof(Buf
));
165 if (strcmp(Buf
,Text
) == 0)
170 // ShowList - Show a list /*{{{*/
171 // ---------------------------------------------------------------------
172 /* This prints out a string of space separated words with a title and
173 a two space indent line wraped to the current screen width. */
174 bool ShowList(ostream
&out
,string Title
,string List
,string VersionsList
)
176 if (List
.empty() == true)
178 // trim trailing space
179 int NonSpace
= List
.find_last_not_of(' ');
182 List
= List
.erase(NonSpace
+ 1);
183 if (List
.empty() == true)
187 // Acount for the leading space
188 int ScreenWidth
= ::ScreenWidth
- 3;
190 out
<< Title
<< endl
;
191 string::size_type Start
= 0;
192 string::size_type VersionsStart
= 0;
193 while (Start
< List
.size())
195 if(_config
->FindB("APT::Get::Show-Versions",false) == true &&
196 VersionsList
.size() > 0) {
197 string::size_type End
;
198 string::size_type VersionsEnd
;
200 End
= List
.find(' ',Start
);
201 VersionsEnd
= VersionsList
.find('\n', VersionsStart
);
203 out
<< " " << string(List
,Start
,End
- Start
) << " (" <<
204 string(VersionsList
,VersionsStart
,VersionsEnd
- VersionsStart
) <<
207 if (End
== string::npos
|| End
< Start
)
208 End
= Start
+ ScreenWidth
;
211 VersionsStart
= VersionsEnd
+ 1;
213 string::size_type End
;
215 if (Start
+ ScreenWidth
>= List
.size())
218 End
= List
.rfind(' ',Start
+ScreenWidth
);
220 if (End
== string::npos
|| End
< Start
)
221 End
= Start
+ ScreenWidth
;
222 out
<< " " << string(List
,Start
,End
- Start
) << endl
;
230 // ShowBroken - Debugging aide /*{{{*/
231 // ---------------------------------------------------------------------
232 /* This prints out the names of all the packages that are broken along
233 with the name of each each broken dependency and a quite version
236 The output looks like:
237 The following packages have unmet dependencies:
238 exim: Depends: libc6 (>= 2.1.94) but 2.1.3-10 is to be installed
239 Depends: libldap2 (>= 2.0.2-2) but it is not going to be installed
240 Depends: libsasl7 but it is not going to be installed
242 void ShowBroken(ostream
&out
,CacheFile
&Cache
,bool Now
)
244 out
<< _("The following packages have unmet dependencies:") << endl
;
245 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
247 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
251 if (Cache
[I
].NowBroken() == false)
256 if (Cache
[I
].InstBroken() == false)
260 // Print out each package and the failed dependencies
261 out
<< " " << I
.FullName(true) << " :";
262 unsigned const Indent
= I
.FullName(true).size() + 3;
264 pkgCache::VerIterator Ver
;
267 Ver
= I
.CurrentVer();
269 Ver
= Cache
[I
].InstVerIter(Cache
);
271 if (Ver
.end() == true)
277 for (pkgCache::DepIterator D
= Ver
.DependsList(); D
.end() == false;)
279 // Compute a single dependency element (glob or)
280 pkgCache::DepIterator Start
;
281 pkgCache::DepIterator End
;
282 D
.GlobOr(Start
,End
); // advances D
284 if (Cache
->IsImportantDep(End
) == false)
289 if ((Cache
[End
] & pkgDepCache::DepGNow
) == pkgDepCache::DepGNow
)
294 if ((Cache
[End
] & pkgDepCache::DepGInstall
) == pkgDepCache::DepGInstall
)
302 for (unsigned J
= 0; J
!= Indent
; J
++)
306 if (FirstOr
== false)
308 for (unsigned J
= 0; J
!= strlen(End
.DepType()) + 3; J
++)
312 out
<< ' ' << End
.DepType() << ": ";
315 out
<< Start
.TargetPkg().FullName(true);
317 // Show a quick summary of the version requirements
318 if (Start
.TargetVer() != 0)
319 out
<< " (" << Start
.CompType() << " " << Start
.TargetVer() << ")";
321 /* Show a summary of the target package if possible. In the case
322 of virtual packages we show nothing */
323 pkgCache::PkgIterator Targ
= Start
.TargetPkg();
324 if (Targ
->ProvidesList
== 0)
327 pkgCache::VerIterator Ver
= Cache
[Targ
].InstVerIter(Cache
);
329 Ver
= Targ
.CurrentVer();
331 if (Ver
.end() == false)
334 ioprintf(out
,_("but %s is installed"),Ver
.VerStr());
336 ioprintf(out
,_("but %s is to be installed"),Ver
.VerStr());
340 if (Cache
[Targ
].CandidateVerIter(Cache
).end() == true)
342 if (Targ
->ProvidesList
== 0)
343 out
<< _("but it is not installable");
345 out
<< _("but it is a virtual package");
348 out
<< (Now
?_("but it is not installed"):_("but it is not going to be installed"));
364 // ShowNew - Show packages to newly install /*{{{*/
365 // ---------------------------------------------------------------------
367 void ShowNew(ostream
&out
,CacheFile
&Cache
)
369 /* Print out a list of packages that are going to be installed extra
370 to what the user asked */
373 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
375 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
376 if (Cache
[I
].NewInstall() == true) {
377 if (Cache
[I
].CandidateVerIter(Cache
).Pseudo() == true)
379 List
+= I
.FullName(true) + " ";
380 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
384 ShowList(out
,_("The following NEW packages will be installed:"),List
,VersionsList
);
387 // ShowDel - Show packages to delete /*{{{*/
388 // ---------------------------------------------------------------------
390 void ShowDel(ostream
&out
,CacheFile
&Cache
)
392 /* Print out a list of packages that are going to be removed extra
393 to what the user asked */
396 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
398 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
399 if (Cache
[I
].Delete() == true)
401 if (Cache
[I
].CandidateVerIter(Cache
).Pseudo() == true)
403 if ((Cache
[I
].iFlags
& pkgDepCache::Purge
) == pkgDepCache::Purge
)
404 List
+= I
.FullName(true) + "* ";
406 List
+= I
.FullName(true) + " ";
408 VersionsList
+= string(Cache
[I
].CandVersion
)+ "\n";
412 ShowList(out
,_("The following packages will be REMOVED:"),List
,VersionsList
);
415 // ShowKept - Show kept packages /*{{{*/
416 // ---------------------------------------------------------------------
418 void ShowKept(ostream
&out
,CacheFile
&Cache
)
422 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
424 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
427 if (Cache
[I
].Upgrade() == true || Cache
[I
].Upgradable() == false ||
428 I
->CurrentVer
== 0 || Cache
[I
].Delete() == true)
431 List
+= I
.FullName(true) + " ";
432 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
434 ShowList(out
,_("The following packages have been kept back:"),List
,VersionsList
);
437 // ShowUpgraded - Show upgraded packages /*{{{*/
438 // ---------------------------------------------------------------------
440 void ShowUpgraded(ostream
&out
,CacheFile
&Cache
)
444 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
446 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
449 if (Cache
[I
].Upgrade() == false || Cache
[I
].NewInstall() == true)
451 if (Cache
[I
].CandidateVerIter(Cache
).Pseudo() == true)
454 List
+= I
.FullName(true) + " ";
455 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
457 ShowList(out
,_("The following packages will be upgraded:"),List
,VersionsList
);
460 // ShowDowngraded - Show downgraded packages /*{{{*/
461 // ---------------------------------------------------------------------
463 bool ShowDowngraded(ostream
&out
,CacheFile
&Cache
)
467 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
469 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
472 if (Cache
[I
].Downgrade() == false || Cache
[I
].NewInstall() == true)
474 if (Cache
[I
].CandidateVerIter(Cache
).Pseudo() == true)
477 List
+= I
.FullName(true) + " ";
478 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
480 return ShowList(out
,_("The following packages will be DOWNGRADED:"),List
,VersionsList
);
483 // ShowHold - Show held but changed packages /*{{{*/
484 // ---------------------------------------------------------------------
486 bool ShowHold(ostream
&out
,CacheFile
&Cache
)
490 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
492 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
493 if (Cache
[I
].InstallVer
!= (pkgCache::Version
*)I
.CurrentVer() &&
494 I
->SelectedState
== pkgCache::State::Hold
) {
495 List
+= I
.FullName(true) + " ";
496 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
500 return ShowList(out
,_("The following held packages will be changed:"),List
,VersionsList
);
503 // ShowEssential - Show an essential package warning /*{{{*/
504 // ---------------------------------------------------------------------
505 /* This prints out a warning message that is not to be ignored. It shows
506 all essential packages and their dependents that are to be removed.
507 It is insanely risky to remove the dependents of an essential package! */
508 bool ShowEssential(ostream
&out
,CacheFile
&Cache
)
512 bool *Added
= new bool[Cache
->Head().PackageCount
];
513 for (unsigned int I
= 0; I
!= Cache
->Head().PackageCount
; I
++)
516 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
518 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
519 if ((I
->Flags
& pkgCache::Flag::Essential
) != pkgCache::Flag::Essential
&&
520 (I
->Flags
& pkgCache::Flag::Important
) != pkgCache::Flag::Important
)
523 // The essential package is being removed
524 if (Cache
[I
].Delete() == true)
526 if (Added
[I
->ID
] == false)
529 List
+= I
.FullName(true) + " ";
530 //VersionsList += string(Cache[I].CurVersion) + "\n"; ???
534 if (I
->CurrentVer
== 0)
537 // Print out any essential package depenendents that are to be removed
538 for (pkgCache::DepIterator D
= I
.CurrentVer().DependsList(); D
.end() == false; D
++)
540 // Skip everything but depends
541 if (D
->Type
!= pkgCache::Dep::PreDepends
&&
542 D
->Type
!= pkgCache::Dep::Depends
)
545 pkgCache::PkgIterator P
= D
.SmartTargetPkg();
546 if (Cache
[P
].Delete() == true)
548 if (Added
[P
->ID
] == true)
553 snprintf(S
,sizeof(S
),_("%s (due to %s) "),P
.FullName(true).c_str(),I
.FullName(true).c_str());
555 //VersionsList += "\n"; ???
561 return ShowList(out
,_("WARNING: The following essential packages will be removed.\n"
562 "This should NOT be done unless you know exactly what you are doing!"),List
,VersionsList
);
566 // Stats - Show some statistics /*{{{*/
567 // ---------------------------------------------------------------------
569 void Stats(ostream
&out
,pkgDepCache
&Dep
)
571 unsigned long Upgrade
= 0;
572 unsigned long Downgrade
= 0;
573 unsigned long Install
= 0;
574 unsigned long ReInstall
= 0;
575 for (pkgCache::PkgIterator I
= Dep
.PkgBegin(); I
.end() == false; I
++)
577 if (pkgCache::VerIterator(Dep
, Dep
[I
].CandidateVer
).Pseudo() == true)
580 if (Dep
[I
].NewInstall() == true)
584 if (Dep
[I
].Upgrade() == true)
587 if (Dep
[I
].Downgrade() == true)
591 if (Dep
[I
].Delete() == false && (Dep
[I
].iFlags
& pkgDepCache::ReInstall
) == pkgDepCache::ReInstall
)
595 ioprintf(out
,_("%lu upgraded, %lu newly installed, "),
599 ioprintf(out
,_("%lu reinstalled, "),ReInstall
);
601 ioprintf(out
,_("%lu downgraded, "),Downgrade
);
603 ioprintf(out
,_("%lu to remove and %lu not upgraded.\n"),
604 Dep
.DelCount(),Dep
.KeepCount());
606 if (Dep
.BadCount() != 0)
607 ioprintf(out
,_("%lu not fully installed or removed.\n"),
611 // CacheFile::NameComp - QSort compare by name /*{{{*/
612 // ---------------------------------------------------------------------
614 pkgCache
*CacheFile::SortCache
= 0;
615 int CacheFile::NameComp(const void *a
,const void *b
)
617 if (*(pkgCache::Package
**)a
== 0 || *(pkgCache::Package
**)b
== 0)
618 return *(pkgCache::Package
**)a
- *(pkgCache::Package
**)b
;
620 const pkgCache::Package
&A
= **(pkgCache::Package
**)a
;
621 const pkgCache::Package
&B
= **(pkgCache::Package
**)b
;
623 return strcmp(SortCache
->StrP
+ A
.Name
,SortCache
->StrP
+ B
.Name
);
626 // CacheFile::Sort - Sort by name /*{{{*/
627 // ---------------------------------------------------------------------
629 void CacheFile::Sort()
632 List
= new pkgCache::Package
*[Cache
->Head().PackageCount
];
633 memset(List
,0,sizeof(*List
)*Cache
->Head().PackageCount
);
634 pkgCache::PkgIterator I
= Cache
->PkgBegin();
635 for (;I
.end() != true; I
++)
639 qsort(List
,Cache
->Head().PackageCount
,sizeof(*List
),NameComp
);
642 // CacheFile::CheckDeps - Open the cache file /*{{{*/
643 // ---------------------------------------------------------------------
644 /* This routine generates the caches and then opens the dependency cache
645 and verifies that the system is OK. */
646 bool CacheFile::CheckDeps(bool AllowBroken
)
648 bool FixBroken
= _config
->FindB("APT::Get::Fix-Broken",false);
650 if (_error
->PendingError() == true)
653 // Check that the system is OK
654 if (DCache
->DelCount() != 0 || DCache
->InstCount() != 0)
655 return _error
->Error("Internal error, non-zero counts");
657 // Apply corrections for half-installed packages
658 if (pkgApplyStatus(*DCache
) == false)
661 if (_config
->FindB("APT::Get::Fix-Policy-Broken",false) == true)
664 if ((DCache
->PolicyBrokenCount() > 0))
666 // upgrade all policy-broken packages with ForceImportantDeps=True
667 for (pkgCache::PkgIterator I
= Cache
->PkgBegin(); !I
.end(); I
++)
668 if ((*DCache
)[I
].NowPolicyBroken() == true)
669 DCache
->MarkInstall(I
,true,0, false, true);
674 if (DCache
->BrokenCount() == 0 || AllowBroken
== true)
677 // Attempt to fix broken things
678 if (FixBroken
== true)
680 c1out
<< _("Correcting dependencies...") << flush
;
681 if (pkgFixBroken(*DCache
) == false || DCache
->BrokenCount() != 0)
683 c1out
<< _(" failed.") << endl
;
684 ShowBroken(c1out
,*this,true);
686 return _error
->Error(_("Unable to correct dependencies"));
688 if (pkgMinimizeUpgrade(*DCache
) == false)
689 return _error
->Error(_("Unable to minimize the upgrade set"));
691 c1out
<< _(" Done") << endl
;
695 c1out
<< _("You might want to run `apt-get -f install' to correct these.") << endl
;
696 ShowBroken(c1out
,*this,true);
698 return _error
->Error(_("Unmet dependencies. Try using -f."));
704 // CheckAuth - check if each download comes form a trusted source /*{{{*/
705 // ---------------------------------------------------------------------
707 static bool CheckAuth(pkgAcquire
& Fetcher
)
709 string UntrustedList
;
710 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd(); ++I
)
712 if (!(*I
)->IsTrusted())
714 UntrustedList
+= string((*I
)->ShortDesc()) + " ";
718 if (UntrustedList
== "")
723 ShowList(c2out
,_("WARNING: The following packages cannot be authenticated!"),UntrustedList
,"");
725 if (_config
->FindB("APT::Get::AllowUnauthenticated",false) == true)
727 c2out
<< _("Authentication warning overridden.\n");
731 if (_config
->FindI("quiet",0) < 2
732 && _config
->FindB("APT::Get::Assume-Yes",false) == false)
734 c2out
<< _("Install these packages without verification [y/N]? ") << flush
;
735 if (!YnPrompt(false))
736 return _error
->Error(_("Some packages could not be authenticated"));
740 else if (_config
->FindB("APT::Get::Force-Yes",false) == true)
745 return _error
->Error(_("There are problems and -y was used without --force-yes"));
748 // InstallPackages - Actually download and install the packages /*{{{*/
749 // ---------------------------------------------------------------------
750 /* This displays the informative messages describing what is going to
751 happen and then calls the download routines */
752 bool InstallPackages(CacheFile
&Cache
,bool ShwKept
,bool Ask
= true,
755 if (_config
->FindB("APT::Get::Purge",false) == true)
757 pkgCache::PkgIterator I
= Cache
->PkgBegin();
758 for (; I
.end() == false; I
++)
760 if (I
.Purge() == false && Cache
[I
].Mode
== pkgDepCache::ModeDelete
)
761 Cache
->MarkDelete(I
,true);
766 bool Essential
= false;
768 // Show all the various warning indicators
769 ShowDel(c1out
,Cache
);
770 ShowNew(c1out
,Cache
);
772 ShowKept(c1out
,Cache
);
773 Fail
|= !ShowHold(c1out
,Cache
);
774 if (_config
->FindB("APT::Get::Show-Upgraded",true) == true)
775 ShowUpgraded(c1out
,Cache
);
776 Fail
|= !ShowDowngraded(c1out
,Cache
);
777 if (_config
->FindB("APT::Get::Download-Only",false) == false)
778 Essential
= !ShowEssential(c1out
,Cache
);
783 if (Cache
->BrokenCount() != 0)
785 ShowBroken(c1out
,Cache
,false);
786 return _error
->Error(_("Internal error, InstallPackages was called with broken packages!"));
789 if (Cache
->DelCount() == 0 && Cache
->InstCount() == 0 &&
790 Cache
->BadCount() == 0)
794 if (Cache
->DelCount() != 0 && _config
->FindB("APT::Get::Remove",true) == false)
795 return _error
->Error(_("Packages need to be removed but remove is disabled."));
797 // Run the simulator ..
798 if (_config
->FindB("APT::Get::Simulate") == true)
800 pkgSimulate
PM(Cache
);
801 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
802 pkgPackageManager::OrderResult Res
= PM
.DoInstall(status_fd
);
803 if (Res
== pkgPackageManager::Failed
)
805 if (Res
!= pkgPackageManager::Completed
)
806 return _error
->Error(_("Internal error, Ordering didn't finish"));
810 // Create the text record parser
811 pkgRecords
Recs(Cache
);
812 if (_error
->PendingError() == true)
815 // Lock the archive directory
817 if (_config
->FindB("Debug::NoLocking",false) == false &&
818 _config
->FindB("APT::Get::Print-URIs") == false)
820 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
821 if (_error
->PendingError() == true)
822 return _error
->Error(_("Unable to lock the download directory"));
825 // Create the download object
826 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
827 pkgAcquire
Fetcher(&Stat
);
829 // Read the source list
831 if (List
.ReadMainList() == false)
832 return _error
->Error(_("The list of sources could not be read."));
834 // Create the package manager and prepare to download
835 SPtr
<pkgPackageManager
> PM
= _system
->CreatePM(Cache
);
836 if (PM
->GetArchives(&Fetcher
,&List
,&Recs
) == false ||
837 _error
->PendingError() == true)
840 // Display statistics
841 double FetchBytes
= Fetcher
.FetchNeeded();
842 double FetchPBytes
= Fetcher
.PartialPresent();
843 double DebBytes
= Fetcher
.TotalNeeded();
844 if (DebBytes
!= Cache
->DebSize())
846 c0out
<< DebBytes
<< ',' << Cache
->DebSize() << endl
;
847 c0out
<< _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl
;
851 if (DebBytes
!= FetchBytes
)
852 ioprintf(c1out
,_("Need to get %sB/%sB of archives.\n"),
853 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
854 else if (DebBytes
!= 0)
855 ioprintf(c1out
,_("Need to get %sB of archives.\n"),
856 SizeToStr(DebBytes
).c_str());
859 if (Cache
->UsrSize() >= 0)
860 ioprintf(c1out
,_("After this operation, %sB of additional disk space will be used.\n"),
861 SizeToStr(Cache
->UsrSize()).c_str());
863 ioprintf(c1out
,_("After this operation, %sB disk space will be freed.\n"),
864 SizeToStr(-1*Cache
->UsrSize()).c_str());
866 if (_error
->PendingError() == true)
869 /* Check for enough free space, but only if we are actually going to
871 if (_config
->FindB("APT::Get::Print-URIs") == false &&
872 _config
->FindB("APT::Get::Download",true) == true)
875 string OutputDir
= _config
->FindDir("Dir::Cache::Archives");
876 if (statvfs(OutputDir
.c_str(),&Buf
) != 0) {
877 if (errno
== EOVERFLOW
)
878 return _error
->WarningE("statvfs",_("Couldn't determine free space in %s"),
881 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
883 } else if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
886 if (statfs(OutputDir
.c_str(),&Stat
) != 0
887 #if HAVE_STRUCT_STATFS_F_TYPE
888 || unsigned(Stat
.f_type
) != RAMFS_MAGIC
891 return _error
->Error(_("You don't have enough free space in %s."),
897 if (_config
->FindI("quiet",0) >= 2 ||
898 _config
->FindB("APT::Get::Assume-Yes",false) == true)
900 if (Fail
== true && _config
->FindB("APT::Get::Force-Yes",false) == false)
901 return _error
->Error(_("There are problems and -y was used without --force-yes"));
904 if (Essential
== true && Safety
== true)
906 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
907 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
909 const char *Prompt
= _("Yes, do as I say!");
911 _("You are about to do something potentially harmful.\n"
912 "To continue type in the phrase '%s'\n"
915 if (AnalPrompt(Prompt
) == false)
917 c2out
<< _("Abort.") << endl
;
923 // Prompt to continue
924 if (Ask
== true || Fail
== true)
926 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
927 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
929 if (_config
->FindI("quiet",0) < 2 &&
930 _config
->FindB("APT::Get::Assume-Yes",false) == false)
932 c2out
<< _("Do you want to continue [Y/n]? ") << flush
;
934 if (YnPrompt() == false)
936 c2out
<< _("Abort.") << endl
;
943 // Just print out the uris an exit if the --print-uris flag was used
944 if (_config
->FindB("APT::Get::Print-URIs") == true)
946 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
947 for (; I
!= Fetcher
.UriEnd(); I
++)
948 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
949 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
953 if (!CheckAuth(Fetcher
))
956 /* Unlock the dpkg lock if we are not going to be doing an install
958 if (_config
->FindB("APT::Get::Download-Only",false) == true)
964 bool Transient
= false;
965 if (_config
->FindB("APT::Get::Download",true) == false)
967 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd();)
969 if ((*I
)->Local
== true)
975 // Close the item and check if it was found in cache
977 if ((*I
)->Complete
== false)
980 // Clear it out of the fetch list
982 I
= Fetcher
.ItemsBegin();
986 if (Fetcher
.Run() == pkgAcquire::Failed
)
991 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); I
++)
993 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
994 (*I
)->Complete
== true)
997 if ((*I
)->Status
== pkgAcquire::Item::StatIdle
)
1004 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
1005 (*I
)->ErrorText
.c_str());
1009 /* If we are in no download mode and missing files and there were
1010 'failures' then the user must specify -m. Furthermore, there
1011 is no such thing as a transient error in no-download mode! */
1012 if (Transient
== true &&
1013 _config
->FindB("APT::Get::Download",true) == false)
1019 if (_config
->FindB("APT::Get::Download-Only",false) == true)
1021 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
1022 return _error
->Error(_("Some files failed to download"));
1023 c1out
<< _("Download complete and in download only mode") << endl
;
1027 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
1029 return _error
->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
1032 if (Transient
== true && Failed
== true)
1033 return _error
->Error(_("--fix-missing and media swapping is not currently supported"));
1035 // Try to deal with missing package files
1036 if (Failed
== true && PM
->FixMissing() == false)
1038 cerr
<< _("Unable to correct missing packages.") << endl
;
1039 return _error
->Error(_("Aborting install."));
1043 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
1044 pkgPackageManager::OrderResult Res
= PM
->DoInstall(status_fd
);
1045 if (Res
== pkgPackageManager::Failed
|| _error
->PendingError() == true)
1047 if (Res
== pkgPackageManager::Completed
)
1050 // Reload the fetcher object and loop again for media swapping
1052 if (PM
->GetArchives(&Fetcher
,&List
,&Recs
) == false)
1059 // TryToInstall - Try to install a single package /*{{{*/
1060 // ---------------------------------------------------------------------
1061 /* This used to be inlined in DoInstall, but with the advent of regex package
1062 name matching it was split out.. */
1063 bool TryToInstall(pkgCache::PkgIterator Pkg
,pkgDepCache
&Cache
,
1064 pkgProblemResolver
&Fix
,bool Remove
,bool BrokenFix
,
1065 unsigned int &ExpectedInst
,bool AllowFail
= true)
1067 /* This is a pure virtual package and there is a single available
1068 candidate providing it. */
1069 if (Cache
[Pkg
].CandidateVer
== 0 && Pkg
->ProvidesList
!= 0)
1071 pkgCache::PkgIterator Prov
;
1072 bool found_one
= false;
1074 for (pkgCache::PrvIterator P
= Pkg
.ProvidesList(); P
; P
++)
1076 pkgCache::VerIterator
const PVer
= P
.OwnerVer();
1077 pkgCache::PkgIterator
const PPkg
= PVer
.ParentPkg();
1079 /* Ignore versions that are not a candidate. */
1080 if (Cache
[PPkg
].CandidateVer
!= PVer
)
1083 if (found_one
== false)
1088 else if (PPkg
!= Prov
)
1090 found_one
= false; // we found at least two
1095 if (found_one
== true)
1097 ioprintf(c1out
,_("Note, selecting %s instead of %s\n"),
1098 Prov
.FullName(true).c_str(),Pkg
.FullName(true).c_str());
1103 // Handle the no-upgrade case
1104 if (_config
->FindB("APT::Get::upgrade",true) == false &&
1105 Pkg
->CurrentVer
!= 0)
1107 if (AllowFail
== true)
1108 ioprintf(c1out
,_("Skipping %s, it is already installed and upgrade is not set.\n"),
1109 Pkg
.FullName(true).c_str());
1113 // Check if there is something at all to install
1114 pkgDepCache::StateCache
&State
= Cache
[Pkg
];
1115 if (Remove
== true && Pkg
->CurrentVer
== 0)
1121 /* We want to continue searching for regex hits, so we return false here
1122 otherwise this is not really an error. */
1123 if (AllowFail
== false)
1126 ioprintf(c1out
,_("Package %s is not installed, so not removed\n"),Pkg
.FullName(true).c_str());
1130 if (State
.CandidateVer
== 0 && Remove
== false)
1132 if (AllowFail
== false)
1135 if (Pkg
->ProvidesList
!= 0)
1137 ioprintf(c1out
,_("Package %s is a virtual package provided by:\n"),
1138 Pkg
.FullName(true).c_str());
1140 pkgCache::PrvIterator I
= Pkg
.ProvidesList();
1141 for (; I
.end() == false; I
++)
1143 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
1145 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer())
1147 if (Cache
[Pkg
].Install() == true && Cache
[Pkg
].NewInstall() == false)
1148 c1out
<< " " << Pkg
.FullName(true) << " " << I
.OwnerVer().VerStr() <<
1149 _(" [Installed]") << endl
;
1151 c1out
<< " " << Pkg
.FullName(true) << " " << I
.OwnerVer().VerStr() << endl
;
1154 c1out
<< _("You should explicitly select one to install.") << endl
;
1159 _("Package %s is not available, but is referred to by another package.\n"
1160 "This may mean that the package is missing, has been obsoleted, or\n"
1161 "is only available from another source\n"),Pkg
.FullName(true).c_str());
1164 string VersionsList
;
1165 SPtrArray
<bool> Seen
= new bool[Cache
.Head().PackageCount
];
1166 memset(Seen
,0,Cache
.Head().PackageCount
*sizeof(*Seen
));
1167 pkgCache::DepIterator Dep
= Pkg
.RevDependsList();
1168 for (; Dep
.end() == false; Dep
++)
1170 if (Dep
->Type
!= pkgCache::Dep::Replaces
)
1172 if (Seen
[Dep
.ParentPkg()->ID
] == true)
1174 Seen
[Dep
.ParentPkg()->ID
] = true;
1175 List
+= Dep
.ParentPkg().FullName(true) + " ";
1176 //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
1178 ShowList(c1out
,_("However the following packages replace it:"),List
,VersionsList
);
1181 _error
->Error(_("Package %s has no installation candidate"),Pkg
.FullName(true).c_str());
1190 Cache
.MarkDelete(Pkg
,_config
->FindB("APT::Get::Purge",false));
1195 Cache
.MarkInstall(Pkg
,false);
1196 if (State
.Install() == false)
1198 if (_config
->FindB("APT::Get::ReInstall",false) == true)
1200 if (Pkg
->CurrentVer
== 0 || Pkg
.CurrentVer().Downloadable() == false)
1201 ioprintf(c1out
,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
1202 Pkg
.FullName(true).c_str());
1204 Cache
.SetReInstall(Pkg
,true);
1208 if (AllowFail
== true)
1209 ioprintf(c1out
,_("%s is already the newest version.\n"),
1210 Pkg
.FullName(true).c_str());
1216 // Install it with autoinstalling enabled (if we not respect the minial
1217 // required deps or the policy)
1218 if ((State
.InstBroken() == true || State
.InstPolicyBroken() == true) && BrokenFix
== false)
1219 Cache
.MarkInstall(Pkg
,true);
1224 // TryToChangeVer - Try to change a candidate version /*{{{*/
1225 // ---------------------------------------------------------------------
1227 bool TryToChangeVer(pkgCache::PkgIterator Pkg
,pkgDepCache
&Cache
,
1228 const char *VerTag
,bool IsRel
)
1230 pkgVersionMatch
Match(VerTag
,(IsRel
== true?pkgVersionMatch::Release
:
1231 pkgVersionMatch::Version
));
1233 pkgCache::VerIterator Ver
= Match
.Find(Pkg
);
1235 if (Ver
.end() == true)
1238 return _error
->Error(_("Release '%s' for '%s' was not found"),
1239 VerTag
,Pkg
.FullName(true).c_str());
1240 return _error
->Error(_("Version '%s' for '%s' was not found"),
1241 VerTag
,Pkg
.FullName(true).c_str());
1244 if (strcmp(VerTag
,Ver
.VerStr()) != 0)
1246 ioprintf(c1out
,_("Selected version %s (%s) for %s\n"),
1247 Ver
.VerStr(),Ver
.RelStr().c_str(),Pkg
.FullName(true).c_str());
1250 Cache
.SetCandidateVersion(Ver
);
1254 // FindSrc - Find a source record /*{{{*/
1255 // ---------------------------------------------------------------------
1257 pkgSrcRecords::Parser
*FindSrc(const char *Name
,pkgRecords
&Recs
,
1258 pkgSrcRecords
&SrcRecs
,string
&Src
,
1262 string DefRel
= _config
->Find("APT::Default-Release");
1263 string TmpSrc
= Name
;
1265 // extract the version/release from the pkgname
1266 const size_t found
= TmpSrc
.find_last_of("/=");
1267 if (found
!= string::npos
) {
1268 if (TmpSrc
[found
] == '/')
1269 DefRel
= TmpSrc
.substr(found
+1);
1271 VerTag
= TmpSrc
.substr(found
+1);
1272 TmpSrc
= TmpSrc
.substr(0,found
);
1275 /* Lookup the version of the package we would install if we were to
1276 install a version and determine the source package name, then look
1277 in the archive for a source package of the same name. */
1278 bool MatchSrcOnly
= _config
->FindB("APT::Get::Only-Source");
1279 const pkgCache::PkgIterator Pkg
= Cache
.FindPkg(TmpSrc
);
1280 if (MatchSrcOnly
== false && Pkg
.end() == false)
1282 if(VerTag
.empty() == false || DefRel
.empty() == false)
1284 // we have a default release, try to locate the pkg. we do it like
1285 // this because GetCandidateVer() will not "downgrade", that means
1286 // "apt-get source -t stable apt" won't work on a unstable system
1287 for (pkgCache::VerIterator Ver
= Pkg
.VersionList();
1288 Ver
.end() == false; Ver
++)
1290 for (pkgCache::VerFileIterator VF
= Ver
.FileList();
1291 VF
.end() == false; VF
++)
1293 /* If this is the status file, and the current version is not the
1294 version in the status file (ie it is not installed, or somesuch)
1295 then it is not a candidate for installation, ever. This weeds
1296 out bogus entries that may be due to config-file states, or
1298 if ((VF
.File()->Flags
& pkgCache::Flag::NotSource
) ==
1299 pkgCache::Flag::NotSource
&& Pkg
.CurrentVer() != Ver
)
1302 // We match against a concrete version (or a part of this version)
1303 if (VerTag
.empty() == false && strncmp(VerTag
.c_str(), Ver
.VerStr(), VerTag
.size()) != 0)
1306 // or we match against a release
1307 if(VerTag
.empty() == false ||
1308 (VF
.File().Archive() != 0 && VF
.File().Archive() == DefRel
) ||
1309 (VF
.File().Codename() != 0 && VF
.File().Codename() == DefRel
))
1311 pkgRecords::Parser
&Parse
= Recs
.Lookup(VF
);
1312 Src
= Parse
.SourcePkg();
1313 // no SourcePkg name, so it is the "binary" name
1314 if (Src
.empty() == true)
1316 // no Version, so we try the Version of the SourcePkg -
1317 // and after that the version of the binary package
1318 if (VerTag
.empty() == true)
1319 VerTag
= Parse
.SourceVer();
1320 if (VerTag
.empty() == true)
1321 VerTag
= Ver
.VerStr();
1325 if (Src
.empty() == false)
1328 if (Src
.empty() == true)
1330 // Sources files have no codename information
1331 if (VerTag
.empty() == true && DefRel
.empty() == false)
1332 _error
->Warning(_("Ignore unavailable target release '%s' of package '%s'"), DefRel
.c_str(), TmpSrc
.c_str());
1336 if (Src
.empty() == true)
1338 // if we don't have found a fitting package yet so we will
1339 // choose a good candidate and proceed with that.
1340 // Maybe we will find a source later on with the right VerTag
1341 pkgCache::VerIterator Ver
= Cache
.GetCandidateVer(Pkg
);
1342 if (Ver
.end() == false)
1344 pkgRecords::Parser
&Parse
= Recs
.Lookup(Ver
.FileList());
1345 Src
= Parse
.SourcePkg();
1346 if (VerTag
.empty() == true)
1347 VerTag
= Parse
.SourceVer();
1352 if (Src
.empty() == true)
1356 /* if we have a source pkg name, make sure to only search
1357 for srcpkg names, otherwise apt gets confused if there
1358 is a binary package "pkg1" and a source package "pkg1"
1359 with the same name but that comes from different packages */
1360 MatchSrcOnly
= true;
1363 ioprintf(c1out
, _("Picking '%s' as source package instead of '%s'\n"), Src
.c_str(), TmpSrc
.c_str());
1368 pkgSrcRecords::Parser
*Last
= 0;
1369 unsigned long Offset
= 0;
1372 /* Iterate over all of the hits, which includes the resulting
1373 binary packages in the search */
1374 pkgSrcRecords::Parser
*Parse
;
1378 while ((Parse
= SrcRecs
.Find(Src
.c_str(), MatchSrcOnly
)) != 0)
1380 const string Ver
= Parse
->Version();
1382 // Ignore all versions which doesn't fit
1383 if (VerTag
.empty() == false && strncmp(VerTag
.c_str(), Ver
.c_str(), VerTag
.size()) != 0)
1386 // Newer version or an exact match? Save the hit
1387 if (Last
== 0 || Cache
.VS().CmpVersion(Version
,Ver
) < 0) {
1389 Offset
= Parse
->Offset();
1393 // was the version check above an exact match? If so, we don't need to look further
1394 if (VerTag
.empty() == false && VerTag
.size() == Ver
.size())
1397 if (Last
!= 0 || VerTag
.empty() == true)
1399 //if (VerTag.empty() == false && Last == 0)
1400 _error
->Warning(_("Ignore unavailable version '%s' of package '%s'"), VerTag
.c_str(), TmpSrc
.c_str());
1404 if (Last
== 0 || Last
->Jump(Offset
) == false)
1410 // DoUpdate - Update the package lists /*{{{*/
1411 // ---------------------------------------------------------------------
1413 bool DoUpdate(CommandLine
&CmdL
)
1415 if (CmdL
.FileSize() != 1)
1416 return _error
->Error(_("The update command takes no arguments"));
1418 // Get the source list
1420 if (List
.ReadMainList() == false)
1423 // Lock the list directory
1425 if (_config
->FindB("Debug::NoLocking",false) == false)
1427 Lock
.Fd(GetLock(_config
->FindDir("Dir::State::Lists") + "lock"));
1428 if (_error
->PendingError() == true)
1429 return _error
->Error(_("Unable to lock the list directory"));
1432 // Create the progress
1433 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
1435 // Just print out the uris an exit if the --print-uris flag was used
1436 if (_config
->FindB("APT::Get::Print-URIs") == true)
1439 pkgAcquire
Fetcher(&Stat
);
1441 // Populate it with the source selection and get all Indexes
1443 if (List
.GetIndexes(&Fetcher
,true) == false)
1446 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
1447 for (; I
!= Fetcher
.UriEnd(); I
++)
1448 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
1449 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
1455 if (_config
->FindB("APT::Get::Download",true) == true)
1456 ListUpdate(Stat
, List
);
1458 // Rebuild the cache.
1459 if (Cache
.BuildCaches() == false)
1465 // DoAutomaticRemove - Remove all automatic unused packages /*{{{*/
1466 // ---------------------------------------------------------------------
1467 /* Remove unused automatic packages */
1468 bool DoAutomaticRemove(CacheFile
&Cache
)
1470 bool Debug
= _config
->FindI("Debug::pkgAutoRemove",false);
1471 bool doAutoRemove
= _config
->FindB("APT::Get::AutomaticRemove", false);
1472 bool hideAutoRemove
= _config
->FindB("APT::Get::HideAutoRemove");
1474 pkgDepCache::ActionGroup
group(*Cache
);
1476 std::cout
<< "DoAutomaticRemove()" << std::endl
;
1478 // we don't want to autoremove and we don't want to see it, so why calculating?
1479 if (doAutoRemove
== false && hideAutoRemove
== true)
1482 if (doAutoRemove
== true &&
1483 _config
->FindB("APT::Get::Remove",true) == false)
1485 c1out
<< _("We are not supposed to delete stuff, can't start "
1486 "AutoRemover") << std::endl
;
1490 bool purgePkgs
= _config
->FindB("APT::Get::Purge", false);
1491 bool smallList
= (hideAutoRemove
== false &&
1492 strcasecmp(_config
->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
1494 string autoremovelist
, autoremoveversions
;
1495 unsigned long autoRemoveCount
= 0;
1496 // look over the cache to see what can be removed
1497 for (pkgCache::PkgIterator Pkg
= Cache
->PkgBegin(); ! Pkg
.end(); ++Pkg
)
1499 if (Cache
[Pkg
].Garbage
)
1501 if(Pkg
.CurrentVer() != 0 || Cache
[Pkg
].Install())
1503 std::cout
<< "We could delete %s" << Pkg
.FullName(true).c_str() << std::endl
;
1507 if(Pkg
.CurrentVer() != 0 &&
1508 Pkg
->CurrentState
!= pkgCache::State::ConfigFiles
)
1509 Cache
->MarkDelete(Pkg
, purgePkgs
);
1511 Cache
->MarkKeep(Pkg
, false, false);
1515 // only show stuff in the list that is not yet marked for removal
1516 if(Cache
[Pkg
].Delete() == false)
1519 // we don't need to fill the strings if we don't need them
1520 if (smallList
== false)
1522 autoremovelist
+= Pkg
.FullName(true) + " ";
1523 autoremoveversions
+= string(Cache
[Pkg
].CandVersion
) + "\n";
1529 // if we don't remove them, we should show them!
1530 if (doAutoRemove
== false && (autoremovelist
.empty() == false || autoRemoveCount
!= 0))
1532 if (smallList
== false)
1533 ShowList(c1out
, P_("The following package is automatically installed and is no longer required:",
1534 "The following packages were automatically installed and are no longer required:",
1535 autoRemoveCount
), autoremovelist
, autoremoveversions
);
1537 ioprintf(c1out
, P_("%lu package was automatically installed and is no longer required.\n",
1538 "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount
), autoRemoveCount
);
1539 c1out
<< _("Use 'apt-get autoremove' to remove them.") << std::endl
;
1541 // Now see if we had destroyed anything (if we had done anything)
1542 else if (Cache
->BrokenCount() != 0)
1544 c1out
<< _("Hmm, seems like the AutoRemover destroyed something which really\n"
1545 "shouldn't happen. Please file a bug report against apt.") << endl
;
1547 c1out
<< _("The following information may help to resolve the situation:") << endl
;
1549 ShowBroken(c1out
,Cache
,false);
1551 return _error
->Error(_("Internal Error, AutoRemover broke stuff"));
1556 // DoUpgrade - Upgrade all packages /*{{{*/
1557 // ---------------------------------------------------------------------
1558 /* Upgrade all packages without installing new packages or erasing old
1560 bool DoUpgrade(CommandLine
&CmdL
)
1563 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
1567 if (pkgAllUpgrade(Cache
) == false)
1569 ShowBroken(c1out
,Cache
,false);
1570 return _error
->Error(_("Internal error, AllUpgrade broke stuff"));
1573 return InstallPackages(Cache
,true);
1576 // DoInstallTask - Install task from the command line /*{{{*/
1577 // ---------------------------------------------------------------------
1578 /* Install named task */
1579 bool TryInstallTask(pkgDepCache
&Cache
, pkgProblemResolver
&Fix
,
1581 unsigned int& ExpectedInst
,
1582 const char *taskname
,
1585 const char *start
, *end
;
1586 pkgCache::PkgIterator Pkg
;
1591 pkgRecords
Recs(Cache
);
1593 // build regexp for the task
1595 snprintf(S
, sizeof(S
), "^Task:.*[, ]%s([, ]|$)", taskname
);
1596 if(regcomp(&Pattern
,S
, REG_EXTENDED
| REG_NOSUB
| REG_NEWLINE
) != 0)
1597 return _error
->Error("Failed to compile task regexp");
1602 // two runs, first ignore dependencies, second install any missing
1603 for(int IgnoreBroken
=1; IgnoreBroken
>= 0; IgnoreBroken
--)
1605 for (Pkg
= Cache
.PkgBegin(); Pkg
.end() == false; Pkg
++)
1607 pkgCache::VerIterator ver
= Cache
[Pkg
].CandidateVerIter(Cache
);
1610 pkgRecords::Parser
&parser
= Recs
.Lookup(ver
.FileList());
1611 parser
.GetRec(start
,end
);
1612 strncpy(buf
, start
, end
-start
);
1613 buf
[end
-start
] = 0x0;
1614 if (regexec(&Pattern
,buf
,0,0,0) != 0)
1616 res
&= TryToInstall(Pkg
,Cache
,Fix
,Remove
,IgnoreBroken
,ExpectedInst
);
1621 // now let the problem resolver deal with any issues
1625 _error
->Error(_("Couldn't find task %s"),taskname
);
1631 // DoInstall - Install packages from the command line /*{{{*/
1632 // ---------------------------------------------------------------------
1633 /* Install named packages */
1634 bool DoInstall(CommandLine
&CmdL
)
1637 if (Cache
.OpenForInstall() == false ||
1638 Cache
.CheckDeps(CmdL
.FileSize() != 1) == false)
1641 // Enter the special broken fixing mode if the user specified arguments
1642 bool BrokenFix
= false;
1643 if (Cache
->BrokenCount() != 0)
1646 unsigned int AutoMarkChanged
= 0;
1647 unsigned int ExpectedInst
= 0;
1648 unsigned int Packages
= 0;
1649 pkgProblemResolver
Fix(Cache
);
1651 bool DefRemove
= false;
1652 if (strcasecmp(CmdL
.FileList
[0],"remove") == 0)
1654 else if (strcasecmp(CmdL
.FileList
[0], "purge") == 0)
1656 _config
->Set("APT::Get::Purge", true);
1659 else if (strcasecmp(CmdL
.FileList
[0], "autoremove") == 0)
1661 _config
->Set("APT::Get::AutomaticRemove", "true");
1664 // new scope for the ActionGroup
1666 pkgDepCache::ActionGroup
group(Cache
);
1667 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++)
1669 // Duplicate the string
1670 unsigned int Length
= strlen(*I
);
1672 if (Length
>= sizeof(S
))
1676 // See if we are removing and special indicators..
1677 bool Remove
= DefRemove
;
1679 bool VerIsRel
= false;
1682 if (Length
>= 1 && S
[Length
- 1] == '^')
1685 // tasks must always be confirmed
1686 ExpectedInst
+= 1000;
1687 // see if we can install it
1688 TryInstallTask(Cache
, Fix
, BrokenFix
, ExpectedInst
, S
, Remove
);
1692 while (Cache
->FindPkg(S
).end() == true)
1694 // Handle an optional end tag indicating what to do
1695 if (Length
>= 1 && S
[Length
- 1] == '-')
1702 if (Length
>= 1 && S
[Length
- 1] == '+')
1709 char *Slash
= strchr(S
,'=');
1717 Slash
= strchr(S
,'/');
1728 // Locate the package
1729 pkgCache::PkgIterator Pkg
= Cache
->FindPkg(S
);
1731 if (Pkg
.end() == true)
1733 // Check if the name is a regex
1735 for (I
= S
; *I
!= 0; I
++)
1736 if (*I
== '?' || *I
== '*' || *I
== '|' ||
1737 *I
== '[' || *I
== '^' || *I
== '$')
1740 return _error
->Error(_("Couldn't find package %s"),S
);
1742 // Regexs must always be confirmed
1743 ExpectedInst
+= 1000;
1745 // Compile the regex pattern
1748 if ((Res
= regcomp(&Pattern
,S
,REG_EXTENDED
| REG_ICASE
|
1752 regerror(Res
,&Pattern
,Error
,sizeof(Error
));
1753 return _error
->Error(_("Regex compilation error - %s"),Error
);
1756 // Run over the matches
1758 for (Pkg
= Cache
->PkgBegin(); Pkg
.end() == false; Pkg
++)
1760 if (regexec(&Pattern
,Pkg
.Name(),0,0,0) != 0)
1763 ioprintf(c1out
,_("Note, selecting %s for regex '%s'\n"),
1767 if (TryToChangeVer(Pkg
,Cache
,VerTag
,VerIsRel
) == false)
1770 Hit
|= TryToInstall(Pkg
,Cache
,Fix
,Remove
,BrokenFix
,
1771 ExpectedInst
,false);
1776 return _error
->Error(_("Couldn't find package %s"),S
);
1781 if (TryToChangeVer(Pkg
,Cache
,VerTag
,VerIsRel
) == false)
1783 if (TryToInstall(Pkg
,Cache
,Fix
,Remove
,BrokenFix
,ExpectedInst
) == false)
1786 // see if we need to fix the auto-mark flag
1787 // e.g. apt-get install foo
1788 // where foo is marked automatic
1790 Cache
[Pkg
].Install() == false &&
1791 (Cache
[Pkg
].Flags
& pkgCache::Flag::Auto
) &&
1792 _config
->FindB("APT::Get::ReInstall",false) == false &&
1793 _config
->FindB("APT::Get::Download-Only",false) == false)
1795 ioprintf(c1out
,_("%s set to manually installed.\n"),
1796 Pkg
.FullName(true).c_str());
1797 Cache
->MarkAuto(Pkg
,false);
1803 /* If we are in the Broken fixing mode we do not attempt to fix the
1804 problems. This is if the user invoked install without -f and gave
1806 if (BrokenFix
== true && Cache
->BrokenCount() != 0)
1808 c1out
<< _("You might want to run `apt-get -f install' to correct these:") << endl
;
1809 ShowBroken(c1out
,Cache
,false);
1811 return _error
->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1814 // Call the scored problem resolver
1815 Fix
.InstallProtect();
1816 if (Fix
.Resolve(true) == false)
1819 // Now we check the state of the packages,
1820 if (Cache
->BrokenCount() != 0)
1823 _("Some packages could not be installed. This may mean that you have\n"
1824 "requested an impossible situation or if you are using the unstable\n"
1825 "distribution that some required packages have not yet been created\n"
1826 "or been moved out of Incoming.") << endl
;
1832 _("Since you only requested a single operation it is extremely likely that\n"
1833 "the package is simply not installable and a bug report against\n"
1834 "that package should be filed.") << endl;
1838 c1out
<< _("The following information may help to resolve the situation:") << endl
;
1840 ShowBroken(c1out
,Cache
,false);
1841 return _error
->Error(_("Broken packages"));
1844 if (!DoAutomaticRemove(Cache
))
1847 /* Print out a list of packages that are going to be installed extra
1848 to what the user asked */
1849 if (Cache
->InstCount() != ExpectedInst
)
1852 string VersionsList
;
1853 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
1855 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
1856 if ((*Cache
)[I
].Install() == false)
1860 for (J
= CmdL
.FileList
+ 1; *J
!= 0; J
++)
1861 if (strcmp(*J
,I
.Name()) == 0)
1865 List
+= I
.FullName(true) + " ";
1866 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
1870 ShowList(c1out
,_("The following extra packages will be installed:"),List
,VersionsList
);
1873 /* Print out a list of suggested and recommended packages */
1875 string SuggestsList
, RecommendsList
, List
;
1876 string SuggestsVersions
, RecommendsVersions
;
1877 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
1879 pkgCache::PkgIterator
Pkg(Cache
,Cache
.List
[J
]);
1881 /* Just look at the ones we want to install */
1882 if ((*Cache
)[Pkg
].Install() == false)
1885 // get the recommends/suggests for the candidate ver
1886 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
1887 for (pkgCache::DepIterator D
= CV
.DependsList(); D
.end() == false; )
1889 pkgCache::DepIterator Start
;
1890 pkgCache::DepIterator End
;
1891 D
.GlobOr(Start
,End
); // advances D
1893 // FIXME: we really should display a or-group as a or-group to the user
1894 // the problem is that ShowList is incapable of doing this
1895 string RecommendsOrList
,RecommendsOrVersions
;
1896 string SuggestsOrList
,SuggestsOrVersions
;
1897 bool foundInstalledInOrGroup
= false;
1900 /* Skip if package is installed already, or is about to be */
1901 string target
= Start
.TargetPkg().FullName(true) + " ";
1903 if ((*Start
.TargetPkg()).SelectedState
== pkgCache::State::Install
1904 || Cache
[Start
.TargetPkg()].Install())
1906 foundInstalledInOrGroup
=true;
1910 /* Skip if we already saw it */
1911 if (int(SuggestsList
.find(target
)) != -1 || int(RecommendsList
.find(target
)) != -1)
1913 foundInstalledInOrGroup
=true;
1917 // this is a dep on a virtual pkg, check if any package that provides it
1918 // should be installed
1919 if(Start
.TargetPkg().ProvidesList() != 0)
1921 pkgCache::PrvIterator I
= Start
.TargetPkg().ProvidesList();
1922 for (; I
.end() == false; I
++)
1924 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
1925 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer() &&
1926 Pkg
.CurrentVer() != 0)
1927 foundInstalledInOrGroup
=true;
1931 if (Start
->Type
== pkgCache::Dep::Suggests
)
1933 SuggestsOrList
+= target
;
1934 SuggestsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
1937 if (Start
->Type
== pkgCache::Dep::Recommends
)
1939 RecommendsOrList
+= target
;
1940 RecommendsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
1948 if(foundInstalledInOrGroup
== false)
1950 RecommendsList
+= RecommendsOrList
;
1951 RecommendsVersions
+= RecommendsOrVersions
;
1952 SuggestsList
+= SuggestsOrList
;
1953 SuggestsVersions
+= SuggestsOrVersions
;
1959 ShowList(c1out
,_("Suggested packages:"),SuggestsList
,SuggestsVersions
);
1960 ShowList(c1out
,_("Recommended packages:"),RecommendsList
,RecommendsVersions
);
1964 // if nothing changed in the cache, but only the automark information
1965 // we write the StateFile here, otherwise it will be written in
1967 if (AutoMarkChanged
> 0 &&
1968 Cache
->DelCount() == 0 && Cache
->InstCount() == 0 &&
1969 Cache
->BadCount() == 0 &&
1970 _config
->FindB("APT::Get::Simulate",false) == false)
1971 Cache
->writeStateFile(NULL
);
1973 // See if we need to prompt
1974 if (Cache
->InstCount() == ExpectedInst
&& Cache
->DelCount() == 0)
1975 return InstallPackages(Cache
,false,false);
1977 return InstallPackages(Cache
,false);
1980 // DoDistUpgrade - Automatic smart upgrader /*{{{*/
1981 // ---------------------------------------------------------------------
1982 /* Intelligent upgrader that will install and remove packages at will */
1983 bool DoDistUpgrade(CommandLine
&CmdL
)
1986 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
1989 c0out
<< _("Calculating upgrade... ") << flush
;
1990 if (pkgDistUpgrade(*Cache
) == false)
1992 c0out
<< _("Failed") << endl
;
1993 ShowBroken(c1out
,Cache
,false);
1997 c0out
<< _("Done") << endl
;
1999 return InstallPackages(Cache
,true);
2002 // DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
2003 // ---------------------------------------------------------------------
2004 /* Follows dselect's selections */
2005 bool DoDSelectUpgrade(CommandLine
&CmdL
)
2008 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
2011 pkgDepCache::ActionGroup
group(Cache
);
2013 // Install everything with the install flag set
2014 pkgCache::PkgIterator I
= Cache
->PkgBegin();
2015 for (;I
.end() != true; I
++)
2017 /* Install the package only if it is a new install, the autoupgrader
2018 will deal with the rest */
2019 if (I
->SelectedState
== pkgCache::State::Install
)
2020 Cache
->MarkInstall(I
,false);
2023 /* Now install their deps too, if we do this above then order of
2024 the status file is significant for | groups */
2025 for (I
= Cache
->PkgBegin();I
.end() != true; I
++)
2027 /* Install the package only if it is a new install, the autoupgrader
2028 will deal with the rest */
2029 if (I
->SelectedState
== pkgCache::State::Install
)
2030 Cache
->MarkInstall(I
,true);
2033 // Apply erasures now, they override everything else.
2034 for (I
= Cache
->PkgBegin();I
.end() != true; I
++)
2037 if (I
->SelectedState
== pkgCache::State::DeInstall
||
2038 I
->SelectedState
== pkgCache::State::Purge
)
2039 Cache
->MarkDelete(I
,I
->SelectedState
== pkgCache::State::Purge
);
2042 /* Resolve any problems that dselect created, allupgrade cannot handle
2043 such things. We do so quite agressively too.. */
2044 if (Cache
->BrokenCount() != 0)
2046 pkgProblemResolver
Fix(Cache
);
2048 // Hold back held packages.
2049 if (_config
->FindB("APT::Ignore-Hold",false) == false)
2051 for (pkgCache::PkgIterator I
= Cache
->PkgBegin(); I
.end() == false; I
++)
2053 if (I
->SelectedState
== pkgCache::State::Hold
)
2061 if (Fix
.Resolve() == false)
2063 ShowBroken(c1out
,Cache
,false);
2064 return _error
->Error(_("Internal error, problem resolver broke stuff"));
2068 // Now upgrade everything
2069 if (pkgAllUpgrade(Cache
) == false)
2071 ShowBroken(c1out
,Cache
,false);
2072 return _error
->Error(_("Internal error, problem resolver broke stuff"));
2075 return InstallPackages(Cache
,false);
2078 // DoClean - Remove download archives /*{{{*/
2079 // ---------------------------------------------------------------------
2081 bool DoClean(CommandLine
&CmdL
)
2083 if (_config
->FindB("APT::Get::Simulate") == true)
2085 cout
<< "Del " << _config
->FindDir("Dir::Cache::archives") << "* " <<
2086 _config
->FindDir("Dir::Cache::archives") << "partial/*" << endl
;
2090 // Lock the archive directory
2092 if (_config
->FindB("Debug::NoLocking",false) == false)
2094 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
2095 if (_error
->PendingError() == true)
2096 return _error
->Error(_("Unable to lock the download directory"));
2100 Fetcher
.Clean(_config
->FindDir("Dir::Cache::archives"));
2101 Fetcher
.Clean(_config
->FindDir("Dir::Cache::archives") + "partial/");
2105 // DoAutoClean - Smartly remove downloaded archives /*{{{*/
2106 // ---------------------------------------------------------------------
2107 /* This is similar to clean but it only purges things that cannot be
2108 downloaded, that is old versions of cached packages. */
2109 class LogCleaner
: public pkgArchiveCleaner
2112 virtual void Erase(const char *File
,string Pkg
,string Ver
,struct stat
&St
)
2114 c1out
<< "Del " << Pkg
<< " " << Ver
<< " [" << SizeToStr(St
.st_size
) << "B]" << endl
;
2116 if (_config
->FindB("APT::Get::Simulate") == false)
2121 bool DoAutoClean(CommandLine
&CmdL
)
2123 // Lock the archive directory
2125 if (_config
->FindB("Debug::NoLocking",false) == false)
2127 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
2128 if (_error
->PendingError() == true)
2129 return _error
->Error(_("Unable to lock the download directory"));
2133 if (Cache
.Open() == false)
2138 return Cleaner
.Go(_config
->FindDir("Dir::Cache::archives"),*Cache
) &&
2139 Cleaner
.Go(_config
->FindDir("Dir::Cache::archives") + "partial/",*Cache
);
2142 // DoCheck - Perform the check operation /*{{{*/
2143 // ---------------------------------------------------------------------
2144 /* Opening automatically checks the system, this command is mostly used
2146 bool DoCheck(CommandLine
&CmdL
)
2155 // DoSource - Fetch a source archive /*{{{*/
2156 // ---------------------------------------------------------------------
2157 /* Fetch souce packages */
2165 bool DoSource(CommandLine
&CmdL
)
2168 if (Cache
.Open(false) == false)
2171 if (CmdL
.FileSize() <= 1)
2172 return _error
->Error(_("Must specify at least one package to fetch source for"));
2174 // Read the source list
2176 if (List
.ReadMainList() == false)
2177 return _error
->Error(_("The list of sources could not be read."));
2179 // Create the text record parsers
2180 pkgRecords
Recs(Cache
);
2181 pkgSrcRecords
SrcRecs(List
);
2182 if (_error
->PendingError() == true)
2185 // Create the download object
2186 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
2187 pkgAcquire
Fetcher(&Stat
);
2189 DscFile
*Dsc
= new DscFile
[CmdL
.FileSize()];
2191 // insert all downloaded uris into this set to avoid downloading them
2194 // Load the requestd sources into the fetcher
2196 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
2199 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
2202 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
2205 vector
<pkgSrcRecords::File
> Lst
;
2206 if (Last
->Files(Lst
) == false)
2209 // Load them into the fetcher
2210 for (vector
<pkgSrcRecords::File
>::const_iterator I
= Lst
.begin();
2211 I
!= Lst
.end(); I
++)
2213 // Try to guess what sort of file it is we are getting.
2214 if (I
->Type
== "dsc")
2216 Dsc
[J
].Package
= Last
->Package();
2217 Dsc
[J
].Version
= Last
->Version();
2218 Dsc
[J
].Dsc
= flNotDir(I
->Path
);
2221 // Diff only mode only fetches .diff files
2222 if (_config
->FindB("APT::Get::Diff-Only",false) == true &&
2226 // Tar only mode only fetches .tar files
2227 if (_config
->FindB("APT::Get::Tar-Only",false) == true &&
2231 // Dsc only mode only fetches .dsc files
2232 if (_config
->FindB("APT::Get::Dsc-Only",false) == true &&
2236 // don't download the same uri twice (should this be moved to
2237 // the fetcher interface itself?)
2238 if(queued
.find(Last
->Index().ArchiveURI(I
->Path
)) != queued
.end())
2240 queued
.insert(Last
->Index().ArchiveURI(I
->Path
));
2242 // check if we have a file with that md5 sum already localy
2243 if(!I
->MD5Hash
.empty() && FileExists(flNotDir(I
->Path
)))
2245 FileFd
Fd(flNotDir(I
->Path
), FileFd::ReadOnly
);
2247 sum
.AddFD(Fd
.Fd(), Fd
.Size());
2249 if((string
)sum
.Result() == I
->MD5Hash
)
2251 ioprintf(c1out
,_("Skipping already downloaded file '%s'\n"),
2252 flNotDir(I
->Path
).c_str());
2257 new pkgAcqFile(&Fetcher
,Last
->Index().ArchiveURI(I
->Path
),
2259 Last
->Index().SourceInfo(*Last
,*I
),Src
);
2263 // Display statistics
2264 double FetchBytes
= Fetcher
.FetchNeeded();
2265 double FetchPBytes
= Fetcher
.PartialPresent();
2266 double DebBytes
= Fetcher
.TotalNeeded();
2268 // Check for enough free space
2270 string OutputDir
= ".";
2271 if (statvfs(OutputDir
.c_str(),&Buf
) != 0) {
2272 if (errno
== EOVERFLOW
)
2273 return _error
->WarningE("statvfs",_("Couldn't determine free space in %s"),
2276 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
2278 } else if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
2281 if (statfs(OutputDir
.c_str(),&Stat
) != 0
2282 #if HAVE_STRUCT_STATFS_F_TYPE
2283 || unsigned(Stat
.f_type
) != RAMFS_MAGIC
2286 return _error
->Error(_("You don't have enough free space in %s"),
2291 if (DebBytes
!= FetchBytes
)
2292 ioprintf(c1out
,_("Need to get %sB/%sB of source archives.\n"),
2293 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
2295 ioprintf(c1out
,_("Need to get %sB of source archives.\n"),
2296 SizeToStr(DebBytes
).c_str());
2298 if (_config
->FindB("APT::Get::Simulate",false) == true)
2300 for (unsigned I
= 0; I
!= J
; I
++)
2301 ioprintf(cout
,_("Fetch source %s\n"),Dsc
[I
].Package
.c_str());
2305 // Just print out the uris an exit if the --print-uris flag was used
2306 if (_config
->FindB("APT::Get::Print-URIs") == true)
2308 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
2309 for (; I
!= Fetcher
.UriEnd(); I
++)
2310 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
2311 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
2316 if (Fetcher
.Run() == pkgAcquire::Failed
)
2319 // Print error messages
2320 bool Failed
= false;
2321 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); I
++)
2323 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
2324 (*I
)->Complete
== true)
2327 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
2328 (*I
)->ErrorText
.c_str());
2332 return _error
->Error(_("Failed to fetch some archives."));
2334 if (_config
->FindB("APT::Get::Download-only",false) == true)
2336 c1out
<< _("Download complete and in download only mode") << endl
;
2340 // Unpack the sources
2341 pid_t Process
= ExecFork();
2345 for (unsigned I
= 0; I
!= J
; I
++)
2347 string Dir
= Dsc
[I
].Package
+ '-' + Cache
->VS().UpstreamVersion(Dsc
[I
].Version
.c_str());
2349 // Diff only mode only fetches .diff files
2350 if (_config
->FindB("APT::Get::Diff-Only",false) == true ||
2351 _config
->FindB("APT::Get::Tar-Only",false) == true ||
2352 Dsc
[I
].Dsc
.empty() == true)
2355 // See if the package is already unpacked
2357 if (stat(Dir
.c_str(),&Stat
) == 0 &&
2358 S_ISDIR(Stat
.st_mode
) != 0)
2360 ioprintf(c0out
,_("Skipping unpack of already unpacked source in %s\n"),
2367 snprintf(S
,sizeof(S
),"%s -x %s",
2368 _config
->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2369 Dsc
[I
].Dsc
.c_str());
2372 fprintf(stderr
,_("Unpack command '%s' failed.\n"),S
);
2373 fprintf(stderr
,_("Check if the 'dpkg-dev' package is installed.\n"));
2378 // Try to compile it with dpkg-buildpackage
2379 if (_config
->FindB("APT::Get::Compile",false) == true)
2381 // Call dpkg-buildpackage
2383 snprintf(S
,sizeof(S
),"cd %s && %s %s",
2385 _config
->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2386 _config
->Find("DPkg::Build-Options","-b -uc").c_str());
2390 fprintf(stderr
,_("Build command '%s' failed.\n"),S
);
2399 // Wait for the subprocess
2401 while (waitpid(Process
,&Status
,0) != Process
)
2405 return _error
->Errno("waitpid","Couldn't wait for subprocess");
2408 if (WIFEXITED(Status
) == 0 || WEXITSTATUS(Status
) != 0)
2409 return _error
->Error(_("Child process failed"));
2414 // DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/
2415 // ---------------------------------------------------------------------
2416 /* This function will look at the build depends list of the given source
2417 package and install the necessary packages to make it true, or fail. */
2418 bool DoBuildDep(CommandLine
&CmdL
)
2421 if (Cache
.Open(true) == false)
2424 if (CmdL
.FileSize() <= 1)
2425 return _error
->Error(_("Must specify at least one package to check builddeps for"));
2427 // Read the source list
2429 if (List
.ReadMainList() == false)
2430 return _error
->Error(_("The list of sources could not be read."));
2432 // Create the text record parsers
2433 pkgRecords
Recs(Cache
);
2434 pkgSrcRecords
SrcRecs(List
);
2435 if (_error
->PendingError() == true)
2438 // Create the download object
2439 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
2440 pkgAcquire
Fetcher(&Stat
);
2443 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
2446 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
2448 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
2450 // Process the build-dependencies
2451 vector
<pkgSrcRecords::Parser::BuildDepRec
> BuildDeps
;
2452 if (Last
->BuildDepends(BuildDeps
, _config
->FindB("APT::Get::Arch-Only",true)) == false)
2453 return _error
->Error(_("Unable to get build-dependency information for %s"),Src
.c_str());
2455 // Also ensure that build-essential packages are present
2456 Configuration::Item
const *Opts
= _config
->Tree("APT::Build-Essential");
2459 for (; Opts
; Opts
= Opts
->Next
)
2461 if (Opts
->Value
.empty() == true)
2464 pkgSrcRecords::Parser::BuildDepRec rec
;
2465 rec
.Package
= Opts
->Value
;
2466 rec
.Type
= pkgSrcRecords::Parser::BuildDependIndep
;
2468 BuildDeps
.push_back(rec
);
2471 if (BuildDeps
.size() == 0)
2473 ioprintf(c1out
,_("%s has no build depends.\n"),Src
.c_str());
2477 // Install the requested packages
2478 unsigned int ExpectedInst
= 0;
2479 vector
<pkgSrcRecords::Parser::BuildDepRec
>::iterator D
;
2480 pkgProblemResolver
Fix(Cache
);
2481 bool skipAlternatives
= false; // skip remaining alternatives in an or group
2482 for (D
= BuildDeps
.begin(); D
!= BuildDeps
.end(); D
++)
2484 bool hasAlternatives
= (((*D
).Op
& pkgCache::Dep::Or
) == pkgCache::Dep::Or
);
2486 if (skipAlternatives
== true)
2488 if (!hasAlternatives
)
2489 skipAlternatives
= false; // end of or group
2493 if ((*D
).Type
== pkgSrcRecords::Parser::BuildConflict
||
2494 (*D
).Type
== pkgSrcRecords::Parser::BuildConflictIndep
)
2496 pkgCache::PkgIterator Pkg
= Cache
->FindPkg((*D
).Package
);
2497 // Build-conflicts on unknown packages are silently ignored
2498 if (Pkg
.end() == true)
2501 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2504 * Remove if we have an installed version that satisfies the
2507 if (IV
.end() == false &&
2508 Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2509 TryToInstall(Pkg
,Cache
,Fix
,true,false,ExpectedInst
);
2511 else // BuildDep || BuildDepIndep
2513 pkgCache::PkgIterator Pkg
= Cache
->FindPkg((*D
).Package
);
2514 if (_config
->FindB("Debug::BuildDeps",false) == true)
2515 cout
<< "Looking for " << (*D
).Package
<< "...\n";
2517 if (Pkg
.end() == true)
2519 if (_config
->FindB("Debug::BuildDeps",false) == true)
2520 cout
<< " (not found)" << (*D
).Package
<< endl
;
2522 if (hasAlternatives
)
2525 return _error
->Error(_("%s dependency for %s cannot be satisfied "
2526 "because the package %s cannot be found"),
2527 Last
->BuildDepType((*D
).Type
),Src
.c_str(),
2528 (*D
).Package
.c_str());
2532 * if there are alternatives, we've already picked one, so skip
2535 * TODO: this means that if there's a build-dep on A|B and B is
2536 * installed, we'll still try to install A; more importantly,
2537 * if A is currently broken, we cannot go back and try B. To fix
2538 * this would require we do a Resolve cycle for each package we
2539 * add to the install list. Ugh
2543 * If this is a virtual package, we need to check the list of
2544 * packages that provide it and see if any of those are
2547 pkgCache::PrvIterator Prv
= Pkg
.ProvidesList();
2548 for (; Prv
.end() != true; Prv
++)
2550 if (_config
->FindB("Debug::BuildDeps",false) == true)
2551 cout
<< " Checking provider " << Prv
.OwnerPkg().FullName() << endl
;
2553 if ((*Cache
)[Prv
.OwnerPkg()].InstVerIter(*Cache
).end() == false)
2557 // Get installed version and version we are going to install
2558 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2560 if ((*D
).Version
[0] != '\0') {
2561 // Versioned dependency
2563 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
2565 for (; CV
.end() != true; CV
++)
2567 if (Cache
->VS().CheckDep(CV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2570 if (CV
.end() == true)
2572 if (hasAlternatives
)
2578 return _error
->Error(_("%s dependency for %s cannot be satisfied "
2579 "because no available versions of package %s "
2580 "can satisfy version requirements"),
2581 Last
->BuildDepType((*D
).Type
),Src
.c_str(),
2582 (*D
).Package
.c_str());
2588 // Only consider virtual packages if there is no versioned dependency
2589 if (Prv
.end() == false)
2591 if (_config
->FindB("Debug::BuildDeps",false) == true)
2592 cout
<< " Is provided by installed package " << Prv
.OwnerPkg().FullName() << endl
;
2593 skipAlternatives
= hasAlternatives
;
2598 if (IV
.end() == false)
2600 if (_config
->FindB("Debug::BuildDeps",false) == true)
2601 cout
<< " Is installed\n";
2603 if (Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2605 skipAlternatives
= hasAlternatives
;
2609 if (_config
->FindB("Debug::BuildDeps",false) == true)
2610 cout
<< " ...but the installed version doesn't meet the version requirement\n";
2612 if (((*D
).Op
& pkgCache::Dep::LessEq
) == pkgCache::Dep::LessEq
)
2614 return _error
->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2615 Last
->BuildDepType((*D
).Type
),
2617 Pkg
.FullName(true).c_str());
2622 if (_config
->FindB("Debug::BuildDeps",false) == true)
2623 cout
<< " Trying to install " << (*D
).Package
<< endl
;
2625 if (TryToInstall(Pkg
,Cache
,Fix
,false,false,ExpectedInst
) == true)
2627 // We successfully installed something; skip remaining alternatives
2628 skipAlternatives
= hasAlternatives
;
2629 if(_config
->FindB("APT::Get::Build-Dep-Automatic", false) == true)
2630 Cache
->MarkAuto(Pkg
, true);
2633 else if (hasAlternatives
)
2635 if (_config
->FindB("Debug::BuildDeps",false) == true)
2636 cout
<< " Unsatisfiable, trying alternatives\n";
2641 return _error
->Error(_("Failed to satisfy %s dependency for %s: %s"),
2642 Last
->BuildDepType((*D
).Type
),
2644 (*D
).Package
.c_str());
2649 Fix
.InstallProtect();
2650 if (Fix
.Resolve(true) == false)
2653 // Now we check the state of the packages,
2654 if (Cache
->BrokenCount() != 0)
2656 ShowBroken(cout
, Cache
, false);
2657 return _error
->Error(_("Build-dependencies for %s could not be satisfied."),*I
);
2661 if (InstallPackages(Cache
, false, true) == false)
2662 return _error
->Error(_("Failed to process build dependencies"));
2666 // DoMoo - Never Ask, Never Tell /*{{{*/
2667 // ---------------------------------------------------------------------
2669 bool DoMoo(CommandLine
&CmdL
)
2678 "....\"Have you mooed today?\"...\n";
2683 // ShowHelp - Show a help screen /*{{{*/
2684 // ---------------------------------------------------------------------
2686 bool ShowHelp(CommandLine
&CmdL
)
2688 ioprintf(cout
,_("%s %s for %s compiled on %s %s\n"),PACKAGE
,VERSION
,
2689 COMMON_ARCH
,__DATE__
,__TIME__
);
2691 if (_config
->FindB("version") == true)
2693 cout
<< _("Supported modules:") << endl
;
2695 for (unsigned I
= 0; I
!= pkgVersioningSystem::GlobalListLen
; I
++)
2697 pkgVersioningSystem
*VS
= pkgVersioningSystem::GlobalList
[I
];
2698 if (_system
!= 0 && _system
->VS
== VS
)
2702 cout
<< "Ver: " << VS
->Label
<< endl
;
2704 /* Print out all the packaging systems that will work with
2706 for (unsigned J
= 0; J
!= pkgSystem::GlobalListLen
; J
++)
2708 pkgSystem
*Sys
= pkgSystem::GlobalList
[J
];
2713 if (Sys
->VS
->TestCompatibility(*VS
) == true)
2714 cout
<< "Pkg: " << Sys
->Label
<< " (Priority " << Sys
->Score(*_config
) << ")" << endl
;
2718 for (unsigned I
= 0; I
!= pkgSourceList::Type::GlobalListLen
; I
++)
2720 pkgSourceList::Type
*Type
= pkgSourceList::Type::GlobalList
[I
];
2721 cout
<< " S.L: '" << Type
->Name
<< "' " << Type
->Label
<< endl
;
2724 for (unsigned I
= 0; I
!= pkgIndexFile::Type::GlobalListLen
; I
++)
2726 pkgIndexFile::Type
*Type
= pkgIndexFile::Type::GlobalList
[I
];
2727 cout
<< " Idx: " << Type
->Label
<< endl
;
2734 _("Usage: apt-get [options] command\n"
2735 " apt-get [options] install|remove pkg1 [pkg2 ...]\n"
2736 " apt-get [options] source pkg1 [pkg2 ...]\n"
2738 "apt-get is a simple command line interface for downloading and\n"
2739 "installing packages. The most frequently used commands are update\n"
2743 " update - Retrieve new lists of packages\n"
2744 " upgrade - Perform an upgrade\n"
2745 " install - Install new packages (pkg is libc6 not libc6.deb)\n"
2746 " remove - Remove packages\n"
2747 " autoremove - Remove automatically all unused packages\n"
2748 " purge - Remove packages and config files\n"
2749 " source - Download source archives\n"
2750 " build-dep - Configure build-dependencies for source packages\n"
2751 " dist-upgrade - Distribution upgrade, see apt-get(8)\n"
2752 " dselect-upgrade - Follow dselect selections\n"
2753 " clean - Erase downloaded archive files\n"
2754 " autoclean - Erase old downloaded archive files\n"
2755 " check - Verify that there are no broken dependencies\n"
2758 " -h This help text.\n"
2759 " -q Loggable output - no progress indicator\n"
2760 " -qq No output except for errors\n"
2761 " -d Download only - do NOT install or unpack archives\n"
2762 " -s No-act. Perform ordering simulation\n"
2763 " -y Assume Yes to all queries and do not prompt\n"
2764 " -f Attempt to correct a system with broken dependencies in place\n"
2765 " -m Attempt to continue if archives are unlocatable\n"
2766 " -u Show a list of upgraded packages as well\n"
2767 " -b Build the source package after fetching it\n"
2768 " -V Show verbose version numbers\n"
2769 " -c=? Read this configuration file\n"
2770 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
2771 "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
2772 "pages for more information and options.\n"
2773 " This APT has Super Cow Powers.\n");
2777 // GetInitialize - Initialize things for apt-get /*{{{*/
2778 // ---------------------------------------------------------------------
2780 void GetInitialize()
2782 _config
->Set("quiet",0);
2783 _config
->Set("help",false);
2784 _config
->Set("APT::Get::Download-Only",false);
2785 _config
->Set("APT::Get::Simulate",false);
2786 _config
->Set("APT::Get::Assume-Yes",false);
2787 _config
->Set("APT::Get::Fix-Broken",false);
2788 _config
->Set("APT::Get::Force-Yes",false);
2789 _config
->Set("APT::Get::List-Cleanup",true);
2790 _config
->Set("APT::Get::AutomaticRemove",false);
2793 // SigWinch - Window size change signal handler /*{{{*/
2794 // ---------------------------------------------------------------------
2798 // Riped from GNU ls
2802 if (ioctl(1, TIOCGWINSZ
, &ws
) != -1 && ws
.ws_col
>= 5)
2803 ScreenWidth
= ws
.ws_col
- 1;
2807 int main(int argc
,const char *argv
[]) /*{{{*/
2809 CommandLine::Args Args
[] = {
2810 {'h',"help","help",0},
2811 {'v',"version","version",0},
2812 {'V',"verbose-versions","APT::Get::Show-Versions",0},
2813 {'q',"quiet","quiet",CommandLine::IntLevel
},
2814 {'q',"silent","quiet",CommandLine::IntLevel
},
2815 {'d',"download-only","APT::Get::Download-Only",0},
2816 {'b',"compile","APT::Get::Compile",0},
2817 {'b',"build","APT::Get::Compile",0},
2818 {'s',"simulate","APT::Get::Simulate",0},
2819 {'s',"just-print","APT::Get::Simulate",0},
2820 {'s',"recon","APT::Get::Simulate",0},
2821 {'s',"dry-run","APT::Get::Simulate",0},
2822 {'s',"no-act","APT::Get::Simulate",0},
2823 {'y',"yes","APT::Get::Assume-Yes",0},
2824 {'y',"assume-yes","APT::Get::Assume-Yes",0},
2825 {'f',"fix-broken","APT::Get::Fix-Broken",0},
2826 {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
2827 {'m',"ignore-missing","APT::Get::Fix-Missing",0},
2828 {'t',"target-release","APT::Default-Release",CommandLine::HasArg
},
2829 {'t',"default-release","APT::Default-Release",CommandLine::HasArg
},
2830 {0,"download","APT::Get::Download",0},
2831 {0,"fix-missing","APT::Get::Fix-Missing",0},
2832 {0,"ignore-hold","APT::Ignore-Hold",0},
2833 {0,"upgrade","APT::Get::upgrade",0},
2834 {0,"force-yes","APT::Get::force-yes",0},
2835 {0,"print-uris","APT::Get::Print-URIs",0},
2836 {0,"diff-only","APT::Get::Diff-Only",0},
2837 {0,"debian-only","APT::Get::Diff-Only",0},
2838 {0,"tar-only","APT::Get::Tar-Only",0},
2839 {0,"dsc-only","APT::Get::Dsc-Only",0},
2840 {0,"purge","APT::Get::Purge",0},
2841 {0,"list-cleanup","APT::Get::List-Cleanup",0},
2842 {0,"reinstall","APT::Get::ReInstall",0},
2843 {0,"trivial-only","APT::Get::Trivial-Only",0},
2844 {0,"remove","APT::Get::Remove",0},
2845 {0,"only-source","APT::Get::Only-Source",0},
2846 {0,"arch-only","APT::Get::Arch-Only",0},
2847 {0,"auto-remove","APT::Get::AutomaticRemove",0},
2848 {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
2849 {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean
},
2850 {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
2851 {'c',"config-file",0,CommandLine::ConfigFile
},
2852 {'o',"option",0,CommandLine::ArbItem
},
2854 CommandLine::Dispatch Cmds
[] = {{"update",&DoUpdate
},
2855 {"upgrade",&DoUpgrade
},
2856 {"install",&DoInstall
},
2857 {"remove",&DoInstall
},
2858 {"purge",&DoInstall
},
2859 {"autoremove",&DoInstall
},
2860 {"purge",&DoInstall
},
2861 {"dist-upgrade",&DoDistUpgrade
},
2862 {"dselect-upgrade",&DoDSelectUpgrade
},
2863 {"build-dep",&DoBuildDep
},
2865 {"autoclean",&DoAutoClean
},
2867 {"source",&DoSource
},
2872 // Set up gettext support
2873 setlocale(LC_ALL
,"");
2874 textdomain(PACKAGE
);
2876 // Parse the command line and initialize the package library
2877 CommandLine
CmdL(Args
,_config
);
2878 if (pkgInitConfig(*_config
) == false ||
2879 CmdL
.Parse(argc
,argv
) == false ||
2880 pkgInitSystem(*_config
,_system
) == false)
2882 if (_config
->FindB("version") == true)
2885 _error
->DumpErrors();
2889 // See if the help should be shown
2890 if (_config
->FindB("help") == true ||
2891 _config
->FindB("version") == true ||
2892 CmdL
.FileSize() == 0)
2898 // simulate user-friendly if apt-get has no root privileges
2899 if (getuid() != 0 && _config
->FindB("APT::Get::Simulate") == true)
2901 if (_config
->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
2902 cout
<< _("NOTE: This is only a simulation!\n"
2903 " apt-get needs root privileges for real execution.\n"
2904 " Keep also in mind that locking is deactivated,\n"
2905 " so don't depend on the relevance to the real current situation!"
2907 _config
->Set("Debug::NoLocking",true);
2910 // Deal with stdout not being a tty
2911 if (!isatty(STDOUT_FILENO
) && _config
->FindI("quiet",0) < 1)
2912 _config
->Set("quiet","1");
2914 // Setup the output streams
2915 c0out
.rdbuf(cout
.rdbuf());
2916 c1out
.rdbuf(cout
.rdbuf());
2917 c2out
.rdbuf(cout
.rdbuf());
2918 if (_config
->FindI("quiet",0) > 0)
2919 c0out
.rdbuf(devnull
.rdbuf());
2920 if (_config
->FindI("quiet",0) > 1)
2921 c1out
.rdbuf(devnull
.rdbuf());
2923 // Setup the signals
2924 signal(SIGPIPE
,SIG_IGN
);
2925 signal(SIGWINCH
,SigWinch
);
2928 // Match the operation
2929 CmdL
.DispatchArg(Cmds
);
2931 // Print any errors or warnings found during parsing
2932 if (_error
->empty() == false)
2934 bool Errors
= _error
->PendingError();
2935 _error
->DumpErrors();
2936 return Errors
== true?100:0;