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/statvfs.h>
70 ofstream
devnull("/dev/null");
71 unsigned int ScreenWidth
= 80 - 1; /* - 1 for the cursor */
73 // class CacheFile - Cover class for some dependency cache functions /*{{{*/
74 // ---------------------------------------------------------------------
76 class CacheFile
: public pkgCacheFile
78 static pkgCache
*SortCache
;
79 static int NameComp(const void *a
,const void *b
);
82 pkgCache::Package
**List
;
85 bool CheckDeps(bool AllowBroken
= false);
86 bool BuildCaches(bool WithLock
= true)
88 OpTextProgress
Prog(*_config
);
89 if (pkgCacheFile::BuildCaches(Prog
,WithLock
) == false)
93 bool Open(bool WithLock
= true)
95 OpTextProgress
Prog(*_config
);
96 if (pkgCacheFile::Open(Prog
,WithLock
) == false)
102 bool OpenForInstall()
104 if (_config
->FindB("APT::Get::Print-URIs") == true)
109 CacheFile() : List(0) {};
113 // YnPrompt - Yes No Prompt. /*{{{*/
114 // ---------------------------------------------------------------------
115 /* Returns true on a Yes.*/
116 bool YnPrompt(bool Default
=true)
118 if (_config
->FindB("APT::Get::Assume-Yes",false) == true)
120 c1out
<< _("Y") << endl
;
124 char response
[1024] = "";
125 cin
.getline(response
, sizeof(response
));
130 if (strlen(response
) == 0)
136 Res
= regcomp(&Pattern
, nl_langinfo(YESEXPR
),
137 REG_EXTENDED
|REG_ICASE
|REG_NOSUB
);
141 regerror(Res
,&Pattern
,Error
,sizeof(Error
));
142 return _error
->Error(_("Regex compilation error - %s"),Error
);
145 Res
= regexec(&Pattern
, response
, 0, NULL
, 0);
151 // AnalPrompt - Annoying Yes No Prompt. /*{{{*/
152 // ---------------------------------------------------------------------
153 /* Returns true on a Yes.*/
154 bool AnalPrompt(const char *Text
)
157 cin
.getline(Buf
,sizeof(Buf
));
158 if (strcmp(Buf
,Text
) == 0)
163 // ShowList - Show a list /*{{{*/
164 // ---------------------------------------------------------------------
165 /* This prints out a string of space separated words with a title and
166 a two space indent line wraped to the current screen width. */
167 bool ShowList(ostream
&out
,string Title
,string List
,string VersionsList
)
169 if (List
.empty() == true)
171 // trim trailing space
172 int NonSpace
= List
.find_last_not_of(' ');
175 List
= List
.erase(NonSpace
+ 1);
176 if (List
.empty() == true)
180 // Acount for the leading space
181 int ScreenWidth
= ::ScreenWidth
- 3;
183 out
<< Title
<< endl
;
184 string::size_type Start
= 0;
185 string::size_type VersionsStart
= 0;
186 while (Start
< List
.size())
188 if(_config
->FindB("APT::Get::Show-Versions",false) == true &&
189 VersionsList
.size() > 0) {
190 string::size_type End
;
191 string::size_type VersionsEnd
;
193 End
= List
.find(' ',Start
);
194 VersionsEnd
= VersionsList
.find('\n', VersionsStart
);
196 out
<< " " << string(List
,Start
,End
- Start
) << " (" <<
197 string(VersionsList
,VersionsStart
,VersionsEnd
- VersionsStart
) <<
200 if (End
== string::npos
|| End
< Start
)
201 End
= Start
+ ScreenWidth
;
204 VersionsStart
= VersionsEnd
+ 1;
206 string::size_type End
;
208 if (Start
+ ScreenWidth
>= List
.size())
211 End
= List
.rfind(' ',Start
+ScreenWidth
);
213 if (End
== string::npos
|| End
< Start
)
214 End
= Start
+ ScreenWidth
;
215 out
<< " " << string(List
,Start
,End
- Start
) << endl
;
223 // ShowBroken - Debugging aide /*{{{*/
224 // ---------------------------------------------------------------------
225 /* This prints out the names of all the packages that are broken along
226 with the name of each each broken dependency and a quite version
229 The output looks like:
230 The following packages have unmet dependencies:
231 exim: Depends: libc6 (>= 2.1.94) but 2.1.3-10 is to be installed
232 Depends: libldap2 (>= 2.0.2-2) but it is not going to be installed
233 Depends: libsasl7 but it is not going to be installed
235 void ShowBroken(ostream
&out
,CacheFile
&Cache
,bool Now
)
237 out
<< _("The following packages have unmet dependencies:") << endl
;
238 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
240 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
244 if (Cache
[I
].NowBroken() == false)
249 if (Cache
[I
].InstBroken() == false)
253 // Print out each package and the failed dependencies
254 out
<<" " << I
.Name() << ":";
255 unsigned Indent
= strlen(I
.Name()) + 3;
257 pkgCache::VerIterator Ver
;
260 Ver
= I
.CurrentVer();
262 Ver
= Cache
[I
].InstVerIter(Cache
);
264 if (Ver
.end() == true)
270 for (pkgCache::DepIterator D
= Ver
.DependsList(); D
.end() == false;)
272 // Compute a single dependency element (glob or)
273 pkgCache::DepIterator Start
;
274 pkgCache::DepIterator End
;
275 D
.GlobOr(Start
,End
); // advances D
277 if (Cache
->IsImportantDep(End
) == false)
282 if ((Cache
[End
] & pkgDepCache::DepGNow
) == pkgDepCache::DepGNow
)
287 if ((Cache
[End
] & pkgDepCache::DepGInstall
) == pkgDepCache::DepGInstall
)
295 for (unsigned J
= 0; J
!= Indent
; J
++)
299 if (FirstOr
== false)
301 for (unsigned J
= 0; J
!= strlen(End
.DepType()) + 3; J
++)
305 out
<< ' ' << End
.DepType() << ": ";
308 out
<< Start
.TargetPkg().Name();
310 // Show a quick summary of the version requirements
311 if (Start
.TargetVer() != 0)
312 out
<< " (" << Start
.CompType() << " " << Start
.TargetVer() << ")";
314 /* Show a summary of the target package if possible. In the case
315 of virtual packages we show nothing */
316 pkgCache::PkgIterator Targ
= Start
.TargetPkg();
317 if (Targ
->ProvidesList
== 0)
320 pkgCache::VerIterator Ver
= Cache
[Targ
].InstVerIter(Cache
);
322 Ver
= Targ
.CurrentVer();
324 if (Ver
.end() == false)
327 ioprintf(out
,_("but %s is installed"),Ver
.VerStr());
329 ioprintf(out
,_("but %s is to be installed"),Ver
.VerStr());
333 if (Cache
[Targ
].CandidateVerIter(Cache
).end() == true)
335 if (Targ
->ProvidesList
== 0)
336 out
<< _("but it is not installable");
338 out
<< _("but it is a virtual package");
341 out
<< (Now
?_("but it is not installed"):_("but it is not going to be installed"));
357 // ShowNew - Show packages to newly install /*{{{*/
358 // ---------------------------------------------------------------------
360 void ShowNew(ostream
&out
,CacheFile
&Cache
)
362 /* Print out a list of packages that are going to be installed extra
363 to what the user asked */
366 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
368 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
369 if (Cache
[I
].NewInstall() == true) {
370 List
+= string(I
.Name()) + " ";
371 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
375 ShowList(out
,_("The following NEW packages will be installed:"),List
,VersionsList
);
378 // ShowDel - Show packages to delete /*{{{*/
379 // ---------------------------------------------------------------------
381 void ShowDel(ostream
&out
,CacheFile
&Cache
)
383 /* Print out a list of packages that are going to be removed extra
384 to what the user asked */
387 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
389 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
390 if (Cache
[I
].Delete() == true)
392 if ((Cache
[I
].iFlags
& pkgDepCache::Purge
) == pkgDepCache::Purge
)
393 List
+= string(I
.Name()) + "* ";
395 List
+= string(I
.Name()) + " ";
397 VersionsList
+= string(Cache
[I
].CandVersion
)+ "\n";
401 ShowList(out
,_("The following packages will be REMOVED:"),List
,VersionsList
);
404 // ShowKept - Show kept packages /*{{{*/
405 // ---------------------------------------------------------------------
407 void ShowKept(ostream
&out
,CacheFile
&Cache
)
411 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
413 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
416 if (Cache
[I
].Upgrade() == true || Cache
[I
].Upgradable() == false ||
417 I
->CurrentVer
== 0 || Cache
[I
].Delete() == true)
420 List
+= string(I
.Name()) + " ";
421 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
423 ShowList(out
,_("The following packages have been kept back:"),List
,VersionsList
);
426 // ShowUpgraded - Show upgraded packages /*{{{*/
427 // ---------------------------------------------------------------------
429 void ShowUpgraded(ostream
&out
,CacheFile
&Cache
)
433 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
435 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
438 if (Cache
[I
].Upgrade() == false || Cache
[I
].NewInstall() == true)
441 List
+= string(I
.Name()) + " ";
442 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
444 ShowList(out
,_("The following packages will be upgraded:"),List
,VersionsList
);
447 // ShowDowngraded - Show downgraded packages /*{{{*/
448 // ---------------------------------------------------------------------
450 bool ShowDowngraded(ostream
&out
,CacheFile
&Cache
)
454 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
456 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
459 if (Cache
[I
].Downgrade() == false || Cache
[I
].NewInstall() == true)
462 List
+= string(I
.Name()) + " ";
463 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
465 return ShowList(out
,_("The following packages will be DOWNGRADED:"),List
,VersionsList
);
468 // ShowHold - Show held but changed packages /*{{{*/
469 // ---------------------------------------------------------------------
471 bool ShowHold(ostream
&out
,CacheFile
&Cache
)
475 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
477 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
478 if (Cache
[I
].InstallVer
!= (pkgCache::Version
*)I
.CurrentVer() &&
479 I
->SelectedState
== pkgCache::State::Hold
) {
480 List
+= string(I
.Name()) + " ";
481 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
485 return ShowList(out
,_("The following held packages will be changed:"),List
,VersionsList
);
488 // ShowEssential - Show an essential package warning /*{{{*/
489 // ---------------------------------------------------------------------
490 /* This prints out a warning message that is not to be ignored. It shows
491 all essential packages and their dependents that are to be removed.
492 It is insanely risky to remove the dependents of an essential package! */
493 bool ShowEssential(ostream
&out
,CacheFile
&Cache
)
497 bool *Added
= new bool[Cache
->Head().PackageCount
];
498 for (unsigned int I
= 0; I
!= Cache
->Head().PackageCount
; I
++)
501 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
503 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
504 if ((I
->Flags
& pkgCache::Flag::Essential
) != pkgCache::Flag::Essential
&&
505 (I
->Flags
& pkgCache::Flag::Important
) != pkgCache::Flag::Important
)
508 // The essential package is being removed
509 if (Cache
[I
].Delete() == true)
511 if (Added
[I
->ID
] == false)
514 List
+= string(I
.Name()) + " ";
515 //VersionsList += string(Cache[I].CurVersion) + "\n"; ???
519 if (I
->CurrentVer
== 0)
522 // Print out any essential package depenendents that are to be removed
523 for (pkgCache::DepIterator D
= I
.CurrentVer().DependsList(); D
.end() == false; D
++)
525 // Skip everything but depends
526 if (D
->Type
!= pkgCache::Dep::PreDepends
&&
527 D
->Type
!= pkgCache::Dep::Depends
)
530 pkgCache::PkgIterator P
= D
.SmartTargetPkg();
531 if (Cache
[P
].Delete() == true)
533 if (Added
[P
->ID
] == true)
538 snprintf(S
,sizeof(S
),_("%s (due to %s) "),P
.Name(),I
.Name());
540 //VersionsList += "\n"; ???
546 return ShowList(out
,_("WARNING: The following essential packages will be removed.\n"
547 "This should NOT be done unless you know exactly what you are doing!"),List
,VersionsList
);
551 // Stats - Show some statistics /*{{{*/
552 // ---------------------------------------------------------------------
554 void Stats(ostream
&out
,pkgDepCache
&Dep
)
556 unsigned long Upgrade
= 0;
557 unsigned long Downgrade
= 0;
558 unsigned long Install
= 0;
559 unsigned long ReInstall
= 0;
560 for (pkgCache::PkgIterator I
= Dep
.PkgBegin(); I
.end() == false; I
++)
562 if (Dep
[I
].NewInstall() == true)
566 if (Dep
[I
].Upgrade() == true)
569 if (Dep
[I
].Downgrade() == true)
573 if (Dep
[I
].Delete() == false && (Dep
[I
].iFlags
& pkgDepCache::ReInstall
) == pkgDepCache::ReInstall
)
577 ioprintf(out
,_("%lu upgraded, %lu newly installed, "),
581 ioprintf(out
,_("%lu reinstalled, "),ReInstall
);
583 ioprintf(out
,_("%lu downgraded, "),Downgrade
);
585 ioprintf(out
,_("%lu to remove and %lu not upgraded.\n"),
586 Dep
.DelCount(),Dep
.KeepCount());
588 if (Dep
.BadCount() != 0)
589 ioprintf(out
,_("%lu not fully installed or removed.\n"),
594 // CacheFile::NameComp - QSort compare by name /*{{{*/
595 // ---------------------------------------------------------------------
597 pkgCache
*CacheFile::SortCache
= 0;
598 int CacheFile::NameComp(const void *a
,const void *b
)
600 if (*(pkgCache::Package
**)a
== 0 || *(pkgCache::Package
**)b
== 0)
601 return *(pkgCache::Package
**)a
- *(pkgCache::Package
**)b
;
603 const pkgCache::Package
&A
= **(pkgCache::Package
**)a
;
604 const pkgCache::Package
&B
= **(pkgCache::Package
**)b
;
606 return strcmp(SortCache
->StrP
+ A
.Name
,SortCache
->StrP
+ B
.Name
);
609 // CacheFile::Sort - Sort by name /*{{{*/
610 // ---------------------------------------------------------------------
612 void CacheFile::Sort()
615 List
= new pkgCache::Package
*[Cache
->Head().PackageCount
];
616 memset(List
,0,sizeof(*List
)*Cache
->Head().PackageCount
);
617 pkgCache::PkgIterator I
= Cache
->PkgBegin();
618 for (;I
.end() != true; I
++)
622 qsort(List
,Cache
->Head().PackageCount
,sizeof(*List
),NameComp
);
625 // CacheFile::CheckDeps - Open the cache file /*{{{*/
626 // ---------------------------------------------------------------------
627 /* This routine generates the caches and then opens the dependency cache
628 and verifies that the system is OK. */
629 bool CacheFile::CheckDeps(bool AllowBroken
)
631 if (_error
->PendingError() == true)
634 // Check that the system is OK
635 if (DCache
->DelCount() != 0 || DCache
->InstCount() != 0)
636 return _error
->Error("Internal error, non-zero counts");
638 // Apply corrections for half-installed packages
639 if (pkgApplyStatus(*DCache
) == false)
643 if (DCache
->BrokenCount() == 0 || AllowBroken
== true)
646 // Attempt to fix broken things
647 if (_config
->FindB("APT::Get::Fix-Broken",false) == true)
649 c1out
<< _("Correcting dependencies...") << flush
;
650 if (pkgFixBroken(*DCache
) == false || DCache
->BrokenCount() != 0)
652 c1out
<< _(" failed.") << endl
;
653 ShowBroken(c1out
,*this,true);
655 return _error
->Error(_("Unable to correct dependencies"));
657 if (pkgMinimizeUpgrade(*DCache
) == false)
658 return _error
->Error(_("Unable to minimize the upgrade set"));
660 c1out
<< _(" Done") << endl
;
664 c1out
<< _("You might want to run `apt-get -f install' to correct these.") << endl
;
665 ShowBroken(c1out
,*this,true);
667 return _error
->Error(_("Unmet dependencies. Try using -f."));
673 static bool CheckAuth(pkgAcquire
& Fetcher
)
675 string UntrustedList
;
676 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd(); ++I
)
678 if (!(*I
)->IsTrusted())
680 UntrustedList
+= string((*I
)->ShortDesc()) + " ";
684 if (UntrustedList
== "")
689 ShowList(c2out
,_("WARNING: The following packages cannot be authenticated!"),UntrustedList
,"");
691 if (_config
->FindB("APT::Get::AllowUnauthenticated",false) == true)
693 c2out
<< _("Authentication warning overridden.\n");
697 if (_config
->FindI("quiet",0) < 2
698 && _config
->FindB("APT::Get::Assume-Yes",false) == false)
700 c2out
<< _("Install these packages without verification [y/N]? ") << flush
;
701 if (!YnPrompt(false))
702 return _error
->Error(_("Some packages could not be authenticated"));
706 else if (_config
->FindB("APT::Get::Force-Yes",false) == true)
711 return _error
->Error(_("There are problems and -y was used without --force-yes"));
717 // InstallPackages - Actually download and install the packages /*{{{*/
718 // ---------------------------------------------------------------------
719 /* This displays the informative messages describing what is going to
720 happen and then calls the download routines */
721 bool InstallPackages(CacheFile
&Cache
,bool ShwKept
,bool Ask
= true,
724 if (_config
->FindB("APT::Get::Purge",false) == true)
726 pkgCache::PkgIterator I
= Cache
->PkgBegin();
727 for (; I
.end() == false; I
++)
729 if (I
.Purge() == false && Cache
[I
].Mode
== pkgDepCache::ModeDelete
)
730 Cache
->MarkDelete(I
,true);
735 bool Essential
= false;
737 // Show all the various warning indicators
738 ShowDel(c1out
,Cache
);
739 ShowNew(c1out
,Cache
);
741 ShowKept(c1out
,Cache
);
742 Fail
|= !ShowHold(c1out
,Cache
);
743 if (_config
->FindB("APT::Get::Show-Upgraded",true) == true)
744 ShowUpgraded(c1out
,Cache
);
745 Fail
|= !ShowDowngraded(c1out
,Cache
);
746 if (_config
->FindB("APT::Get::Download-Only",false) == false)
747 Essential
= !ShowEssential(c1out
,Cache
);
752 if (Cache
->BrokenCount() != 0)
754 ShowBroken(c1out
,Cache
,false);
755 return _error
->Error(_("Internal error, InstallPackages was called with broken packages!"));
758 if (Cache
->DelCount() == 0 && Cache
->InstCount() == 0 &&
759 Cache
->BadCount() == 0)
763 if (Cache
->DelCount() != 0 && _config
->FindB("APT::Get::Remove",true) == false)
764 return _error
->Error(_("Packages need to be removed but remove is disabled."));
766 // Run the simulator ..
767 if (_config
->FindB("APT::Get::Simulate") == true)
769 pkgSimulate
PM(Cache
);
770 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
771 pkgPackageManager::OrderResult Res
= PM
.DoInstall(status_fd
);
772 if (Res
== pkgPackageManager::Failed
)
774 if (Res
!= pkgPackageManager::Completed
)
775 return _error
->Error(_("Internal error, Ordering didn't finish"));
779 // Create the text record parser
780 pkgRecords
Recs(Cache
);
781 if (_error
->PendingError() == true)
784 // Lock the archive directory
786 if (_config
->FindB("Debug::NoLocking",false) == false &&
787 _config
->FindB("APT::Get::Print-URIs") == false)
789 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
790 if (_error
->PendingError() == true)
791 return _error
->Error(_("Unable to lock the download directory"));
794 // Create the download object
795 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
796 pkgAcquire
Fetcher(&Stat
);
798 // Read the source list
800 if (List
.ReadMainList() == false)
801 return _error
->Error(_("The list of sources could not be read."));
803 // Create the package manager and prepare to download
804 SPtr
<pkgPackageManager
> PM
= _system
->CreatePM(Cache
);
805 if (PM
->GetArchives(&Fetcher
,&List
,&Recs
) == false ||
806 _error
->PendingError() == true)
809 // Display statistics
810 double FetchBytes
= Fetcher
.FetchNeeded();
811 double FetchPBytes
= Fetcher
.PartialPresent();
812 double DebBytes
= Fetcher
.TotalNeeded();
813 if (DebBytes
!= Cache
->DebSize())
815 c0out
<< DebBytes
<< ',' << Cache
->DebSize() << endl
;
816 c0out
<< _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl
;
820 if (DebBytes
!= FetchBytes
)
821 ioprintf(c1out
,_("Need to get %sB/%sB of archives.\n"),
822 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
824 ioprintf(c1out
,_("Need to get %sB of archives.\n"),
825 SizeToStr(DebBytes
).c_str());
828 if (Cache
->UsrSize() >= 0)
829 ioprintf(c1out
,_("After unpacking %sB of additional disk space will be used.\n"),
830 SizeToStr(Cache
->UsrSize()).c_str());
832 ioprintf(c1out
,_("After unpacking %sB disk space will be freed.\n"),
833 SizeToStr(-1*Cache
->UsrSize()).c_str());
835 if (_error
->PendingError() == true)
838 /* Check for enough free space, but only if we are actually going to
840 if (_config
->FindB("APT::Get::Print-URIs") == false &&
841 _config
->FindB("APT::Get::Download",true) == true)
844 string OutputDir
= _config
->FindDir("Dir::Cache::Archives");
845 if (statvfs(OutputDir
.c_str(),&Buf
) != 0)
846 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
848 if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
849 return _error
->Error(_("You don't have enough free space in %s."),
854 if (_config
->FindI("quiet",0) >= 2 ||
855 _config
->FindB("APT::Get::Assume-Yes",false) == true)
857 if (Fail
== true && _config
->FindB("APT::Get::Force-Yes",false) == false)
858 return _error
->Error(_("There are problems and -y was used without --force-yes"));
861 if (Essential
== true && Safety
== true)
863 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
864 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
866 const char *Prompt
= _("Yes, do as I say!");
868 _("You are about to do something potentially harmful.\n"
869 "To continue type in the phrase '%s'\n"
872 if (AnalPrompt(Prompt
) == false)
874 c2out
<< _("Abort.") << endl
;
880 // Prompt to continue
881 if (Ask
== true || Fail
== true)
883 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
884 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
886 if (_config
->FindI("quiet",0) < 2 &&
887 _config
->FindB("APT::Get::Assume-Yes",false) == false)
889 c2out
<< _("Do you want to continue [Y/n]? ") << flush
;
891 if (YnPrompt() == false)
893 c2out
<< _("Abort.") << endl
;
900 // Just print out the uris an exit if the --print-uris flag was used
901 if (_config
->FindB("APT::Get::Print-URIs") == true)
903 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
904 for (; I
!= Fetcher
.UriEnd(); I
++)
905 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
906 I
->Owner
->FileSize
<< ' ' << I
->Owner
->MD5Sum() << endl
;
910 if (!CheckAuth(Fetcher
))
913 /* Unlock the dpkg lock if we are not going to be doing an install
915 if (_config
->FindB("APT::Get::Download-Only",false) == true)
921 bool Transient
= false;
922 if (_config
->FindB("APT::Get::Download",true) == false)
924 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd();)
926 if ((*I
)->Local
== true)
932 // Close the item and check if it was found in cache
934 if ((*I
)->Complete
== false)
937 // Clear it out of the fetch list
939 I
= Fetcher
.ItemsBegin();
943 if (Fetcher
.Run() == pkgAcquire::Failed
)
948 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); I
++)
950 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
951 (*I
)->Complete
== true)
954 if ((*I
)->Status
== pkgAcquire::Item::StatIdle
)
961 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
962 (*I
)->ErrorText
.c_str());
966 /* If we are in no download mode and missing files and there were
967 'failures' then the user must specify -m. Furthermore, there
968 is no such thing as a transient error in no-download mode! */
969 if (Transient
== true &&
970 _config
->FindB("APT::Get::Download",true) == false)
976 if (_config
->FindB("APT::Get::Download-Only",false) == true)
978 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
979 return _error
->Error(_("Some files failed to download"));
980 c1out
<< _("Download complete and in download only mode") << endl
;
984 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
986 return _error
->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
989 if (Transient
== true && Failed
== true)
990 return _error
->Error(_("--fix-missing and media swapping is not currently supported"));
992 // Try to deal with missing package files
993 if (Failed
== true && PM
->FixMissing() == false)
995 cerr
<< _("Unable to correct missing packages.") << endl
;
996 return _error
->Error(_("Aborting install."));
1000 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
1001 pkgPackageManager::OrderResult Res
= PM
->DoInstall(status_fd
);
1002 if (Res
== pkgPackageManager::Failed
|| _error
->PendingError() == true)
1004 if (Res
== pkgPackageManager::Completed
)
1007 // Reload the fetcher object and loop again for media swapping
1009 if (PM
->GetArchives(&Fetcher
,&List
,&Recs
) == false)
1016 // TryToInstall - Try to install a single package /*{{{*/
1017 // ---------------------------------------------------------------------
1018 /* This used to be inlined in DoInstall, but with the advent of regex package
1019 name matching it was split out.. */
1020 bool TryToInstall(pkgCache::PkgIterator Pkg
,pkgDepCache
&Cache
,
1021 pkgProblemResolver
&Fix
,bool Remove
,bool BrokenFix
,
1022 unsigned int &ExpectedInst
,bool AllowFail
= true)
1024 /* This is a pure virtual package and there is a single available
1026 if (Cache
[Pkg
].CandidateVer
== 0 && Pkg
->ProvidesList
!= 0 &&
1027 Pkg
.ProvidesList()->NextProvides
== 0)
1029 pkgCache::PkgIterator Tmp
= Pkg
.ProvidesList().OwnerPkg();
1030 ioprintf(c1out
,_("Note, selecting %s instead of %s\n"),
1031 Tmp
.Name(),Pkg
.Name());
1035 // Handle the no-upgrade case
1036 if (_config
->FindB("APT::Get::upgrade",true) == false &&
1037 Pkg
->CurrentVer
!= 0)
1039 if (AllowFail
== true)
1040 ioprintf(c1out
,_("Skipping %s, it is already installed and upgrade is not set.\n"),
1045 // Check if there is something at all to install
1046 pkgDepCache::StateCache
&State
= Cache
[Pkg
];
1047 if (Remove
== true && Pkg
->CurrentVer
== 0)
1053 /* We want to continue searching for regex hits, so we return false here
1054 otherwise this is not really an error. */
1055 if (AllowFail
== false)
1058 ioprintf(c1out
,_("Package %s is not installed, so not removed\n"),Pkg
.Name());
1062 if (State
.CandidateVer
== 0 && Remove
== false)
1064 if (AllowFail
== false)
1067 if (Pkg
->ProvidesList
!= 0)
1069 ioprintf(c1out
,_("Package %s is a virtual package provided by:\n"),
1072 pkgCache::PrvIterator I
= Pkg
.ProvidesList();
1073 for (; I
.end() == false; I
++)
1075 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
1077 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer())
1079 if (Cache
[Pkg
].Install() == true && Cache
[Pkg
].NewInstall() == false)
1080 c1out
<< " " << Pkg
.Name() << " " << I
.OwnerVer().VerStr() <<
1081 _(" [Installed]") << endl
;
1083 c1out
<< " " << Pkg
.Name() << " " << I
.OwnerVer().VerStr() << endl
;
1086 c1out
<< _("You should explicitly select one to install.") << endl
;
1091 _("Package %s is not available, but is referred to by another package.\n"
1092 "This may mean that the package is missing, has been obsoleted, or\n"
1093 "is only available from another source\n"),Pkg
.Name());
1096 string VersionsList
;
1097 SPtrArray
<bool> Seen
= new bool[Cache
.Head().PackageCount
];
1098 memset(Seen
,0,Cache
.Head().PackageCount
*sizeof(*Seen
));
1099 pkgCache::DepIterator Dep
= Pkg
.RevDependsList();
1100 for (; Dep
.end() == false; Dep
++)
1102 if (Dep
->Type
!= pkgCache::Dep::Replaces
)
1104 if (Seen
[Dep
.ParentPkg()->ID
] == true)
1106 Seen
[Dep
.ParentPkg()->ID
] = true;
1107 List
+= string(Dep
.ParentPkg().Name()) + " ";
1108 //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
1110 ShowList(c1out
,_("However the following packages replace it:"),List
,VersionsList
);
1113 _error
->Error(_("Package %s has no installation candidate"),Pkg
.Name());
1122 Cache
.MarkDelete(Pkg
,_config
->FindB("APT::Get::Purge",false));
1127 Cache
.MarkInstall(Pkg
,false);
1128 if (State
.Install() == false)
1130 if (_config
->FindB("APT::Get::ReInstall",false) == true)
1132 if (Pkg
->CurrentVer
== 0 || Pkg
.CurrentVer().Downloadable() == false)
1133 ioprintf(c1out
,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
1136 Cache
.SetReInstall(Pkg
,true);
1140 if (AllowFail
== true)
1141 ioprintf(c1out
,_("%s is already the newest version.\n"),
1148 // Install it with autoinstalling enabled.
1149 if (State
.InstBroken() == true && BrokenFix
== false)
1150 Cache
.MarkInstall(Pkg
,true);
1154 // TryToChangeVer - Try to change a candidate version /*{{{*/
1155 // ---------------------------------------------------------------------
1157 bool TryToChangeVer(pkgCache::PkgIterator Pkg
,pkgDepCache
&Cache
,
1158 const char *VerTag
,bool IsRel
)
1160 pkgVersionMatch
Match(VerTag
,(IsRel
== true?pkgVersionMatch::Release
:
1161 pkgVersionMatch::Version
));
1163 pkgCache::VerIterator Ver
= Match
.Find(Pkg
);
1165 if (Ver
.end() == true)
1168 return _error
->Error(_("Release '%s' for '%s' was not found"),
1170 return _error
->Error(_("Version '%s' for '%s' was not found"),
1174 if (strcmp(VerTag
,Ver
.VerStr()) != 0)
1176 ioprintf(c1out
,_("Selected version %s (%s) for %s\n"),
1177 Ver
.VerStr(),Ver
.RelStr().c_str(),Pkg
.Name());
1180 Cache
.SetCandidateVersion(Ver
);
1184 // FindSrc - Find a source record /*{{{*/
1185 // ---------------------------------------------------------------------
1187 pkgSrcRecords::Parser
*FindSrc(const char *Name
,pkgRecords
&Recs
,
1188 pkgSrcRecords
&SrcRecs
,string
&Src
,
1191 // We want to pull the version off the package specification..
1193 string TmpSrc
= Name
;
1194 string::size_type Slash
= TmpSrc
.rfind('=');
1196 // honor default release
1197 string DefRel
= _config
->Find("APT::Default-Release");
1198 pkgCache::PkgIterator Pkg
= Cache
.FindPkg(TmpSrc
);
1200 if (Slash
!= string::npos
)
1202 VerTag
= string(TmpSrc
.begin() + Slash
+ 1,TmpSrc
.end());
1203 TmpSrc
= string(TmpSrc
.begin(),TmpSrc
.begin() + Slash
);
1205 else if(!Pkg
.end() && DefRel
.empty() == false)
1207 // we have a default release, try to locate the pkg. we do it like
1208 // this because GetCandidateVer() will not "downgrade", that means
1209 // "apt-get source -t stable apt" won't work on a unstable system
1210 for (pkgCache::VerIterator Ver
= Pkg
.VersionList(); Ver
.end() == false;
1213 for (pkgCache::VerFileIterator VF
= Ver
.FileList(); VF
.end() == false;
1216 /* If this is the status file, and the current version is not the
1217 version in the status file (ie it is not installed, or somesuch)
1218 then it is not a candidate for installation, ever. This weeds
1219 out bogus entries that may be due to config-file states, or
1221 if ((VF
.File()->Flags
& pkgCache::Flag::NotSource
) ==
1222 pkgCache::Flag::NotSource
&& Pkg
.CurrentVer() != Ver
)
1225 //std::cout << VF.File().Archive() << std::endl;
1226 if(VF
.File().Archive() && (VF
.File().Archive() == DefRel
))
1228 VerTag
= Ver
.VerStr();
1235 /* Lookup the version of the package we would install if we were to
1236 install a version and determine the source package name, then look
1237 in the archive for a source package of the same name. */
1238 if (_config
->FindB("APT::Get::Only-Source") == false)
1240 if (Pkg
.end() == false)
1242 pkgCache::VerIterator Ver
= Cache
.GetCandidateVer(Pkg
);
1243 if (Ver
.end() == false)
1245 pkgRecords::Parser
&Parse
= Recs
.Lookup(Ver
.FileList());
1246 Src
= Parse
.SourcePkg();
1251 // No source package name..
1252 if (Src
.empty() == true)
1256 pkgSrcRecords::Parser
*Last
= 0;
1257 unsigned long Offset
= 0;
1259 bool IsMatch
= false;
1261 // If we are matching by version then we need exact matches to be happy
1262 if (VerTag
.empty() == false)
1265 /* Iterate over all of the hits, which includes the resulting
1266 binary packages in the search */
1267 pkgSrcRecords::Parser
*Parse
;
1269 while ((Parse
= SrcRecs
.Find(Src
.c_str(),false)) != 0)
1271 string Ver
= Parse
->Version();
1273 // Skip name mismatches
1274 if (IsMatch
== true && Parse
->Package() != Src
)
1277 if (VerTag
.empty() == false)
1279 /* Don't want to fall through because we are doing exact version
1281 if (Cache
.VS().CmpVersion(VerTag
,Ver
) != 0)
1285 Offset
= Parse
->Offset();
1289 // Newer version or an exact match
1290 if (Last
== 0 || Cache
.VS().CmpVersion(Version
,Ver
) < 0 ||
1291 (Parse
->Package() == Src
&& IsMatch
== false))
1293 IsMatch
= Parse
->Package() == Src
;
1295 Offset
= Parse
->Offset();
1300 if (Last
== 0 || Last
->Jump(Offset
) == false)
1307 // DoUpdate - Update the package lists /*{{{*/
1308 // ---------------------------------------------------------------------
1310 bool DoUpdate(CommandLine
&CmdL
)
1312 if (CmdL
.FileSize() != 1)
1313 return _error
->Error(_("The update command takes no arguments"));
1315 // Get the source list
1317 if (List
.ReadMainList() == false)
1320 // Lock the list directory
1322 if (_config
->FindB("Debug::NoLocking",false) == false)
1324 Lock
.Fd(GetLock(_config
->FindDir("Dir::State::Lists") + "lock"));
1325 if (_error
->PendingError() == true)
1326 return _error
->Error(_("Unable to lock the list directory"));
1329 // Create the download object
1330 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
1331 pkgAcquire
Fetcher(&Stat
);
1334 // Just print out the uris an exit if the --print-uris flag was used
1335 if (_config
->FindB("APT::Get::Print-URIs") == true)
1337 // Populate it with the source selection and get all Indexes
1339 if (List
.GetIndexes(&Fetcher
,true) == false)
1342 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
1343 for (; I
!= Fetcher
.UriEnd(); I
++)
1344 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
1345 I
->Owner
->FileSize
<< ' ' << I
->Owner
->MD5Sum() << endl
;
1349 // Populate it with the source selection
1350 if (List
.GetIndexes(&Fetcher
) == false)
1354 if (Fetcher
.Run() == pkgAcquire::Failed
)
1357 bool Failed
= false;
1358 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); I
++)
1360 if ((*I
)->Status
== pkgAcquire::Item::StatDone
)
1365 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
1366 (*I
)->ErrorText
.c_str());
1370 // Clean out any old list files
1371 if (!Failed
&& _config
->FindB("APT::Get::List-Cleanup",true) == true)
1373 if (Fetcher
.Clean(_config
->FindDir("Dir::State::lists")) == false ||
1374 Fetcher
.Clean(_config
->FindDir("Dir::State::lists") + "partial/") == false)
1378 // Prepare the cache.
1380 if (Cache
.BuildCaches() == false)
1384 return _error
->Error(_("Some index files failed to download, they have been ignored, or old ones used instead."));
1389 // DoUpgrade - Upgrade all packages /*{{{*/
1390 // ---------------------------------------------------------------------
1391 /* Upgrade all packages without installing new packages or erasing old
1393 bool DoUpgrade(CommandLine
&CmdL
)
1396 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
1400 if (pkgAllUpgrade(Cache
) == false)
1402 ShowBroken(c1out
,Cache
,false);
1403 return _error
->Error(_("Internal error, AllUpgrade broke stuff"));
1406 return InstallPackages(Cache
,true);
1409 // DoInstall - Install packages from the command line /*{{{*/
1410 // ---------------------------------------------------------------------
1411 /* Install named packages */
1412 bool DoInstall(CommandLine
&CmdL
)
1415 if (Cache
.OpenForInstall() == false ||
1416 Cache
.CheckDeps(CmdL
.FileSize() != 1) == false)
1419 // Enter the special broken fixing mode if the user specified arguments
1420 bool BrokenFix
= false;
1421 if (Cache
->BrokenCount() != 0)
1424 unsigned int ExpectedInst
= 0;
1425 unsigned int Packages
= 0;
1426 pkgProblemResolver
Fix(Cache
);
1428 bool DefRemove
= false;
1429 if (strcasecmp(CmdL
.FileList
[0],"remove") == 0)
1432 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++)
1434 // Duplicate the string
1435 unsigned int Length
= strlen(*I
);
1437 if (Length
>= sizeof(S
))
1441 // See if we are removing and special indicators..
1442 bool Remove
= DefRemove
;
1444 bool VerIsRel
= false;
1445 while (Cache
->FindPkg(S
).end() == true)
1447 // Handle an optional end tag indicating what to do
1448 if (Length
>= 1 && S
[Length
- 1] == '-')
1455 if (Length
>= 1 && S
[Length
- 1] == '+')
1462 char *Slash
= strchr(S
,'=');
1470 Slash
= strchr(S
,'/');
1481 // Locate the package
1482 pkgCache::PkgIterator Pkg
= Cache
->FindPkg(S
);
1484 if (Pkg
.end() == true)
1486 // Check if the name is a regex
1488 for (I
= S
; *I
!= 0; I
++)
1489 if (*I
== '?' || *I
== '*' || *I
== '|' ||
1490 *I
== '[' || *I
== '^' || *I
== '$')
1493 return _error
->Error(_("Couldn't find package %s"),S
);
1495 // Regexs must always be confirmed
1496 ExpectedInst
+= 1000;
1498 // Compile the regex pattern
1501 if ((Res
= regcomp(&Pattern
,S
,REG_EXTENDED
| REG_ICASE
|
1505 regerror(Res
,&Pattern
,Error
,sizeof(Error
));
1506 return _error
->Error(_("Regex compilation error - %s"),Error
);
1509 // Run over the matches
1511 for (Pkg
= Cache
->PkgBegin(); Pkg
.end() == false; Pkg
++)
1513 if (regexec(&Pattern
,Pkg
.Name(),0,0,0) != 0)
1516 ioprintf(c1out
,_("Note, selecting %s for regex '%s'\n"),
1520 if (TryToChangeVer(Pkg
,Cache
,VerTag
,VerIsRel
) == false)
1523 Hit
|= TryToInstall(Pkg
,Cache
,Fix
,Remove
,BrokenFix
,
1524 ExpectedInst
,false);
1529 return _error
->Error(_("Couldn't find package %s"),S
);
1534 if (TryToChangeVer(Pkg
,Cache
,VerTag
,VerIsRel
) == false)
1536 if (TryToInstall(Pkg
,Cache
,Fix
,Remove
,BrokenFix
,ExpectedInst
) == false)
1541 /* If we are in the Broken fixing mode we do not attempt to fix the
1542 problems. This is if the user invoked install without -f and gave
1544 if (BrokenFix
== true && Cache
->BrokenCount() != 0)
1546 c1out
<< _("You might want to run `apt-get -f install' to correct these:") << endl
;
1547 ShowBroken(c1out
,Cache
,false);
1549 return _error
->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1552 // Call the scored problem resolver
1553 Fix
.InstallProtect();
1554 if (Fix
.Resolve(true) == false)
1557 // Now we check the state of the packages,
1558 if (Cache
->BrokenCount() != 0)
1561 _("Some packages could not be installed. This may mean that you have\n"
1562 "requested an impossible situation or if you are using the unstable\n"
1563 "distribution that some required packages have not yet been created\n"
1564 "or been moved out of Incoming.") << endl
;
1569 _("Since you only requested a single operation it is extremely likely that\n"
1570 "the package is simply not installable and a bug report against\n"
1571 "that package should be filed.") << endl
;
1574 c1out
<< _("The following information may help to resolve the situation:") << endl
;
1576 ShowBroken(c1out
,Cache
,false);
1577 return _error
->Error(_("Broken packages"));
1580 /* Print out a list of packages that are going to be installed extra
1581 to what the user asked */
1582 if (Cache
->InstCount() != ExpectedInst
)
1585 string VersionsList
;
1586 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
1588 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
1589 if ((*Cache
)[I
].Install() == false)
1593 for (J
= CmdL
.FileList
+ 1; *J
!= 0; J
++)
1594 if (strcmp(*J
,I
.Name()) == 0)
1598 List
+= string(I
.Name()) + " ";
1599 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
1603 ShowList(c1out
,_("The following extra packages will be installed:"),List
,VersionsList
);
1606 /* Print out a list of suggested and recommended packages */
1608 string SuggestsList
, RecommendsList
, List
;
1609 string SuggestsVersions
, RecommendsVersions
;
1610 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
1612 pkgCache::PkgIterator
Pkg(Cache
,Cache
.List
[J
]);
1614 /* Just look at the ones we want to install */
1615 if ((*Cache
)[Pkg
].Install() == false)
1618 // get the recommends/suggests for the candidate ver
1619 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
1620 for (pkgCache::DepIterator D
= CV
.DependsList(); D
.end() == false; )
1622 pkgCache::DepIterator Start
;
1623 pkgCache::DepIterator End
;
1624 D
.GlobOr(Start
,End
); // advances D
1626 string RecommendsOrList
,RecommendsOrVersions
;
1627 string SuggestsOrList
,SuggestsOrVersions
;
1628 bool foundInstalledInOrGroup
= false;
1631 /* Skip if package is installed already, or is about to be */
1632 string target
= string(Start
.TargetPkg().Name()) + " ";
1634 if ((*Start
.TargetPkg()).SelectedState
== pkgCache::State::Install
1635 || Cache
[Start
.TargetPkg()].Install())
1637 foundInstalledInOrGroup
=true;
1641 /* Skip if we already saw it */
1642 if (int(SuggestsList
.find(target
)) != -1 || int(RecommendsList
.find(target
)) != -1)
1644 foundInstalledInOrGroup
=true;
1648 // this is a dep on a virtual pkg, check if any package that provides it
1649 // should be installed
1650 if(Start
.TargetPkg().ProvidesList() != 0)
1652 pkgCache::PrvIterator I
= Start
.TargetPkg().ProvidesList();
1653 for (; I
.end() == false; I
++)
1655 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
1656 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer() &&
1657 Pkg
.CurrentVer() != 0)
1658 foundInstalledInOrGroup
=true;
1662 if (Start
->Type
== pkgCache::Dep::Suggests
)
1664 SuggestsOrList
+= target
;
1665 SuggestsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
1668 if (Start
->Type
== pkgCache::Dep::Recommends
)
1670 RecommendsOrList
+= target
;
1671 RecommendsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
1679 if(foundInstalledInOrGroup
== false)
1681 RecommendsList
+= RecommendsOrList
;
1682 RecommendsVersions
+= RecommendsOrVersions
;
1683 SuggestsList
+= SuggestsOrList
;
1684 SuggestsVersions
+= SuggestsOrVersions
;
1690 ShowList(c1out
,_("Suggested packages:"),SuggestsList
,SuggestsVersions
);
1691 ShowList(c1out
,_("Recommended packages:"),RecommendsList
,RecommendsVersions
);
1695 // See if we need to prompt
1696 if (Cache
->InstCount() == ExpectedInst
&& Cache
->DelCount() == 0)
1697 return InstallPackages(Cache
,false,false);
1699 return InstallPackages(Cache
,false);
1702 // DoDistUpgrade - Automatic smart upgrader /*{{{*/
1703 // ---------------------------------------------------------------------
1704 /* Intelligent upgrader that will install and remove packages at will */
1705 bool DoDistUpgrade(CommandLine
&CmdL
)
1708 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
1711 c0out
<< _("Calculating upgrade... ") << flush
;
1712 if (pkgDistUpgrade(*Cache
) == false)
1714 c0out
<< _("Failed") << endl
;
1715 ShowBroken(c1out
,Cache
,false);
1719 c0out
<< _("Done") << endl
;
1721 return InstallPackages(Cache
,true);
1724 // DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
1725 // ---------------------------------------------------------------------
1726 /* Follows dselect's selections */
1727 bool DoDSelectUpgrade(CommandLine
&CmdL
)
1730 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
1733 // Install everything with the install flag set
1734 pkgCache::PkgIterator I
= Cache
->PkgBegin();
1735 for (;I
.end() != true; I
++)
1737 /* Install the package only if it is a new install, the autoupgrader
1738 will deal with the rest */
1739 if (I
->SelectedState
== pkgCache::State::Install
)
1740 Cache
->MarkInstall(I
,false);
1743 /* Now install their deps too, if we do this above then order of
1744 the status file is significant for | groups */
1745 for (I
= Cache
->PkgBegin();I
.end() != true; I
++)
1747 /* Install the package only if it is a new install, the autoupgrader
1748 will deal with the rest */
1749 if (I
->SelectedState
== pkgCache::State::Install
)
1750 Cache
->MarkInstall(I
,true);
1753 // Apply erasures now, they override everything else.
1754 for (I
= Cache
->PkgBegin();I
.end() != true; I
++)
1757 if (I
->SelectedState
== pkgCache::State::DeInstall
||
1758 I
->SelectedState
== pkgCache::State::Purge
)
1759 Cache
->MarkDelete(I
,I
->SelectedState
== pkgCache::State::Purge
);
1762 /* Resolve any problems that dselect created, allupgrade cannot handle
1763 such things. We do so quite agressively too.. */
1764 if (Cache
->BrokenCount() != 0)
1766 pkgProblemResolver
Fix(Cache
);
1768 // Hold back held packages.
1769 if (_config
->FindB("APT::Ignore-Hold",false) == false)
1771 for (pkgCache::PkgIterator I
= Cache
->PkgBegin(); I
.end() == false; I
++)
1773 if (I
->SelectedState
== pkgCache::State::Hold
)
1781 if (Fix
.Resolve() == false)
1783 ShowBroken(c1out
,Cache
,false);
1784 return _error
->Error(_("Internal error, problem resolver broke stuff"));
1788 // Now upgrade everything
1789 if (pkgAllUpgrade(Cache
) == false)
1791 ShowBroken(c1out
,Cache
,false);
1792 return _error
->Error(_("Internal error, problem resolver broke stuff"));
1795 return InstallPackages(Cache
,false);
1798 // DoClean - Remove download archives /*{{{*/
1799 // ---------------------------------------------------------------------
1801 bool DoClean(CommandLine
&CmdL
)
1803 if (_config
->FindB("APT::Get::Simulate") == true)
1805 cout
<< "Del " << _config
->FindDir("Dir::Cache::archives") << "* " <<
1806 _config
->FindDir("Dir::Cache::archives") << "partial/*" << endl
;
1810 // Lock the archive directory
1812 if (_config
->FindB("Debug::NoLocking",false) == false)
1814 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
1815 if (_error
->PendingError() == true)
1816 return _error
->Error(_("Unable to lock the download directory"));
1820 Fetcher
.Clean(_config
->FindDir("Dir::Cache::archives"));
1821 Fetcher
.Clean(_config
->FindDir("Dir::Cache::archives") + "partial/");
1825 // DoAutoClean - Smartly remove downloaded archives /*{{{*/
1826 // ---------------------------------------------------------------------
1827 /* This is similar to clean but it only purges things that cannot be
1828 downloaded, that is old versions of cached packages. */
1829 class LogCleaner
: public pkgArchiveCleaner
1832 virtual void Erase(const char *File
,string Pkg
,string Ver
,struct stat
&St
)
1834 c1out
<< "Del " << Pkg
<< " " << Ver
<< " [" << SizeToStr(St
.st_size
) << "B]" << endl
;
1836 if (_config
->FindB("APT::Get::Simulate") == false)
1841 bool DoAutoClean(CommandLine
&CmdL
)
1843 // Lock the archive directory
1845 if (_config
->FindB("Debug::NoLocking",false) == false)
1847 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
1848 if (_error
->PendingError() == true)
1849 return _error
->Error(_("Unable to lock the download directory"));
1853 if (Cache
.Open() == false)
1858 return Cleaner
.Go(_config
->FindDir("Dir::Cache::archives"),*Cache
) &&
1859 Cleaner
.Go(_config
->FindDir("Dir::Cache::archives") + "partial/",*Cache
);
1862 // DoCheck - Perform the check operation /*{{{*/
1863 // ---------------------------------------------------------------------
1864 /* Opening automatically checks the system, this command is mostly used
1866 bool DoCheck(CommandLine
&CmdL
)
1875 // DoSource - Fetch a source archive /*{{{*/
1876 // ---------------------------------------------------------------------
1877 /* Fetch souce packages */
1885 bool DoSource(CommandLine
&CmdL
)
1888 if (Cache
.Open(false) == false)
1891 if (CmdL
.FileSize() <= 1)
1892 return _error
->Error(_("Must specify at least one package to fetch source for"));
1894 // Read the source list
1896 if (List
.ReadMainList() == false)
1897 return _error
->Error(_("The list of sources could not be read."));
1899 // Create the text record parsers
1900 pkgRecords
Recs(Cache
);
1901 pkgSrcRecords
SrcRecs(List
);
1902 if (_error
->PendingError() == true)
1905 // Create the download object
1906 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
1907 pkgAcquire
Fetcher(&Stat
);
1909 DscFile
*Dsc
= new DscFile
[CmdL
.FileSize()];
1911 // insert all downloaded uris into this set to avoid downloading them
1914 // Load the requestd sources into the fetcher
1916 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
1919 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
1922 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
1925 vector
<pkgSrcRecords::File
> Lst
;
1926 if (Last
->Files(Lst
) == false)
1929 // Load them into the fetcher
1930 for (vector
<pkgSrcRecords::File
>::const_iterator I
= Lst
.begin();
1931 I
!= Lst
.end(); I
++)
1933 // Try to guess what sort of file it is we are getting.
1934 if (I
->Type
== "dsc")
1936 Dsc
[J
].Package
= Last
->Package();
1937 Dsc
[J
].Version
= Last
->Version();
1938 Dsc
[J
].Dsc
= flNotDir(I
->Path
);
1941 // Diff only mode only fetches .diff files
1942 if (_config
->FindB("APT::Get::Diff-Only",false) == true &&
1946 // Tar only mode only fetches .tar files
1947 if (_config
->FindB("APT::Get::Tar-Only",false) == true &&
1951 // don't download the same uri twice (should this be moved to
1952 // the fetcher interface itself?)
1953 if(queued
.find(Last
->Index().ArchiveURI(I
->Path
)) != queued
.end())
1955 queued
.insert(Last
->Index().ArchiveURI(I
->Path
));
1957 // check if we have a file with that md5 sum already localy
1958 if(!I
->MD5Hash
.empty() && FileExists(flNotDir(I
->Path
)))
1960 FileFd
Fd(flNotDir(I
->Path
), FileFd::ReadOnly
);
1962 sum
.AddFD(Fd
.Fd(), Fd
.Size());
1964 if((string
)sum
.Result() == I
->MD5Hash
)
1966 ioprintf(c1out
,_("Skipping already downloaded file '%s'\n"),
1967 flNotDir(I
->Path
).c_str());
1972 new pkgAcqFile(&Fetcher
,Last
->Index().ArchiveURI(I
->Path
),
1974 Last
->Index().SourceInfo(*Last
,*I
),Src
);
1978 // Display statistics
1979 double FetchBytes
= Fetcher
.FetchNeeded();
1980 double FetchPBytes
= Fetcher
.PartialPresent();
1981 double DebBytes
= Fetcher
.TotalNeeded();
1983 // Check for enough free space
1985 string OutputDir
= ".";
1986 if (statvfs(OutputDir
.c_str(),&Buf
) != 0)
1987 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
1989 if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
1990 return _error
->Error(_("You don't have enough free space in %s"),
1994 if (DebBytes
!= FetchBytes
)
1995 ioprintf(c1out
,_("Need to get %sB/%sB of source archives.\n"),
1996 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
1998 ioprintf(c1out
,_("Need to get %sB of source archives.\n"),
1999 SizeToStr(DebBytes
).c_str());
2001 if (_config
->FindB("APT::Get::Simulate",false) == true)
2003 for (unsigned I
= 0; I
!= J
; I
++)
2004 ioprintf(cout
,_("Fetch source %s\n"),Dsc
[I
].Package
.c_str());
2008 // Just print out the uris an exit if the --print-uris flag was used
2009 if (_config
->FindB("APT::Get::Print-URIs") == true)
2011 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
2012 for (; I
!= Fetcher
.UriEnd(); I
++)
2013 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
2014 I
->Owner
->FileSize
<< ' ' << I
->Owner
->MD5Sum() << endl
;
2019 if (Fetcher
.Run() == pkgAcquire::Failed
)
2022 // Print error messages
2023 bool Failed
= false;
2024 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); I
++)
2026 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
2027 (*I
)->Complete
== true)
2030 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
2031 (*I
)->ErrorText
.c_str());
2035 return _error
->Error(_("Failed to fetch some archives."));
2037 if (_config
->FindB("APT::Get::Download-only",false) == true)
2039 c1out
<< _("Download complete and in download only mode") << endl
;
2043 // Unpack the sources
2044 pid_t Process
= ExecFork();
2048 for (unsigned I
= 0; I
!= J
; I
++)
2050 string Dir
= Dsc
[I
].Package
+ '-' + Cache
->VS().UpstreamVersion(Dsc
[I
].Version
.c_str());
2052 // Diff only mode only fetches .diff files
2053 if (_config
->FindB("APT::Get::Diff-Only",false) == true ||
2054 _config
->FindB("APT::Get::Tar-Only",false) == true ||
2055 Dsc
[I
].Dsc
.empty() == true)
2058 // See if the package is already unpacked
2060 if (stat(Dir
.c_str(),&Stat
) == 0 &&
2061 S_ISDIR(Stat
.st_mode
) != 0)
2063 ioprintf(c0out
,_("Skipping unpack of already unpacked source in %s\n"),
2070 snprintf(S
,sizeof(S
),"%s -x %s",
2071 _config
->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2072 Dsc
[I
].Dsc
.c_str());
2075 fprintf(stderr
,_("Unpack command '%s' failed.\n"),S
);
2076 fprintf(stderr
,_("Check if the 'dpkg-dev' package is installed.\n"));
2081 // Try to compile it with dpkg-buildpackage
2082 if (_config
->FindB("APT::Get::Compile",false) == true)
2084 // Call dpkg-buildpackage
2086 snprintf(S
,sizeof(S
),"cd %s && %s %s",
2088 _config
->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2089 _config
->Find("DPkg::Build-Options","-b -uc").c_str());
2093 fprintf(stderr
,_("Build command '%s' failed.\n"),S
);
2102 // Wait for the subprocess
2104 while (waitpid(Process
,&Status
,0) != Process
)
2108 return _error
->Errno("waitpid","Couldn't wait for subprocess");
2111 if (WIFEXITED(Status
) == 0 || WEXITSTATUS(Status
) != 0)
2112 return _error
->Error(_("Child process failed"));
2117 // DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/
2118 // ---------------------------------------------------------------------
2119 /* This function will look at the build depends list of the given source
2120 package and install the necessary packages to make it true, or fail. */
2121 bool DoBuildDep(CommandLine
&CmdL
)
2124 if (Cache
.Open(true) == false)
2127 if (CmdL
.FileSize() <= 1)
2128 return _error
->Error(_("Must specify at least one package to check builddeps for"));
2130 // Read the source list
2132 if (List
.ReadMainList() == false)
2133 return _error
->Error(_("The list of sources could not be read."));
2135 // Create the text record parsers
2136 pkgRecords
Recs(Cache
);
2137 pkgSrcRecords
SrcRecs(List
);
2138 if (_error
->PendingError() == true)
2141 // Create the download object
2142 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
2143 pkgAcquire
Fetcher(&Stat
);
2146 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
2149 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
2151 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
2153 // Process the build-dependencies
2154 vector
<pkgSrcRecords::Parser::BuildDepRec
> BuildDeps
;
2155 if (Last
->BuildDepends(BuildDeps
, _config
->FindB("APT::Get::Arch-Only",false)) == false)
2156 return _error
->Error(_("Unable to get build-dependency information for %s"),Src
.c_str());
2158 // Also ensure that build-essential packages are present
2159 Configuration::Item
const *Opts
= _config
->Tree("APT::Build-Essential");
2162 for (; Opts
; Opts
= Opts
->Next
)
2164 if (Opts
->Value
.empty() == true)
2167 pkgSrcRecords::Parser::BuildDepRec rec
;
2168 rec
.Package
= Opts
->Value
;
2169 rec
.Type
= pkgSrcRecords::Parser::BuildDependIndep
;
2171 BuildDeps
.push_back(rec
);
2174 if (BuildDeps
.size() == 0)
2176 ioprintf(c1out
,_("%s has no build depends.\n"),Src
.c_str());
2180 // Install the requested packages
2181 unsigned int ExpectedInst
= 0;
2182 vector
<pkgSrcRecords::Parser::BuildDepRec
>::iterator D
;
2183 pkgProblemResolver
Fix(Cache
);
2184 bool skipAlternatives
= false; // skip remaining alternatives in an or group
2185 for (D
= BuildDeps
.begin(); D
!= BuildDeps
.end(); D
++)
2187 bool hasAlternatives
= (((*D
).Op
& pkgCache::Dep::Or
) == pkgCache::Dep::Or
);
2189 if (skipAlternatives
== true)
2191 if (!hasAlternatives
)
2192 skipAlternatives
= false; // end of or group
2196 if ((*D
).Type
== pkgSrcRecords::Parser::BuildConflict
||
2197 (*D
).Type
== pkgSrcRecords::Parser::BuildConflictIndep
)
2199 pkgCache::PkgIterator Pkg
= Cache
->FindPkg((*D
).Package
);
2200 // Build-conflicts on unknown packages are silently ignored
2201 if (Pkg
.end() == true)
2204 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2207 * Remove if we have an installed version that satisfies the
2210 if (IV
.end() == false &&
2211 Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2212 TryToInstall(Pkg
,Cache
,Fix
,true,false,ExpectedInst
);
2214 else // BuildDep || BuildDepIndep
2216 pkgCache::PkgIterator Pkg
= Cache
->FindPkg((*D
).Package
);
2217 if (_config
->FindB("Debug::BuildDeps",false) == true)
2218 cout
<< "Looking for " << (*D
).Package
<< "...\n";
2220 if (Pkg
.end() == true)
2222 if (_config
->FindB("Debug::BuildDeps",false) == true)
2223 cout
<< " (not found)" << (*D
).Package
<< endl
;
2225 if (hasAlternatives
)
2228 return _error
->Error(_("%s dependency for %s cannot be satisfied "
2229 "because the package %s cannot be found"),
2230 Last
->BuildDepType((*D
).Type
),Src
.c_str(),
2231 (*D
).Package
.c_str());
2235 * if there are alternatives, we've already picked one, so skip
2238 * TODO: this means that if there's a build-dep on A|B and B is
2239 * installed, we'll still try to install A; more importantly,
2240 * if A is currently broken, we cannot go back and try B. To fix
2241 * this would require we do a Resolve cycle for each package we
2242 * add to the install list. Ugh
2246 * If this is a virtual package, we need to check the list of
2247 * packages that provide it and see if any of those are
2250 pkgCache::PrvIterator Prv
= Pkg
.ProvidesList();
2251 for (; Prv
.end() != true; Prv
++)
2253 if (_config
->FindB("Debug::BuildDeps",false) == true)
2254 cout
<< " Checking provider " << Prv
.OwnerPkg().Name() << endl
;
2256 if ((*Cache
)[Prv
.OwnerPkg()].InstVerIter(*Cache
).end() == false)
2260 // Get installed version and version we are going to install
2261 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2263 if ((*D
).Version
[0] != '\0') {
2264 // Versioned dependency
2266 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
2268 for (; CV
.end() != true; CV
++)
2270 if (Cache
->VS().CheckDep(CV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2273 if (CV
.end() == true)
2274 if (hasAlternatives
)
2280 return _error
->Error(_("%s dependency for %s cannot be satisfied "
2281 "because no available versions of package %s "
2282 "can satisfy version requirements"),
2283 Last
->BuildDepType((*D
).Type
),Src
.c_str(),
2284 (*D
).Package
.c_str());
2289 // Only consider virtual packages if there is no versioned dependency
2290 if (Prv
.end() == false)
2292 if (_config
->FindB("Debug::BuildDeps",false) == true)
2293 cout
<< " Is provided by installed package " << Prv
.OwnerPkg().Name() << endl
;
2294 skipAlternatives
= hasAlternatives
;
2299 if (IV
.end() == false)
2301 if (_config
->FindB("Debug::BuildDeps",false) == true)
2302 cout
<< " Is installed\n";
2304 if (Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2306 skipAlternatives
= hasAlternatives
;
2310 if (_config
->FindB("Debug::BuildDeps",false) == true)
2311 cout
<< " ...but the installed version doesn't meet the version requirement\n";
2313 if (((*D
).Op
& pkgCache::Dep::LessEq
) == pkgCache::Dep::LessEq
)
2315 return _error
->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2316 Last
->BuildDepType((*D
).Type
),
2323 if (_config
->FindB("Debug::BuildDeps",false) == true)
2324 cout
<< " Trying to install " << (*D
).Package
<< endl
;
2326 if (TryToInstall(Pkg
,Cache
,Fix
,false,false,ExpectedInst
) == true)
2328 // We successfully installed something; skip remaining alternatives
2329 skipAlternatives
= hasAlternatives
;
2332 else if (hasAlternatives
)
2334 if (_config
->FindB("Debug::BuildDeps",false) == true)
2335 cout
<< " Unsatisfiable, trying alternatives\n";
2340 return _error
->Error(_("Failed to satisfy %s dependency for %s: %s"),
2341 Last
->BuildDepType((*D
).Type
),
2343 (*D
).Package
.c_str());
2348 Fix
.InstallProtect();
2349 if (Fix
.Resolve(true) == false)
2352 // Now we check the state of the packages,
2353 if (Cache
->BrokenCount() != 0)
2354 return _error
->Error(_("Build-dependencies for %s could not be satisfied."),*I
);
2357 if (InstallPackages(Cache
, false, true) == false)
2358 return _error
->Error(_("Failed to process build dependencies"));
2363 // DoMoo - Never Ask, Never Tell /*{{{*/
2364 // ---------------------------------------------------------------------
2366 bool DoMoo(CommandLine
&CmdL
)
2375 "....\"Have you mooed today?\"...\n";
2380 // ShowHelp - Show a help screen /*{{{*/
2381 // ---------------------------------------------------------------------
2383 bool ShowHelp(CommandLine
&CmdL
)
2385 ioprintf(cout
,_("%s %s for %s %s compiled on %s %s\n"),PACKAGE
,VERSION
,
2386 COMMON_OS
,COMMON_CPU
,__DATE__
,__TIME__
);
2388 if (_config
->FindB("version") == true)
2390 cout
<< _("Supported modules:") << endl
;
2392 for (unsigned I
= 0; I
!= pkgVersioningSystem::GlobalListLen
; I
++)
2394 pkgVersioningSystem
*VS
= pkgVersioningSystem::GlobalList
[I
];
2395 if (_system
!= 0 && _system
->VS
== VS
)
2399 cout
<< "Ver: " << VS
->Label
<< endl
;
2401 /* Print out all the packaging systems that will work with
2403 for (unsigned J
= 0; J
!= pkgSystem::GlobalListLen
; J
++)
2405 pkgSystem
*Sys
= pkgSystem::GlobalList
[J
];
2410 if (Sys
->VS
->TestCompatibility(*VS
) == true)
2411 cout
<< "Pkg: " << Sys
->Label
<< " (Priority " << Sys
->Score(*_config
) << ")" << endl
;
2415 for (unsigned I
= 0; I
!= pkgSourceList::Type::GlobalListLen
; I
++)
2417 pkgSourceList::Type
*Type
= pkgSourceList::Type::GlobalList
[I
];
2418 cout
<< " S.L: '" << Type
->Name
<< "' " << Type
->Label
<< endl
;
2421 for (unsigned I
= 0; I
!= pkgIndexFile::Type::GlobalListLen
; I
++)
2423 pkgIndexFile::Type
*Type
= pkgIndexFile::Type::GlobalList
[I
];
2424 cout
<< " Idx: " << Type
->Label
<< endl
;
2431 _("Usage: apt-get [options] command\n"
2432 " apt-get [options] install|remove pkg1 [pkg2 ...]\n"
2433 " apt-get [options] source pkg1 [pkg2 ...]\n"
2435 "apt-get is a simple command line interface for downloading and\n"
2436 "installing packages. The most frequently used commands are update\n"
2440 " update - Retrieve new lists of packages\n"
2441 " upgrade - Perform an upgrade\n"
2442 " install - Install new packages (pkg is libc6 not libc6.deb)\n"
2443 " remove - Remove packages\n"
2444 " source - Download source archives\n"
2445 " build-dep - Configure build-dependencies for source packages\n"
2446 " dist-upgrade - Distribution upgrade, see apt-get(8)\n"
2447 " dselect-upgrade - Follow dselect selections\n"
2448 " clean - Erase downloaded archive files\n"
2449 " autoclean - Erase old downloaded archive files\n"
2450 " check - Verify that there are no broken dependencies\n"
2453 " -h This help text.\n"
2454 " -q Loggable output - no progress indicator\n"
2455 " -qq No output except for errors\n"
2456 " -d Download only - do NOT install or unpack archives\n"
2457 " -s No-act. Perform ordering simulation\n"
2458 " -y Assume Yes to all queries and do not prompt\n"
2459 " -f Attempt to continue if the integrity check fails\n"
2460 " -m Attempt to continue if archives are unlocatable\n"
2461 " -u Show a list of upgraded packages as well\n"
2462 " -b Build the source package after fetching it\n"
2463 " -V Show verbose version numbers\n"
2464 " -c=? Read this configuration file\n"
2465 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
2466 "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
2467 "pages for more information and options.\n"
2468 " This APT has Super Cow Powers.\n");
2472 // GetInitialize - Initialize things for apt-get /*{{{*/
2473 // ---------------------------------------------------------------------
2475 void GetInitialize()
2477 _config
->Set("quiet",0);
2478 _config
->Set("help",false);
2479 _config
->Set("APT::Get::Download-Only",false);
2480 _config
->Set("APT::Get::Simulate",false);
2481 _config
->Set("APT::Get::Assume-Yes",false);
2482 _config
->Set("APT::Get::Fix-Broken",false);
2483 _config
->Set("APT::Get::Force-Yes",false);
2484 _config
->Set("APT::Get::List-Cleanup",true);
2487 // SigWinch - Window size change signal handler /*{{{*/
2488 // ---------------------------------------------------------------------
2492 // Riped from GNU ls
2496 if (ioctl(1, TIOCGWINSZ
, &ws
) != -1 && ws
.ws_col
>= 5)
2497 ScreenWidth
= ws
.ws_col
- 1;
2502 int main(int argc
,const char *argv
[])
2504 CommandLine::Args Args
[] = {
2505 {'h',"help","help",0},
2506 {'v',"version","version",0},
2507 {'V',"verbose-versions","APT::Get::Show-Versions",0},
2508 {'q',"quiet","quiet",CommandLine::IntLevel
},
2509 {'q',"silent","quiet",CommandLine::IntLevel
},
2510 {'d',"download-only","APT::Get::Download-Only",0},
2511 {'b',"compile","APT::Get::Compile",0},
2512 {'b',"build","APT::Get::Compile",0},
2513 {'s',"simulate","APT::Get::Simulate",0},
2514 {'s',"just-print","APT::Get::Simulate",0},
2515 {'s',"recon","APT::Get::Simulate",0},
2516 {'s',"dry-run","APT::Get::Simulate",0},
2517 {'s',"no-act","APT::Get::Simulate",0},
2518 {'y',"yes","APT::Get::Assume-Yes",0},
2519 {'y',"assume-yes","APT::Get::Assume-Yes",0},
2520 {'f',"fix-broken","APT::Get::Fix-Broken",0},
2521 {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
2522 {'m',"ignore-missing","APT::Get::Fix-Missing",0},
2523 {'t',"target-release","APT::Default-Release",CommandLine::HasArg
},
2524 {'t',"default-release","APT::Default-Release",CommandLine::HasArg
},
2525 {0,"download","APT::Get::Download",0},
2526 {0,"fix-missing","APT::Get::Fix-Missing",0},
2527 {0,"ignore-hold","APT::Ignore-Hold",0},
2528 {0,"upgrade","APT::Get::upgrade",0},
2529 {0,"force-yes","APT::Get::force-yes",0},
2530 {0,"print-uris","APT::Get::Print-URIs",0},
2531 {0,"diff-only","APT::Get::Diff-Only",0},
2532 {0,"tar-only","APT::Get::tar-Only",0},
2533 {0,"purge","APT::Get::Purge",0},
2534 {0,"list-cleanup","APT::Get::List-Cleanup",0},
2535 {0,"reinstall","APT::Get::ReInstall",0},
2536 {0,"trivial-only","APT::Get::Trivial-Only",0},
2537 {0,"remove","APT::Get::Remove",0},
2538 {0,"only-source","APT::Get::Only-Source",0},
2539 {0,"arch-only","APT::Get::Arch-Only",0},
2540 {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
2541 {'c',"config-file",0,CommandLine::ConfigFile
},
2542 {'o',"option",0,CommandLine::ArbItem
},
2544 CommandLine::Dispatch Cmds
[] = {{"update",&DoUpdate
},
2545 {"upgrade",&DoUpgrade
},
2546 {"install",&DoInstall
},
2547 {"remove",&DoInstall
},
2548 {"dist-upgrade",&DoDistUpgrade
},
2549 {"dselect-upgrade",&DoDSelectUpgrade
},
2550 {"build-dep",&DoBuildDep
},
2552 {"autoclean",&DoAutoClean
},
2554 {"source",&DoSource
},
2559 // Set up gettext support
2560 setlocale(LC_ALL
,"");
2561 textdomain(PACKAGE
);
2563 // Parse the command line and initialize the package library
2564 CommandLine
CmdL(Args
,_config
);
2565 if (pkgInitConfig(*_config
) == false ||
2566 CmdL
.Parse(argc
,argv
) == false ||
2567 pkgInitSystem(*_config
,_system
) == false)
2569 if (_config
->FindB("version") == true)
2572 _error
->DumpErrors();
2576 // See if the help should be shown
2577 if (_config
->FindB("help") == true ||
2578 _config
->FindB("version") == true ||
2579 CmdL
.FileSize() == 0)
2585 // Deal with stdout not being a tty
2586 if (!isatty(STDOUT_FILENO
) && _config
->FindI("quiet",0) < 1)
2587 _config
->Set("quiet","1");
2589 // Setup the output streams
2590 c0out
.rdbuf(cout
.rdbuf());
2591 c1out
.rdbuf(cout
.rdbuf());
2592 c2out
.rdbuf(cout
.rdbuf());
2593 if (_config
->FindI("quiet",0) > 0)
2594 c0out
.rdbuf(devnull
.rdbuf());
2595 if (_config
->FindI("quiet",0) > 1)
2596 c1out
.rdbuf(devnull
.rdbuf());
2598 // Setup the signals
2599 signal(SIGPIPE
,SIG_IGN
);
2600 signal(SIGWINCH
,SigWinch
);
2603 // Match the operation
2604 CmdL
.DispatchArg(Cmds
);
2606 // Print any errors or warnings found during parsing
2607 if (_error
->empty() == false)
2609 bool Errors
= _error
->PendingError();
2610 _error
->DumpErrors();
2611 return Errors
== true?100:0;