HCoop / ntk / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
don't suggest held packages as they are installed (Closes: #578135)
[ntk/apt.git] / cmdline / apt-get.cc
CommitLineData
5ec427c2
AL		 1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
640c5d94 3// $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
5ec427c2
AL		 4/* ######################################################################
5
6 apt-get - Cover for dpkg
7
8 This is an allout cover for dpkg implementing a safer front end. It is
9 based largely on libapt-pkg.
10
11 The syntax is different,
12 apt-get [opt] command [things]
13 Where command is:
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
19 a new distribution.
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
23 the partial dir too
24
25 ##################################################################### */
26 /*}}}*/
27// Include Files /*{{{*/
0a8e3465
AL		 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>
0a8e3465 33#include <apt-pkg/algorithms.h>
0919e3f9 34#include <apt-pkg/acquire-item.h>
cdcc6d34 35#include <apt-pkg/strutl.h>
1bc849af 36#include <apt-pkg/clean.h>
36375005
AL		 37#include <apt-pkg/srcrecords.h>
38#include <apt-pkg/version.h>
2d11135a 39#include <apt-pkg/cachefile.h>
b2e465d6 40#include <apt-pkg/sptr.h>
092ae175 41#include <apt-pkg/md5.h>
b2e465d6
AL		 42#include <apt-pkg/versionmatch.h>
43
0a8e3465 44#include <config.h>
b2e465d6 45#include <apti18n.h>
0a8e3465 46
0919e3f9
AL		 47#include "acqprogress.h"
48
092ae175 49#include <set>
233c2b66 50#include <locale.h>
c8ca0ce1 51#include <langinfo.h>
90f057fd 52#include <fstream>
d7827aca
AL		 53#include <termios.h>
54#include <sys/ioctl.h>
1bc849af 55#include <sys/stat.h>
885d204b 56#include <sys/statfs.h>
101030ab 57#include <sys/statvfs.h>
d7827aca 58#include <signal.h>
65a1e968 59#include <unistd.h>
3e3221ba 60#include <stdio.h>
d6e79b75 61#include <errno.h>
c373c37a 62#include <regex.h>
54676e1a 63#include <sys/wait.h>
afb1e2e3 64#include <sstream>
0a8e3465
AL		 65 /*}}}*/
66
885d204b
OS		 67#define RAMFS_MAGIC 0x858458f6
68
076d01b0
AL		 69using namespace std;
70
71ostream c0out(0);
72ostream c1out(0);
73ostream c2out(0);
0a8e3465 74ofstream devnull("/dev/null");
463870e4 75unsigned int ScreenWidth = 80 - 1; /* - 1 for the cursor */
0a8e3465 76
1089ca89
AL		 77// class CacheFile - Cover class for some dependency cache functions /*{{{*/
78// ---------------------------------------------------------------------
79/* */
80class CacheFile : public pkgCacheFile
81{
82 static pkgCache *SortCache;
83 static int NameComp(const void *a,const void *b);
84
85 public:
86 pkgCache::Package **List;
87
88 void Sort();
89 bool CheckDeps(bool AllowBroken = false);
0077d829
AL		 90 bool BuildCaches(bool WithLock = true)
91 {
92 OpTextProgress Prog(*_config);
93 if (pkgCacheFile::BuildCaches(Prog,WithLock) == false)
94 return false;
95 return true;
96 }
1089ca89
AL		 97 bool Open(bool WithLock = true)
98 {
99 OpTextProgress Prog(*_config);
100 if (pkgCacheFile::Open(Prog,WithLock) == false)
101 return false;
102 Sort();
b2e465d6 103
1089ca89
AL		 104 return true;
105 };
c37b9502
AL		 106 bool OpenForInstall()
107 {
108 if (_config->FindB("APT::Get::Print-URIs") == true)
079a992d 109 return Open(false);
c37b9502 110 else
079a992d 111 return Open(true);
c37b9502 112 }
1089ca89 113 CacheFile() : List(0) {};
7a9f09bd
MV		 114 ~CacheFile() {
115 delete[] List;
116 }
1089ca89
AL		 117};
118 /*}}}*/
119
a6568219
AL		 120// YnPrompt - Yes No Prompt. /*{{{*/
121// ---------------------------------------------------------------------
122/* Returns true on a Yes.*/
7db98ffc 123bool YnPrompt(bool Default=true)
a6568219
AL		 124{
125 if (_config->FindB("APT::Get::Assume-Yes",false) == true)
126 {
10cda9fe 127 c1out << _("Y") << endl;
a6568219
AL		 128 return true;
129 }
10cda9fe
AL		 130
131 char response[1024] = "";
132 cin.getline(response, sizeof(response));
133
134 if (!cin)
b2e465d6 135 return false;
10cda9fe
AL		 136
137 if (strlen(response) == 0)
7db98ffc 138 return Default;
10cda9fe
AL		 139
140 regex_t Pattern;
141 int Res;
142
143 Res = regcomp(&Pattern, nl_langinfo(YESEXPR),
144 REG_EXTENDED|REG_ICASE|REG_NOSUB);
145
146 if (Res != 0) {
147 char Error[300];
148 regerror(Res,&Pattern,Error,sizeof(Error));
149 return _error->Error(_("Regex compilation error - %s"),Error);
150 }
a6568219 151
10cda9fe
AL		 152 Res = regexec(&Pattern, response, 0, NULL, 0);
153 if (Res == 0)
154 return true;
155 return false;
a6568219
AL		 156}
157 /*}}}*/
6f86c974
AL		 158// AnalPrompt - Annoying Yes No Prompt. /*{{{*/
159// ---------------------------------------------------------------------
160/* Returns true on a Yes.*/
161bool AnalPrompt(const char *Text)
162{
163 char Buf[1024];
164 cin.getline(Buf,sizeof(Buf));
165 if (strcmp(Buf,Text) == 0)
166 return true;
167 return false;
168}
169 /*}}}*/
0a8e3465
AL		 170// ShowList - Show a list /*{{{*/
171// ---------------------------------------------------------------------
b2e465d6 172/* This prints out a string of space separated words with a title and
0a8e3465 173 a two space indent line wraped to the current screen width. */
ac625538 174bool ShowList(ostream &out,string Title,string List,string VersionsList)
0a8e3465
AL		 175{
176 if (List.empty() == true)
83d89a9f 177 return true;
4968036c
AL		 178 // trim trailing space
179 int NonSpace = List.find_last_not_of(' ');
180 if (NonSpace != -1)
181 {
182 List = List.erase(NonSpace + 1);
183 if (List.empty() == true)
184 return true;
185 }
0a8e3465
AL		 186
187 // Acount for the leading space
188 int ScreenWidth = ::ScreenWidth - 3;
189
190 out << Title << endl;
191 string::size_type Start = 0;
ac625538 192 string::size_type VersionsStart = 0;
0a8e3465
AL		 193 while (Start < List.size())
194 {
ac625538
AL		 195 if(_config->FindB("APT::Get::Show-Versions",false) == true &&
196 VersionsList.size() > 0) {
197 string::size_type End;
198 string::size_type VersionsEnd;
199
200 End = List.find(' ',Start);
201 VersionsEnd = VersionsList.find('\n', VersionsStart);
202
203 out << " " << string(List,Start,End - Start) << " (" <<
204 string(VersionsList,VersionsStart,VersionsEnd - VersionsStart) <<
205 ")" << endl;
03b9be80
AL		 206
207 if (End == string::npos || End < Start)
208 End = Start + ScreenWidth;
209
ac625538
AL		 210 Start = End + 1;
211 VersionsStart = VersionsEnd + 1;
212 } else {
213 string::size_type End;
214
215 if (Start + ScreenWidth >= List.size())
216 End = List.size();
217 else
218 End = List.rfind(' ',Start+ScreenWidth);
219
220 if (End == string::npos || End < Start)
221 End = Start + ScreenWidth;
222 out << " " << string(List,Start,End - Start) << endl;
223 Start = End + 1;
224 }
0a8e3465 225 }
ac625538 226
83d89a9f 227 return false;
0a8e3465
AL		 228}
229 /*}}}*/
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
b2e465d6
AL		 234 description.
235
236 The output looks like:
677cbcbc 237 The following packages have unmet dependencies:
b2e465d6
AL		 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
241 */
421c8d10 242void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
0a8e3465 243{
677cbcbc 244 out << _("The following packages have unmet dependencies:") << endl;
1089ca89 245 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
0a8e3465 246 {
1089ca89
AL		 247 pkgCache::PkgIterator I(Cache,Cache.List[J]);
248
079a992d
AL		 249 if (Now == true)
250 {
251 if (Cache[I].NowBroken() == false)
252 continue;
253 }
254 else
255 {
256 if (Cache[I].InstBroken() == false)
257 continue;
258 }
259
303a1703 260 // Print out each package and the failed dependencies
75ce2062
DK		 261 out << " " << I.FullName(true) << " :";
262 unsigned const Indent = I.FullName(true).size() + 3;
303a1703 263 bool First = true;
079a992d
AL		 264 pkgCache::VerIterator Ver;
265
266 if (Now == true)
267 Ver = I.CurrentVer();
268 else
269 Ver = Cache[I].InstVerIter(Cache);
270
271 if (Ver.end() == true)
0a8e3465 272 {
079a992d 273 out << endl;
303a1703
AL		 274 continue;
275 }
276
079a992d 277 for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false;)
303a1703 278 {
30e1eab5
AL		 279 // Compute a single dependency element (glob or)
280 pkgCache::DepIterator Start;
281 pkgCache::DepIterator End;
d20333af 282 D.GlobOr(Start,End); // advances D
76fbce56 283
079a992d 284 if (Cache->IsImportantDep(End) == false)
303a1703 285 continue;
079a992d
AL		 286
287 if (Now == true)
288 {
289 if ((Cache[End] & pkgDepCache::DepGNow) == pkgDepCache::DepGNow)
290 continue;
291 }
292 else
293 {
294 if ((Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall)
295 continue;
296 }
297
648e3cb4
AL		 298 bool FirstOr = true;
299 while (1)
0a8e3465 300 {
648e3cb4
AL		 301 if (First == false)
302 for (unsigned J = 0; J != Indent; J++)
303 out << ' ';
304 First = false;
305
306 if (FirstOr == false)
307 {
308 for (unsigned J = 0; J != strlen(End.DepType()) + 3; J++)
309 out << ' ';
310 }
0a8e3465 311 else
648e3cb4
AL		 312 out << ' ' << End.DepType() << ": ";
313 FirstOr = false;
314
75ce2062 315 out << Start.TargetPkg().FullName(true);
648e3cb4
AL		 316
317 // Show a quick summary of the version requirements
318 if (Start.TargetVer() != 0)
b2e465d6 319 out << " (" << Start.CompType() << " " << Start.TargetVer() << ")";
648e3cb4
AL		 320
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)
7e798dd7 325 {
b2e465d6 326 out << ' ';
648e3cb4 327 pkgCache::VerIterator Ver = Cache[Targ].InstVerIter(Cache);
f0ec51c2
AL		 328 if (Now == true)
329 Ver = Targ.CurrentVer();
079a992d 330
648e3cb4 331 if (Ver.end() == false)
b2e465d6
AL		 332 {
333 if (Now == true)
334 ioprintf(out,_("but %s is installed"),Ver.VerStr());
335 else
336 ioprintf(out,_("but %s is to be installed"),Ver.VerStr());
337 }
648e3cb4 338 else
303a1703 339 {
648e3cb4
AL		 340 if (Cache[Targ].CandidateVerIter(Cache).end() == true)
341 {
342 if (Targ->ProvidesList == 0)
b2e465d6 343 out << _("but it is not installable");
648e3cb4 344 else
b2e465d6 345 out << _("but it is a virtual package");
648e3cb4 346 }
303a1703 347 else
b2e465d6 348 out << (Now?_("but it is not installed"):_("but it is not going to be installed"));
648e3cb4
AL		 349 }
350 }
351
352 if (Start != End)
b2e465d6 353 out << _(" or");
648e3cb4
AL		 354 out << endl;
355
356 if (Start == End)
357 break;
358 Start++;
359 }
303a1703 360 }
0a8e3465
AL		 361 }
362}
363 /*}}}*/
364// ShowNew - Show packages to newly install /*{{{*/
365// ---------------------------------------------------------------------
366/* */
1089ca89 367void ShowNew(ostream &out,CacheFile &Cache)
0a8e3465 368{
89260e53 369 /* Print out a list of packages that are going to be installed extra
0a8e3465 370 to what the user asked */
0a8e3465 371 string List;
ac625538 372 string VersionsList;
1089ca89
AL		 373 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
374 {
375 pkgCache::PkgIterator I(Cache,Cache.List[J]);
ac625538 376 if (Cache[I].NewInstall() == true) {
803ea2a8
DK		 377 if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
378 continue;
75ce2062 379 List += I.FullName(true) + " ";
ac625538
AL		 380 VersionsList += string(Cache[I].CandVersion) + "\n";
381 }
1089ca89
AL		 382 }
383
ac625538 384 ShowList(out,_("The following NEW packages will be installed:"),List,VersionsList);
0a8e3465
AL		 385}
386 /*}}}*/
387// ShowDel - Show packages to delete /*{{{*/
388// ---------------------------------------------------------------------
389/* */
1089ca89 390void ShowDel(ostream &out,CacheFile &Cache)
0a8e3465
AL		 391{
392 /* Print out a list of packages that are going to be removed extra
393 to what the user asked */
0a8e3465 394 string List;
ac625538 395 string VersionsList;
1089ca89 396 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
fc4b5c9f 397 {
1089ca89
AL		 398 pkgCache::PkgIterator I(Cache,Cache.List[J]);
399 if (Cache[I].Delete() == true)
fc4b5c9f 400 {
803ea2a8
DK		 401 if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
402 continue;
1089ca89 403 if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
75ce2062 404 List += I.FullName(true) + "* ";
fc4b5c9f 405 else
75ce2062 406 List += I.FullName(true) + " ";
ac625538
AL		 407
408 VersionsList += string(Cache[I].CandVersion)+ "\n";
fc4b5c9f
AL		 409 }
410 }
3d615484 411
ac625538 412 ShowList(out,_("The following packages will be REMOVED:"),List,VersionsList);
0a8e3465
AL		 413}
414 /*}}}*/
415// ShowKept - Show kept packages /*{{{*/
416// ---------------------------------------------------------------------
417/* */
f292686b 418void ShowKept(ostream &out,CacheFile &Cache)
0a8e3465 419{
0a8e3465 420 string List;
ac625538 421 string VersionsList;
f292686b 422 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
0a8e3465 423 {
f292686b
AL		 424 pkgCache::PkgIterator I(Cache,Cache.List[J]);
425
0a8e3465 426 // Not interesting
f292686b
AL		 427 if (Cache[I].Upgrade() == true || Cache[I].Upgradable() == false ||
428 I->CurrentVer == 0 || Cache[I].Delete() == true)
0a8e3465
AL		 429 continue;
430
75ce2062 431 List += I.FullName(true) + " ";
ac625538 432 VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
0a8e3465 433 }
aee7bceb 434 ShowList(out,_("The following packages have been kept back:"),List,VersionsList);
0a8e3465
AL		 435}
436 /*}}}*/
437// ShowUpgraded - Show upgraded packages /*{{{*/
438// ---------------------------------------------------------------------
439/* */
1089ca89 440void ShowUpgraded(ostream &out,CacheFile &Cache)
0a8e3465 441{
0a8e3465 442 string List;
ac625538 443 string VersionsList;
1089ca89 444 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
0a8e3465 445 {
1089ca89
AL		 446 pkgCache::PkgIterator I(Cache,Cache.List[J]);
447
0a8e3465 448 // Not interesting
1089ca89 449 if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true)
0a8e3465 450 continue;
803ea2a8
DK		 451 if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
452 continue;
453
75ce2062 454 List += I.FullName(true) + " ";
ac625538 455 VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
0a8e3465 456 }
aee7bceb 457 ShowList(out,_("The following packages will be upgraded:"),List,VersionsList);
b2e465d6
AL		 458}
459 /*}}}*/
460// ShowDowngraded - Show downgraded packages /*{{{*/
461// ---------------------------------------------------------------------
462/* */
463bool ShowDowngraded(ostream &out,CacheFile &Cache)
464{
465 string List;
ac625538 466 string VersionsList;
b2e465d6
AL		 467 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
468 {
469 pkgCache::PkgIterator I(Cache,Cache.List[J]);
470
471 // Not interesting
472 if (Cache[I].Downgrade() == false || Cache[I].NewInstall() == true)
473 continue;
803ea2a8
DK		 474 if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
475 continue;
476
75ce2062 477 List += I.FullName(true) + " ";
ac625538 478 VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
b2e465d6 479 }
aee7bceb 480 return ShowList(out,_("The following packages will be DOWNGRADED:"),List,VersionsList);
0a8e3465
AL		 481}
482 /*}}}*/
483// ShowHold - Show held but changed packages /*{{{*/
484// ---------------------------------------------------------------------
485/* */
1089ca89 486bool ShowHold(ostream &out,CacheFile &Cache)
0a8e3465 487{
0a8e3465 488 string List;
ac625538 489 string VersionsList;
1089ca89 490 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
0a8e3465 491 {
1089ca89
AL		 492 pkgCache::PkgIterator I(Cache,Cache.List[J]);
493 if (Cache[I].InstallVer != (pkgCache::Version *)I.CurrentVer() &&
ac625538 494 I->SelectedState == pkgCache::State::Hold) {
75ce2062 495 List += I.FullName(true) + " ";
ac625538
AL		 496 VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
497 }
0a8e3465
AL		 498 }
499
ac625538 500 return ShowList(out,_("The following held packages will be changed:"),List,VersionsList);
0a8e3465
AL		 501}
502 /*}}}*/
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! */
1089ca89 508bool ShowEssential(ostream &out,CacheFile &Cache)
0a8e3465 509{
0a8e3465 510 string List;
ac625538 511 string VersionsList;
b2e465d6
AL		 512 bool *Added = new bool[Cache->Head().PackageCount];
513 for (unsigned int I = 0; I != Cache->Head().PackageCount; I++)
0a8e3465
AL		 514 Added[I] = false;
515
1089ca89 516 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
0a8e3465 517 {
1089ca89 518 pkgCache::PkgIterator I(Cache,Cache.List[J]);
b2e465d6
AL		 519 if ((I->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential &&
520 (I->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important)
0a8e3465
AL		 521 continue;
522
523 // The essential package is being removed
1089ca89 524 if (Cache[I].Delete() == true)
0a8e3465
AL		 525 {
526 if (Added[I->ID] == false)
527 {
528 Added[I->ID] = true;
75ce2062 529 List += I.FullName(true) + " ";
ac625538 530 //VersionsList += string(Cache[I].CurVersion) + "\n"; ???
0a8e3465
AL		 531 }
532 }
533
534 if (I->CurrentVer == 0)
535 continue;
536
537 // Print out any essential package depenendents that are to be removed
b2e465d6 538 for (pkgCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; D++)
0a8e3465 539 {
3e3221ba
AL		 540 // Skip everything but depends
541 if (D->Type != pkgCache::Dep::PreDepends &&
542 D->Type != pkgCache::Dep::Depends)
543 continue;
544
0a8e3465 545 pkgCache::PkgIterator P = D.SmartTargetPkg();
1089ca89 546 if (Cache[P].Delete() == true)
0a8e3465
AL		 547 {
548 if (Added[P->ID] == true)
549 continue;
550 Added[P->ID] = true;
3e3221ba
AL		 551
552 char S[300];
75ce2062 553 snprintf(S,sizeof(S),_("%s (due to %s) "),P.FullName(true).c_str(),I.FullName(true).c_str());
3e3221ba 554 List += S;
ac625538 555 //VersionsList += "\n"; ???
0a8e3465
AL		 556 }
557 }
558 }
559
83d89a9f 560 delete [] Added;
080bf1be 561 return ShowList(out,_("WARNING: The following essential packages will be removed.\n"
ac625538 562 "This should NOT be done unless you know exactly what you are doing!"),List,VersionsList);
0a8e3465 563}
7db98ffc 564
0a8e3465
AL		 565 /*}}}*/
566// Stats - Show some statistics /*{{{*/
567// ---------------------------------------------------------------------
568/* */
569void Stats(ostream &out,pkgDepCache &Dep)
570{
571 unsigned long Upgrade = 0;
b2e465d6 572 unsigned long Downgrade = 0;
0a8e3465 573 unsigned long Install = 0;
d0c59649 574 unsigned long ReInstall = 0;
0a8e3465
AL		 575 for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; I++)
576 {
42d71ab5
DK		 577 if (pkgCache::VerIterator(Dep, Dep[I].CandidateVer).Pseudo() == true)
578 continue;
579
0a8e3465
AL		 580 if (Dep[I].NewInstall() == true)
581 Install++;
582 else
b2e465d6 583 {
0a8e3465
AL		 584 if (Dep[I].Upgrade() == true)
585 Upgrade++;
b2e465d6
AL		 586 else
587 if (Dep[I].Downgrade() == true)
588 Downgrade++;
589 }
590
d0c59649
AL		 591 if (Dep[I].Delete() == false && (Dep[I].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall)
592 ReInstall++;
0a8e3465
AL		 593 }
594
2adb5fda 595 ioprintf(out,_("%lu upgraded, %lu newly installed, "),
b2e465d6
AL		 596 Upgrade,Install);
597
d0c59649 598 if (ReInstall != 0)
b2e465d6
AL		 599 ioprintf(out,_("%lu reinstalled, "),ReInstall);
600 if (Downgrade != 0)
601 ioprintf(out,_("%lu downgraded, "),Downgrade);
0a8e3465 602
2d425135 603 ioprintf(out,_("%lu to remove and %lu not upgraded.\n"),
b2e465d6
AL		 604 Dep.DelCount(),Dep.KeepCount());
605
0a8e3465 606 if (Dep.BadCount() != 0)
2adb5fda 607 ioprintf(out,_("%lu not fully installed or removed.\n"),
b2e465d6 608 Dep.BadCount());
0a8e3465
AL		 609}
610 /*}}}*/
1089ca89 611// CacheFile::NameComp - QSort compare by name /*{{{*/
0a8e3465
AL		 612// ---------------------------------------------------------------------
613/* */
1089ca89
AL		 614pkgCache *CacheFile::SortCache = 0;
615int CacheFile::NameComp(const void *a,const void *b)
0a8e3465 616{
8508b1df
AL		 617 if (*(pkgCache::Package **)a == 0 || *(pkgCache::Package **)b == 0)
618 return *(pkgCache::Package **)a - *(pkgCache::Package **)b;
0a8e3465 619
1089ca89
AL		 620 const pkgCache::Package &A = **(pkgCache::Package **)a;
621 const pkgCache::Package &B = **(pkgCache::Package **)b;
622
623 return strcmp(SortCache->StrP + A.Name,SortCache->StrP + B.Name);
624}
625 /*}}}*/
626// CacheFile::Sort - Sort by name /*{{{*/
627// ---------------------------------------------------------------------
628/* */
629void CacheFile::Sort()
630{
631 delete [] List;
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++)
636 List[I->ID] = I;
637
638 SortCache = *this;
639 qsort(List,Cache->Head().PackageCount,sizeof(*List),NameComp);
640}
0a8e3465 641 /*}}}*/
b2e465d6 642// CacheFile::CheckDeps - Open the cache file /*{{{*/
0a8e3465
AL		 643// ---------------------------------------------------------------------
644/* This routine generates the caches and then opens the dependency cache
645 and verifies that the system is OK. */
2d11135a 646bool CacheFile::CheckDeps(bool AllowBroken)
0a8e3465 647{
4ef9a929
MV		 648 bool FixBroken = _config->FindB("APT::Get::Fix-Broken",false);
649
d38b7b3d
AL		 650 if (_error->PendingError() == true)
651 return false;
0a8e3465 652
0a8e3465 653 // Check that the system is OK
b2e465d6 654 if (DCache->DelCount() != 0 || DCache->InstCount() != 0)
db0db9fe 655 return _error->Error("Internal error, non-zero counts");
0a8e3465
AL		 656
657 // Apply corrections for half-installed packages
b2e465d6 658 if (pkgApplyStatus(*DCache) == false)
0a8e3465
AL		 659 return false;
660
4ef9a929
MV		 661 if (_config->FindB("APT::Get::Fix-Policy-Broken",false) == true)
662 {
663 FixBroken = true;
664 if ((DCache->PolicyBrokenCount() > 0))
665 {
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)
7610bb3d 669 DCache->MarkInstall(I,true,0, false, true);
4ef9a929
MV		 670 }
671 }
672
0a8e3465 673 // Nothing is broken
b2e465d6 674 if (DCache->BrokenCount() == 0 || AllowBroken == true)
0a8e3465
AL		 675 return true;
676
677 // Attempt to fix broken things
4ef9a929 678 if (FixBroken == true)
0a8e3465 679 {
b2e465d6
AL		 680 c1out << _("Correcting dependencies...") << flush;
681 if (pkgFixBroken(*DCache) == false || DCache->BrokenCount() != 0)
0a8e3465 682 {
b2e465d6 683 c1out << _(" failed.") << endl;
421c8d10 684 ShowBroken(c1out,*this,true);
0a8e3465 685
b2e465d6 686 return _error->Error(_("Unable to correct dependencies"));
0a8e3465 687 }
b2e465d6
AL		 688 if (pkgMinimizeUpgrade(*DCache) == false)
689 return _error->Error(_("Unable to minimize the upgrade set"));
0a8e3465 690
b2e465d6 691 c1out << _(" Done") << endl;
0a8e3465
AL		 692 }
693 else
694 {
b5647402 695 c1out << _("You might want to run 'apt-get -f install' to correct these.") << endl;
421c8d10 696 ShowBroken(c1out,*this,true);
0a8e3465 697
b2e465d6 698 return _error->Error(_("Unmet dependencies. Try using -f."));
0a8e3465
AL		 699 }
700
701 return true;
702}
92fcbfc1
DK		 703 /*}}}*/
704// CheckAuth - check if each download comes form a trusted source /*{{{*/
705// ---------------------------------------------------------------------
706/* */
7db98ffc
MZ		 707static bool CheckAuth(pkgAcquire& Fetcher)
708{
709 string UntrustedList;
710 for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd(); ++I)
711 {
712 if (!(*I)->IsTrusted())
713 {
714 UntrustedList += string((*I)->ShortDesc()) + " ";
715 }
716 }
717
718 if (UntrustedList == "")
719 {
720 return true;
721 }
722
723 ShowList(c2out,_("WARNING: The following packages cannot be authenticated!"),UntrustedList,"");
724
725 if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
726 {
2a7e07c7 727 c2out << _("Authentication warning overridden.\n");
7db98ffc
MZ		 728 return true;
729 }
730
731 if (_config->FindI("quiet",0) < 2
732 && _config->FindB("APT::Get::Assume-Yes",false) == false)
733 {
db0db9fe 734 c2out << _("Install these packages without verification [y/N]? ") << flush;
7db98ffc
MZ		 735 if (!YnPrompt(false))
736 return _error->Error(_("Some packages could not be authenticated"));
737
738 return true;
739 }
740 else if (_config->FindB("APT::Get::Force-Yes",false) == true)
741 {
742 return true;
743 }
744
745 return _error->Error(_("There are problems and -y was used without --force-yes"));
746}
0a8e3465 747 /*}}}*/
0a8e3465
AL		 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 */
a3eaf954 752bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
80fbda96 753 bool Safety = true)
0a8e3465 754{
fc4b5c9f
AL		 755 if (_config->FindB("APT::Get::Purge",false) == true)
756 {
757 pkgCache::PkgIterator I = Cache->PkgBegin();
758 for (; I.end() == false; I++)
d556d1a1
AL		 759 {
760 if (I.Purge() == false && Cache[I].Mode == pkgDepCache::ModeDelete)
761 Cache->MarkDelete(I,true);
762 }
fc4b5c9f
AL		 763 }
764
83d89a9f 765 bool Fail = false;
6f86c974 766 bool Essential = false;
83d89a9f 767
a6568219 768 // Show all the various warning indicators
0a8e3465
AL		 769 ShowDel(c1out,Cache);
770 ShowNew(c1out,Cache);
771 if (ShwKept == true)
772 ShowKept(c1out,Cache);
7a215bee 773 Fail |= !ShowHold(c1out,Cache);
906fbf88 774 if (_config->FindB("APT::Get::Show-Upgraded",true) == true)
0a8e3465 775 ShowUpgraded(c1out,Cache);
b2e465d6 776 Fail |= !ShowDowngraded(c1out,Cache);
5d1d0738
AL		 777 if (_config->FindB("APT::Get::Download-Only",false) == false)
778 Essential = !ShowEssential(c1out,Cache);
6f86c974 779 Fail |= Essential;
0a8e3465 780 Stats(c1out,Cache);
7db98ffc 781
0a8e3465 782 // Sanity check
d38b7b3d 783 if (Cache->BrokenCount() != 0)
0a8e3465 784 {
421c8d10 785 ShowBroken(c1out,Cache,false);
2a7e07c7 786 return _error->Error(_("Internal error, InstallPackages was called with broken packages!"));
0a8e3465
AL		 787 }
788
d0c59649 789 if (Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
d38b7b3d 790 Cache->BadCount() == 0)
c60d151b 791 return true;
03e39e59 792
d150b09d 793 // No remove flag
b2e465d6 794 if (Cache->DelCount() != 0 && _config->FindB("APT::Get::Remove",true) == false)
db0db9fe 795 return _error->Error(_("Packages need to be removed but remove is disabled."));
d150b09d 796
03e39e59
AL		 797 // Run the simulator ..
798 if (_config->FindB("APT::Get::Simulate") == true)
799 {
800 pkgSimulate PM(Cache);
2a7e07c7
MV		 801 int status_fd = _config->FindI("APT::Status-Fd",-1);
802 pkgPackageManager::OrderResult Res = PM.DoInstall(status_fd);
281daf46
AL		 803 if (Res == pkgPackageManager::Failed)
804 return false;
805 if (Res != pkgPackageManager::Completed)
2a7e07c7 806 return _error->Error(_("Internal error, Ordering didn't finish"));
281daf46 807 return true;
03e39e59
AL		 808 }
809
810 // Create the text record parser
811 pkgRecords Recs(Cache);
83d89a9f
AL		 812 if (_error->PendingError() == true)
813 return false;
1cd1c398 814
03e39e59 815 // Create the download object
1cd1c398 816 pkgAcquire Fetcher;
03e39e59 817 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
a722b2c5
DK		 818 if (_config->FindB("APT::Get::Print-URIs", false) == true)
819 {
820 // force a hashsum for compatibility reasons
821 _config->CndSet("Acquire::ForceHash", "md5sum");
822 if (Fetcher.Setup(&Stat, "") == false)
823 return false;
824 }
825 else if (Fetcher.Setup(&Stat, _config->FindDir("Dir::Cache::Archives")) == false)
1cd1c398 826 return false;
03e39e59
AL		 827
828 // Read the source list
829 pkgSourceList List;
830 if (List.ReadMainList() == false)
b2e465d6 831 return _error->Error(_("The list of sources could not be read."));
03e39e59
AL		 832
833 // Create the package manager and prepare to download
b2e465d6
AL		 834 SPtr<pkgPackageManager> PM= _system->CreatePM(Cache);
835 if (PM->GetArchives(&Fetcher,&List,&Recs) == false ||
424c3bc0 836 _error->PendingError() == true)
03e39e59
AL		 837 return false;
838
7a1b1f8b 839 // Display statistics
b2e465d6
AL		 840 double FetchBytes = Fetcher.FetchNeeded();
841 double FetchPBytes = Fetcher.PartialPresent();
842 double DebBytes = Fetcher.TotalNeeded();
d38b7b3d
AL		 843 if (DebBytes != Cache->DebSize())
844 {
845 c0out << DebBytes << ',' << Cache->DebSize() << endl;
2a7e07c7 846 c0out << _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl;
d38b7b3d 847 }
138d4b3d 848
7a1b1f8b 849 // Number of bytes
a6568219 850 if (DebBytes != FetchBytes)
ac7fd99c 851 ioprintf(c1out,_("Need to get %sB/%sB of archives.\n"),
b2e465d6 852 SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
813603a0 853 else if (DebBytes != 0)
ac7fd99c 854 ioprintf(c1out,_("Need to get %sB of archives.\n"),
b2e465d6
AL		 855 SizeToStr(DebBytes).c_str());
856
10bb1f5f
AL		 857 // Size delta
858 if (Cache->UsrSize() >= 0)
813603a0 859 ioprintf(c1out,_("After this operation, %sB of additional disk space will be used.\n"),
b2e465d6 860 SizeToStr(Cache->UsrSize()).c_str());
10bb1f5f 861 else
813603a0 862 ioprintf(c1out,_("After this operation, %sB disk space will be freed.\n"),
b2e465d6 863 SizeToStr(-1*Cache->UsrSize()).c_str());
10bb1f5f
AL		 864
865 if (_error->PendingError() == true)
866 return false;
31a0531d 867
01b64152
AL		 868 /* Check for enough free space, but only if we are actually going to
869 download */
18e20d63
AL		 870 if (_config->FindB("APT::Get::Print-URIs") == false &&
871 _config->FindB("APT::Get::Download",true) == true)
01b64152
AL		 872 {
873 struct statvfs Buf;
874 string OutputDir = _config->FindDir("Dir::Cache::Archives");
c1ce032a
DK		 875 if (statvfs(OutputDir.c_str(),&Buf) != 0) {
876 if (errno == EOVERFLOW)
877 return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
878 OutputDir.c_str());
879 else
880 return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
881 OutputDir.c_str());
882 } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
885d204b
OS		 883 {
884 struct statfs Stat;
f64196e8
DK		 885 if (statfs(OutputDir.c_str(),&Stat) != 0
886#if HAVE_STRUCT_STATFS_F_TYPE
887 || unsigned(Stat.f_type) != RAMFS_MAGIC
888#endif
889 )
885d204b
OS		 890 return _error->Error(_("You don't have enough free space in %s."),
891 OutputDir.c_str());
892 }
01b64152
AL		 893 }
894
83d89a9f 895 // Fail safe check
0c95c765
AL		 896 if (_config->FindI("quiet",0) >= 2 ||
897 _config->FindB("APT::Get::Assume-Yes",false) == true)
83d89a9f
AL		 898 {
899 if (Fail == true && _config->FindB("APT::Get::Force-Yes",false) == false)
b2e465d6 900 return _error->Error(_("There are problems and -y was used without --force-yes"));
83d89a9f 901 }
83d89a9f 902
80fbda96 903 if (Essential == true && Safety == true)
6f86c974 904 {
d150b09d 905 if (_config->FindB("APT::Get::Trivial-Only",false) == true)
b2e465d6 906 return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
d150b09d 907
b2e465d6
AL		 908 const char *Prompt = _("Yes, do as I say!");
909 ioprintf(c2out,
080bf1be 910 _("You are about to do something potentially harmful.\n"
b2e465d6
AL		 911 "To continue type in the phrase '%s'\n"
912 " ?] "),Prompt);
913 c2out << flush;
914 if (AnalPrompt(Prompt) == false)
6f86c974 915 {
b2e465d6 916 c2out << _("Abort.") << endl;
a6568219 917 exit(1);
6f86c974
AL		 918 }
919 }
920 else
d150b09d 921 {
6f86c974 922 // Prompt to continue
38262e68 923 if (Ask == true || Fail == true)
6f86c974 924 {
d150b09d 925 if (_config->FindB("APT::Get::Trivial-Only",false) == true)
b2e465d6 926 return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
d150b09d 927
0c95c765 928 if (_config->FindI("quiet",0) < 2 &&
6f86c974 929 _config->FindB("APT::Get::Assume-Yes",false) == false)
0c95c765 930 {
db0db9fe 931 c2out << _("Do you want to continue [Y/n]? ") << flush;
6f86c974 932
0c95c765
AL		 933 if (YnPrompt() == false)
934 {
b2e465d6 935 c2out << _("Abort.") << endl;
0c95c765
AL		 936 exit(1);
937 }
938 }
6f86c974
AL		 939 }
940 }
941
36375005 942 // Just print out the uris an exit if the --print-uris flag was used
f7a08e33
AL		 943 if (_config->FindB("APT::Get::Print-URIs") == true)
944 {
945 pkgAcquire::UriIterator I = Fetcher.UriBegin();
946 for (; I != Fetcher.UriEnd(); I++)
947 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
495e5cb2 948 I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
f7a08e33
AL		 949 return true;
950 }
b2e465d6 951
7db98ffc
MZ		 952 if (!CheckAuth(Fetcher))
953 return false;
954
b2e465d6
AL		 955 /* Unlock the dpkg lock if we are not going to be doing an install
956 after. */
957 if (_config->FindB("APT::Get::Download-Only",false) == true)
958 _system->UnLock();
83d89a9f 959
03e39e59 960 // Run it
281daf46 961 while (1)
30e1eab5 962 {
a3eaf954 963 bool Transient = false;
b2e465d6 964 if (_config->FindB("APT::Get::Download",true) == false)
a3eaf954 965 {
076d01b0 966 for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd();)
a3eaf954
AL		 967 {
968 if ((*I)->Local == true)
969 {
970 I++;
971 continue;
972 }
973
974 // Close the item and check if it was found in cache
975 (*I)->Finished();
976 if ((*I)->Complete == false)
977 Transient = true;
978
979 // Clear it out of the fetch list
980 delete *I;
981 I = Fetcher.ItemsBegin();
982 }
983 }
984
985 if (Fetcher.Run() == pkgAcquire::Failed)
986 return false;
30e1eab5 987
281daf46
AL		 988 // Print out errors
989 bool Failed = false;
076d01b0 990 for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
f01fe790 991 {
281daf46
AL		 992 if ((*I)->Status == pkgAcquire::Item::StatDone &&
993 (*I)->Complete == true)
994 continue;
995
281daf46
AL		 996 if ((*I)->Status == pkgAcquire::Item::StatIdle)
997 {
998 Transient = true;
999 // Failed = true;
1000 continue;
1001 }
a3eaf954 1002
b2e465d6
AL		 1003 fprintf(stderr,_("Failed to fetch %s %s\n"),(*I)->DescURI().c_str(),
1004 (*I)->ErrorText.c_str());
f01fe790 1005 Failed = true;
f01fe790 1006 }
5ec427c2 1007
a3eaf954 1008 /* If we are in no download mode and missing files and there were
5ec427c2
AL		 1009 'failures' then the user must specify -m. Furthermore, there
1010 is no such thing as a transient error in no-download mode! */
a3eaf954 1011 if (Transient == true &&
b2e465d6 1012 _config->FindB("APT::Get::Download",true) == false)
5ec427c2
AL		 1013 {
1014 Transient = false;
1015 Failed = true;
1016 }
f01fe790 1017
281daf46
AL		 1018 if (_config->FindB("APT::Get::Download-Only",false) == true)
1019 {
1020 if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
b2e465d6
AL		 1021 return _error->Error(_("Some files failed to download"));
1022 c1out << _("Download complete and in download only mode") << endl;
281daf46
AL		 1023 return true;
1024 }
1025
8195ae46 1026 if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
f01fe790 1027 {
b2e465d6 1028 return _error->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
f01fe790
AL		 1029 }
1030
281daf46 1031 if (Transient == true && Failed == true)
b2e465d6 1032 return _error->Error(_("--fix-missing and media swapping is not currently supported"));
281daf46
AL		 1033
1034 // Try to deal with missing package files
b2e465d6 1035 if (Failed == true && PM->FixMissing() == false)
281daf46 1036 {
b2e465d6 1037 cerr << _("Unable to correct missing packages.") << endl;
db0db9fe 1038 return _error->Error(_("Aborting install."));
281daf46 1039 }
afb1e2e3 1040
b2e465d6 1041 _system->UnLock();
2a7e07c7
MV		 1042 int status_fd = _config->FindI("APT::Status-Fd",-1);
1043 pkgPackageManager::OrderResult Res = PM->DoInstall(status_fd);
281daf46
AL		 1044 if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
1045 return false;
1046 if (Res == pkgPackageManager::Completed)
1047 return true;
1048
1049 // Reload the fetcher object and loop again for media swapping
1050 Fetcher.Shutdown();
b2e465d6 1051 if (PM->GetArchives(&Fetcher,&List,&Recs) == false)
281daf46 1052 return false;
b2e465d6
AL		 1053
1054 _system->Lock();
281daf46 1055 }
0a8e3465
AL		 1056}
1057 /*}}}*/
c373c37a
AL		 1058// TryToInstall - Try to install a single package /*{{{*/
1059// ---------------------------------------------------------------------
1060/* This used to be inlined in DoInstall, but with the advent of regex package
1061 name matching it was split out.. */
1062bool TryToInstall(pkgCache::PkgIterator Pkg,pkgDepCache &Cache,
1063 pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
1064 unsigned int &ExpectedInst,bool AllowFail = true)
1065{
5e62aac0
DK		 1066 /* This is a pure virtual package and there is a single available
1067 candidate providing it. */
1068 if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0)
c373c37a 1069 {
5e62aac0
DK		 1070 pkgCache::PkgIterator Prov;
1071 bool found_one = false;
1072
1073 for (pkgCache::PrvIterator P = Pkg.ProvidesList(); P; P++)
1074 {
1075 pkgCache::VerIterator const PVer = P.OwnerVer();
1076 pkgCache::PkgIterator const PPkg = PVer.ParentPkg();
1077
1078 /* Ignore versions that are not a candidate. */
1079 if (Cache[PPkg].CandidateVer != PVer)
1080 continue;
1081
1082 if (found_one == false)
1083 {
1084 Prov = PPkg;
1085 found_one = true;
1086 }
1087 else if (PPkg != Prov)
1088 {
1089 found_one = false; // we found at least two
1090 break;
1091 }
1092 }
1093
1094 if (found_one == true)
1095 {
1096 ioprintf(c1out,_("Note, selecting %s instead of %s\n"),
75ce2062 1097 Prov.FullName(true).c_str(),Pkg.FullName(true).c_str());
5e62aac0
DK		 1098 Pkg = Prov;
1099 }
c373c37a 1100 }
5e62aac0 1101
c373c37a 1102 // Handle the no-upgrade case
b2e465d6 1103 if (_config->FindB("APT::Get::upgrade",true) == false &&
c373c37a
AL		 1104 Pkg->CurrentVer != 0)
1105 {
1106 if (AllowFail == true)
b2e465d6 1107 ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
75ce2062 1108 Pkg.FullName(true).c_str());
c373c37a
AL		 1109 return true;
1110 }
6cd9fbd7
DK		 1111
1112 // Ignore request for install if package would be new
1113 if (_config->FindB("APT::Get::Only-Upgrade", false) == true &&
1114 Pkg->CurrentVer == 0)
1115 {
1116 if (AllowFail == true)
1117 ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
b2e465d6 1118 Pkg.Name());
c373c37a
AL		 1119 return true;
1120 }
6cd9fbd7 1121
c373c37a
AL		 1122 // Check if there is something at all to install
1123 pkgDepCache::StateCache &State = Cache[Pkg];
a146c927 1124 if (Remove == true && Pkg->CurrentVer == 0)
10bb1f5f 1125 {
d993b35d
AL		 1126 Fix.Clear(Pkg);
1127 Fix.Protect(Pkg);
1128 Fix.Remove(Pkg);
1129
b2e465d6
AL		 1130 /* We want to continue searching for regex hits, so we return false here
1131 otherwise this is not really an error. */
10bb1f5f 1132 if (AllowFail == false)
d993b35d
AL		 1133 return false;
1134
75ce2062 1135 ioprintf(c1out,_("Package %s is not installed, so not removed\n"),Pkg.FullName(true).c_str());
b2e465d6 1136 return true;
10bb1f5f 1137 }
a146c927
AL		 1138
1139 if (State.CandidateVer == 0 && Remove == false)
c373c37a
AL		 1140 {
1141 if (AllowFail == false)
1142 return false;
1143
1144 if (Pkg->ProvidesList != 0)
1145 {
b2e465d6 1146 ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
75ce2062 1147 Pkg.FullName(true).c_str());
c373c37a
AL		 1148
1149 pkgCache::PrvIterator I = Pkg.ProvidesList();
3b796dfc 1150 unsigned short provider = 0;
c373c37a
AL		 1151 for (; I.end() == false; I++)
1152 {
1153 pkgCache::PkgIterator Pkg = I.OwnerPkg();
1154
1155 if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer())
1156 {
3b796dfc 1157 c1out << " " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
c373c37a 1158 if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
3b796dfc
DK		 1159 c1out << _(" [Installed]");
1160 c1out << endl;
1161 ++provider;
1162 }
c373c37a 1163 }
3b796dfc
DK		 1164 // if we found no candidate which provide this package, show non-candidates
1165 if (provider == 0)
1166 for (I = Pkg.ProvidesList(); I.end() == false; I++)
1167 c1out << " " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
1168 << _(" [Not candidate version]") << endl;
1169 else
1170 c1out << _("You should explicitly select one to install.") << endl;
c373c37a
AL		 1171 }
1172 else
1173 {
b2e465d6 1174 ioprintf(c1out,
4c36e062
AL		 1175 _("Package %s is not available, but is referred to by another package.\n"
1176 "This may mean that the package is missing, has been obsoleted, or\n"
75ce2062 1177 "is only available from another source\n"),Pkg.FullName(true).c_str());
c373c37a
AL		 1178
1179 string List;
ac625538 1180 string VersionsList;
c82ffeb6
AL		 1181 SPtrArray<bool> Seen = new bool[Cache.Head().PackageCount];
1182 memset(Seen,0,Cache.Head().PackageCount*sizeof(*Seen));
c373c37a
AL		 1183 pkgCache::DepIterator Dep = Pkg.RevDependsList();
1184 for (; Dep.end() == false; Dep++)
1185 {
1186 if (Dep->Type != pkgCache::Dep::Replaces)
1187 continue;
b2e465d6
AL		 1188 if (Seen[Dep.ParentPkg()->ID] == true)
1189 continue;
1190 Seen[Dep.ParentPkg()->ID] = true;
75ce2062 1191 List += Dep.ParentPkg().FullName(true) + " ";
ac625538 1192 //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
c373c37a 1193 }
ac625538 1194 ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);
c373c37a
AL		 1195 }
1196
75ce2062 1197 _error->Error(_("Package %s has no installation candidate"),Pkg.FullName(true).c_str());
c373c37a
AL		 1198 return false;
1199 }
61d6a8de
AL		 1200
1201 Fix.Clear(Pkg);
70777d4b 1202 Fix.Protect(Pkg);
c373c37a
AL		 1203 if (Remove == true)
1204 {
1205 Fix.Remove(Pkg);
1206 Cache.MarkDelete(Pkg,_config->FindB("APT::Get::Purge",false));
1207 return true;
1208 }
1209
1210 // Install it
1211 Cache.MarkInstall(Pkg,false);
1212 if (State.Install() == false)
1213 {
d0c59649
AL		 1214 if (_config->FindB("APT::Get::ReInstall",false) == true)
1215 {
1216 if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
677cbcbc 1217 ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
75ce2062 1218 Pkg.FullName(true).c_str());
d0c59649
AL		 1219 else
1220 Cache.SetReInstall(Pkg,true);
1221 }
1222 else
1223 {
1224 if (AllowFail == true)
677cbcbc 1225 ioprintf(c1out,_("%s is already the newest version.\n"),
75ce2062 1226 Pkg.FullName(true).c_str());
d0c59649 1227 }
c373c37a
AL		 1228 }
1229 else
1230 ExpectedInst++;
1231
60681f93
MV		 1232 // Install it with autoinstalling enabled (if we not respect the minial
1233 // required deps or the policy)
1234 if ((State.InstBroken() == true || State.InstPolicyBroken() == true) && BrokenFix == false)
c373c37a 1235 Cache.MarkInstall(Pkg,true);
60681f93 1236
c373c37a
AL		 1237 return true;
1238}
1239 /*}}}*/
b2e465d6
AL		 1240// TryToChangeVer - Try to change a candidate version /*{{{*/
1241// ---------------------------------------------------------------------
1242/* */
1243bool TryToChangeVer(pkgCache::PkgIterator Pkg,pkgDepCache &Cache,
1244 const char *VerTag,bool IsRel)
1245{
d993b35d
AL		 1246 pkgVersionMatch Match(VerTag,(IsRel == true?pkgVersionMatch::Release :
1247 pkgVersionMatch::Version));
b2e465d6
AL		 1248
1249 pkgCache::VerIterator Ver = Match.Find(Pkg);
1250
1251 if (Ver.end() == true)
1252 {
1253 if (IsRel == true)
1254 return _error->Error(_("Release '%s' for '%s' was not found"),
75ce2062 1255 VerTag,Pkg.FullName(true).c_str());
b2e465d6 1256 return _error->Error(_("Version '%s' for '%s' was not found"),
75ce2062 1257 VerTag,Pkg.FullName(true).c_str());
b2e465d6
AL		 1258 }
1259
1260 if (strcmp(VerTag,Ver.VerStr()) != 0)
1261 {
1262 ioprintf(c1out,_("Selected version %s (%s) for %s\n"),
75ce2062 1263 Ver.VerStr(),Ver.RelStr().c_str(),Pkg.FullName(true).c_str());
b2e465d6
AL		 1264 }
1265
1266 Cache.SetCandidateVersion(Ver);
08bd372d
DK		 1267
1268 // Set the all package to the same candidate
1269 if (Ver.Pseudo() == true)
1270 Cache.SetCandidateVersion(Match.Find(Pkg.Group().FindPkg("all")));
1271
b2e465d6
AL		 1272 return true;
1273}
1274 /*}}}*/
1275// FindSrc - Find a source record /*{{{*/
1276// ---------------------------------------------------------------------
1277/* */
1278pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
1279 pkgSrcRecords &SrcRecs,string &Src,
1280 pkgDepCache &Cache)
1281{
b2e465d6 1282 string VerTag;
fb3dc579 1283 string DefRel = _config->Find("APT::Default-Release");
b2e465d6 1284 string TmpSrc = Name;
aca056a9 1285
fb3dc579
MV		 1286 // extract the version/release from the pkgname
1287 const size_t found = TmpSrc.find_last_of("/=");
1288 if (found != string::npos) {
1289 if (TmpSrc[found] == '/')
1290 DefRel = TmpSrc.substr(found+1);
1291 else
1292 VerTag = TmpSrc.substr(found+1);
ebf6c42d
DK		 1293 TmpSrc = TmpSrc.substr(0,found);
1294 }
aca056a9 1295
fb3dc579
MV		 1296 /* Lookup the version of the package we would install if we were to
1297 install a version and determine the source package name, then look
1298 in the archive for a source package of the same name. */
1299 bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
1300 const pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
1301 if (MatchSrcOnly == false && Pkg.end() == false)
aca056a9 1302 {
fb3dc579 1303 if(VerTag.empty() == false || DefRel.empty() == false)
aca056a9 1304 {
e84adb76 1305 bool fuzzy = false;
fb3dc579
MV		 1306 // we have a default release, try to locate the pkg. we do it like
1307 // this because GetCandidateVer() will not "downgrade", that means
1308 // "apt-get source -t stable apt" won't work on a unstable system
e84adb76 1309 for (pkgCache::VerIterator Ver = Pkg.VersionList();; Ver++)
aca056a9 1310 {
e84adb76
DK		 1311 // try first only exact matches, later fuzzy matches
1312 if (Ver.end() == true)
1313 {
1314 if (fuzzy == true)
1315 break;
1316 fuzzy = true;
1317 Ver = Pkg.VersionList();
1318 }
1319 // We match against a concrete version (or a part of this version)
1320 if (VerTag.empty() == false &&
1321 (fuzzy == true || Cache.VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
1322 (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
1323 continue;
1324
fb3dc579
MV		 1325 for (pkgCache::VerFileIterator VF = Ver.FileList();
1326 VF.end() == false; VF++)
aca056a9 1327 {
fb3dc579
MV		 1328 /* If this is the status file, and the current version is not the
1329 version in the status file (ie it is not installed, or somesuch)
1330 then it is not a candidate for installation, ever. This weeds
1331 out bogus entries that may be due to config-file states, or
1332 other. */
1333 if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
1334 pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
1335 continue;
1336
fb3dc579
MV		 1337 // or we match against a release
1338 if(VerTag.empty() == false ||
1339 (VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
1340 (VF.File().Codename() != 0 && VF.File().Codename() == DefRel))
1341 {
1342 pkgRecords::Parser &Parse = Recs.Lookup(VF);
1343 Src = Parse.SourcePkg();
61690a7e
MV		 1344 // no SourcePkg name, so it is the "binary" name
1345 if (Src.empty() == true)
1346 Src = TmpSrc;
e84adb76
DK		 1347 // the Version we have is possibly fuzzy or includes binUploads,
1348 // so we use the Version of the SourcePkg (empty if same as package)
1349 VerTag = Parse.SourceVer();
61690a7e
MV		 1350 if (VerTag.empty() == true)
1351 VerTag = Ver.VerStr();
fb3dc579
MV		 1352 break;
1353 }
aca056a9 1354 }
61690a7e
MV		 1355 if (Src.empty() == false)
1356 break;
aca056a9 1357 }
fb3dc579
MV		 1358 if (Src.empty() == true)
1359 {
61690a7e 1360 // Sources files have no codename information
ddff663f
MV		 1361 if (VerTag.empty() == true && DefRel.empty() == false)
1362 {
1363 _error->Error(_("Ignore unavailable target release '%s' of package '%s'"), DefRel.c_str(), TmpSrc.c_str());
1364 return 0;
1365 }
fb3dc579 1366 }
026f60e2 1367 }
61690a7e 1368 if (Src.empty() == true)
b2e465d6 1369 {
61690a7e
MV		 1370 // if we don't have found a fitting package yet so we will
1371 // choose a good candidate and proceed with that.
1372 // Maybe we will find a source later on with the right VerTag
ce6162be 1373 pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
fb3dc579 1374 if (Ver.end() == false)
b2e465d6
AL		 1375 {
1376 pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1377 Src = Parse.SourcePkg();
61690a7e
MV		 1378 if (VerTag.empty() == true)
1379 VerTag = Parse.SourceVer();
b2e465d6 1380 }
fb3dc579
MV		 1381 }
1382 }
1383
1384 if (Src.empty() == true)
1385 Src = TmpSrc;
1386 else
1387 {
1388 /* if we have a source pkg name, make sure to only search
1389 for srcpkg names, otherwise apt gets confused if there
1390 is a binary package "pkg1" and a source package "pkg1"
1391 with the same name but that comes from different packages */
1392 MatchSrcOnly = true;
1393 if (Src != TmpSrc)
1394 {
1395 ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
1396 }
b2e465d6 1397 }
89ad8e7c 1398
b2e465d6
AL		 1399 // The best hit
1400 pkgSrcRecords::Parser *Last = 0;
1401 unsigned long Offset = 0;
1402 string Version;
89ad8e7c 1403
b2e465d6
AL		 1404 /* Iterate over all of the hits, which includes the resulting
1405 binary packages in the search */
1406 pkgSrcRecords::Parser *Parse;
fb3dc579 1407 while (true)
b2e465d6 1408 {
fb3dc579
MV		 1409 SrcRecs.Restart();
1410 while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
b2e465d6 1411 {
fb3dc579
MV		 1412 const string Ver = Parse->Version();
1413
1414 // Ignore all versions which doesn't fit
e84adb76
DK		 1415 if (VerTag.empty() == false &&
1416 Cache.VS().CmpVersion(VerTag, Ver) != 0) // exact match
b2e465d6 1417 continue;
fb3dc579
MV		 1418
1419 // Newer version or an exact match? Save the hit
1420 if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0) {
1421 Last = Parse;
1422 Offset = Parse->Offset();
1423 Version = Ver;
1424 }
1425
1426 // was the version check above an exact match? If so, we don't need to look further
1427 if (VerTag.empty() == false && VerTag.size() == Ver.size())
1428 break;
b2e465d6 1429 }
fb3dc579
MV		 1430 if (Last != 0 || VerTag.empty() == true)
1431 break;
1432 //if (VerTag.empty() == false && Last == 0)
ddff663f
MV		 1433 _error->Error(_("Ignore unavailable version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
1434 return 0;
b2e465d6 1435 }
fb3dc579 1436
ce6162be 1437 if (Last == 0 || Last->Jump(Offset) == false)
b2e465d6 1438 return 0;
fb3dc579 1439
b2e465d6
AL		 1440 return Last;
1441}
1442 /*}}}*/
0a8e3465
AL		 1443// DoUpdate - Update the package lists /*{{{*/
1444// ---------------------------------------------------------------------
1445/* */
b2e465d6 1446bool DoUpdate(CommandLine &CmdL)
0a8e3465 1447{
b2e465d6
AL		 1448 if (CmdL.FileSize() != 1)
1449 return _error->Error(_("The update command takes no arguments"));
1450
0919e3f9
AL		 1451 // Get the source list
1452 pkgSourceList List;
1453 if (List.ReadMainList() == false)
1454 return false;
1455
89b70b5a 1456 // Create the progress
0919e3f9 1457 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
89b70b5a 1458
f0863b21
AL		 1459 // Just print out the uris an exit if the --print-uris flag was used
1460 if (_config->FindB("APT::Get::Print-URIs") == true)
1461 {
a722b2c5
DK		 1462 // force a hashsum for compatibility reasons
1463 _config->CndSet("Acquire::ForceHash", "md5sum");
1464
89b70b5a 1465 // get a fetcher
1cd1c398
DK		 1466 pkgAcquire Fetcher;
1467 if (Fetcher.Setup(&Stat) == false)
1468 return false;
89b70b5a 1469
7db98ffc
MZ		 1470 // Populate it with the source selection and get all Indexes
1471 // (GetAll=true)
1472 if (List.GetIndexes(&Fetcher,true) == false)
1473 return false;
1474
f0863b21
AL		 1475 pkgAcquire::UriIterator I = Fetcher.UriBegin();
1476 for (; I != Fetcher.UriEnd(); I++)
1477 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
495e5cb2 1478 I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
f0863b21
AL		 1479 return true;
1480 }
7db98ffc 1481
89b70b5a 1482 // do the work
0919e3f9 1483 CacheFile Cache;
e88d983a
OS		 1484 if (_config->FindB("APT::Get::Download",true) == true)
1485 ListUpdate(Stat, List);
1486
89b70b5a 1487 // Rebuild the cache.
0077d829 1488 if (Cache.BuildCaches() == false)
0919e3f9
AL		 1489 return false;
1490
1491 return true;
afb1e2e3
MV		 1492}
1493 /*}}}*/
1494// DoAutomaticRemove - Remove all automatic unused packages /*{{{*/
1495// ---------------------------------------------------------------------
1496/* Remove unused automatic packages */
1497bool DoAutomaticRemove(CacheFile &Cache)
1498{
9d2938d4 1499 bool Debug = _config->FindI("Debug::pkgAutoRemove",false);
b255ff1a 1500 bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);
7898bd97 1501 bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");
afb1e2e3 1502
03dbbc98 1503 pkgDepCache::ActionGroup group(*Cache);
9d2938d4 1504 if(Debug)
120365ce 1505 std::cout << "DoAutomaticRemove()" << std::endl;
afb1e2e3 1506
03dbbc98
DK		 1507 // we don't want to autoremove and we don't want to see it, so why calculating?
1508 if (doAutoRemove == false && hideAutoRemove == true)
1509 return true;
1510
1511 if (doAutoRemove == true &&
1512 _config->FindB("APT::Get::Remove",true) == false)
afb1e2e3 1513 {
3d0de656
MV		 1514 c1out << _("We are not supposed to delete stuff, can't start "
1515 "AutoRemover") << std::endl;
03dbbc98 1516 return false;
3d0de656 1517 }
74a05226 1518
03dbbc98
DK		 1519 bool purgePkgs = _config->FindB("APT::Get::Purge", false);
1520 bool smallList = (hideAutoRemove == false &&
1521 strcasecmp(_config->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
1522
9d2938d4 1523 string autoremovelist, autoremoveversions;
03dbbc98 1524 unsigned long autoRemoveCount = 0;
9d2938d4
MV		 1525 // look over the cache to see what can be removed
1526 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); ! Pkg.end(); ++Pkg)
afb1e2e3 1527 {
9d2938d4
MV		 1528 if (Cache[Pkg].Garbage)
1529 {
1530 if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
1531 if(Debug)
75ce2062 1532 std::cout << "We could delete %s" << Pkg.FullName(true).c_str() << std::endl;
03dbbc98 1533
3d0de656 1534 if (doAutoRemove)
9d2938d4
MV		 1535 {
1536 if(Pkg.CurrentVer() != 0 &&
1537 Pkg->CurrentState != pkgCache::State::ConfigFiles)
03dbbc98 1538 Cache->MarkDelete(Pkg, purgePkgs);
9d2938d4 1539 else
74a05226 1540 Cache->MarkKeep(Pkg, false, false);
9d2938d4 1541 }
03dbbc98
DK		 1542 else
1543 {
1544 // only show stuff in the list that is not yet marked for removal
1545 if(Cache[Pkg].Delete() == false)
1546 {
f0f2f956 1547 ++autoRemoveCount;
03dbbc98 1548 // we don't need to fill the strings if we don't need them
f0f2f956 1549 if (smallList == false)
03dbbc98 1550 {
75ce2062 1551 autoremovelist += Pkg.FullName(true) + " ";
03dbbc98
DK		 1552 autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
1553 }
1554 }
1555 }
9d2938d4 1556 }
afb1e2e3 1557 }
03dbbc98
DK		 1558 // if we don't remove them, we should show them!
1559 if (doAutoRemove == false && (autoremovelist.empty() == false || autoRemoveCount != 0))
1560 {
1561 if (smallList == false)
f0f2f956
DK		 1562 ShowList(c1out, P_("The following package is automatically installed and is no longer required:",
1563 "The following packages were automatically installed and are no longer required:",
1564 autoRemoveCount), autoremovelist, autoremoveversions);
03dbbc98 1565 else
f0f2f956
DK		 1566 ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
1567 "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);
9d2938d4 1568 c1out << _("Use 'apt-get autoremove' to remove them.") << std::endl;
03dbbc98
DK		 1569 }
1570 // Now see if we had destroyed anything (if we had done anything)
1571 else if (Cache->BrokenCount() != 0)
afb1e2e3
MV		 1572 {
1573 c1out << _("Hmm, seems like the AutoRemover destroyed something which really\n"
1574 "shouldn't happen. Please file a bug report against apt.") << endl;
1575 c1out << endl;
1576 c1out << _("The following information may help to resolve the situation:") << endl;
1577 c1out << endl;
1578 ShowBroken(c1out,Cache,false);
1579
1580 return _error->Error(_("Internal Error, AutoRemover broke stuff"));
1581 }
1582 return true;
db1e7193 1583}
92fcbfc1 1584 /*}}}*/
db1e7193
MV		 1585// DoUpgrade - Upgrade all packages /*{{{*/
1586// ---------------------------------------------------------------------
1587/* Upgrade all packages without installing new packages or erasing old
1588 packages */
1589bool DoUpgrade(CommandLine &CmdL)
1590{
1591 CacheFile Cache;
1592 if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
1593 return false;
1594
1595 // Do the upgrade
1596 if (pkgAllUpgrade(Cache) == false)
1597 {
1598 ShowBroken(c1out,Cache,false);
1599 return _error->Error(_("Internal error, AllUpgrade broke stuff"));
1600 }
1601
1602 return InstallPackages(Cache,true);
afb1e2e3
MV		 1603}
1604 /*}}}*/
c158ff49
MV		 1605// DoInstallTask - Install task from the command line /*{{{*/
1606// ---------------------------------------------------------------------
1607/* Install named task */
39cc1bbd
MV		 1608bool TryInstallTask(pkgDepCache &Cache, pkgProblemResolver &Fix,
1609 bool BrokenFix,
1610 unsigned int& ExpectedInst,
394eadc8
MV		 1611 const char *taskname,
1612 bool Remove)
c158ff49
MV		 1613{
1614 const char *start, *end;
1615 pkgCache::PkgIterator Pkg;
39cc1bbd
MV		 1616 char buf[64*1024];
1617 regex_t Pattern;
c158ff49 1618
39cc1bbd 1619 // get the records
c158ff49 1620 pkgRecords Recs(Cache);
c158ff49 1621
39cc1bbd
MV		 1622 // build regexp for the task
1623 char S[300];
f03dd1e0
MV		 1624 snprintf(S, sizeof(S), "^Task:.*[, ]%s([, ]|$)", taskname);
1625 if(regcomp(&Pattern,S, REG_EXTENDED | REG_NOSUB | REG_NEWLINE) != 0)
1626 return _error->Error("Failed to compile task regexp");
39cc1bbd
MV		 1627
1628 bool found = false;
1629 bool res = true;
85bd111a
MV		 1630
1631 // two runs, first ignore dependencies, second install any missing
1632 for(int IgnoreBroken=1; IgnoreBroken >= 0; IgnoreBroken--)
c158ff49 1633 {
85bd111a
MV		 1634 for (Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
1635 {
1636 pkgCache::VerIterator ver = Cache[Pkg].CandidateVerIter(Cache);
1637 if(ver.end())
1638 continue;
1639 pkgRecords::Parser &parser = Recs.Lookup(ver.FileList());
1640 parser.GetRec(start,end);
1641 strncpy(buf, start, end-start);
1642 buf[end-start] = 0x0;
1643 if (regexec(&Pattern,buf,0,0,0) != 0)
1644 continue;
1645 res &= TryToInstall(Pkg,Cache,Fix,Remove,IgnoreBroken,ExpectedInst);
1646 found = true;
1647 }
c158ff49 1648 }
c158ff49 1649
9dbe6ae4
MV		 1650 // now let the problem resolver deal with any issues
1651 Fix.Resolve(true);
1652
39cc1bbd
MV		 1653 if(!found)
1654 _error->Error(_("Couldn't find task %s"),taskname);
1655
1656 regfree(&Pattern);
1657 return res;
c158ff49 1658}
92fcbfc1 1659 /*}}}*/
0a8e3465
AL		 1660// DoInstall - Install packages from the command line /*{{{*/
1661// ---------------------------------------------------------------------
1662/* Install named packages */
1663bool DoInstall(CommandLine &CmdL)
1664{
1665 CacheFile Cache;
c37b9502
AL		 1666 if (Cache.OpenForInstall() == false ||
1667 Cache.CheckDeps(CmdL.FileSize() != 1) == false)
0a8e3465
AL		 1668 return false;
1669
7c57fe64
AL		 1670 // Enter the special broken fixing mode if the user specified arguments
1671 bool BrokenFix = false;
1672 if (Cache->BrokenCount() != 0)
1673 BrokenFix = true;
1674
e4b74e4b 1675 unsigned int AutoMarkChanged = 0;
a6568219
AL		 1676 unsigned int ExpectedInst = 0;
1677 unsigned int Packages = 0;
0a8e3465
AL		 1678 pkgProblemResolver Fix(Cache);
1679
303a1703
AL		 1680 bool DefRemove = false;
1681 if (strcasecmp(CmdL.FileList[0],"remove") == 0)
1682 DefRemove = true;
e47c7d16
MV		 1683 else if (strcasecmp(CmdL.FileList[0], "purge") == 0)
1684 {
1685 _config->Set("APT::Get::Purge", true);
1686 DefRemove = true;
1687 }
74a05226 1688 else if (strcasecmp(CmdL.FileList[0], "autoremove") == 0)
0a8e3465 1689 {
54668e4e
MV		 1690 _config->Set("APT::Get::AutomaticRemove", "true");
1691 DefRemove = true;
1692 }
54668e4e 1693 // new scope for the ActionGroup
0a8e3465 1694 {
54668e4e
MV		 1695 pkgDepCache::ActionGroup group(Cache);
1696 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
0a8e3465 1697 {
54668e4e
MV		 1698 // Duplicate the string
1699 unsigned int Length = strlen(*I);
1700 char S[300];
1701 if (Length >= sizeof(S))
fc4b5c9f 1702 continue;
54668e4e
MV		 1703 strcpy(S,*I);
1704
1705 // See if we are removing and special indicators..
1706 bool Remove = DefRemove;
1707 char *VerTag = 0;
1708 bool VerIsRel = false;
5a68ea79
MV		 1709
1710 // this is a task!
1711 if (Length >= 1 && S[Length - 1] == '^')
1712 {
1713 S[--Length] = 0;
1714 // tasks must always be confirmed
1715 ExpectedInst += 1000;
1716 // see if we can install it
394eadc8 1717 TryInstallTask(Cache, Fix, BrokenFix, ExpectedInst, S, Remove);
5a68ea79
MV		 1718 continue;
1719 }
1720
54668e4e 1721 while (Cache->FindPkg(S).end() == true)
b2e465d6 1722 {
54668e4e
MV		 1723 // Handle an optional end tag indicating what to do
1724 if (Length >= 1 && S[Length - 1] == '-')
1725 {
1726 Remove = true;
1727 S[--Length] = 0;
1728 continue;
1729 }
b2e465d6 1730
54668e4e
MV		 1731 if (Length >= 1 && S[Length - 1] == '+')
1732 {
1733 Remove = false;
1734 S[--Length] = 0;
1735 continue;
1736 }
b2e465d6 1737
54668e4e
MV		 1738 char *Slash = strchr(S,'=');
1739 if (Slash != 0)
1740 {
1741 VerIsRel = false;
1742 *Slash = 0;
1743 VerTag = Slash + 1;
1744 }
c373c37a 1745
54668e4e
MV		 1746 Slash = strchr(S,'/');
1747 if (Slash != 0)
1748 {
1749 VerIsRel = true;
1750 *Slash = 0;
1751 VerTag = Slash + 1;
1752 }
c373c37a 1753
54668e4e 1754 break;
b2e465d6 1755 }
54668e4e
MV		 1756
1757 // Locate the package
1758 pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
1759 Packages++;
1760 if (Pkg.end() == true)
303a1703 1761 {
54668e4e
MV		 1762 // Check if the name is a regex
1763 const char *I;
1764 for (I = S; *I != 0; I++)
1765 if (*I == '?' || *I == '*' || *I == '|' ||
1766 *I == '[' || *I == '^' || *I == '$')
1767 break;
1768 if (*I == 0)
1769 return _error->Error(_("Couldn't find package %s"),S);
1770
1771 // Regexs must always be confirmed
1772 ExpectedInst += 1000;
1773
1774 // Compile the regex pattern
1775 regex_t Pattern;
1776 int Res;
1777 if ((Res = regcomp(&Pattern,S,REG_EXTENDED | REG_ICASE |
1778 REG_NOSUB)) != 0)
1779 {
1780 char Error[300];
1781 regerror(Res,&Pattern,Error,sizeof(Error));
1782 return _error->Error(_("Regex compilation error - %s"),Error);
1783 }
1784
1785 // Run over the matches
1786 bool Hit = false;
3d5a34b2 1787 for (pkgCache::GrpIterator Grp = Cache->GrpBegin(); Grp.end() == false; ++Grp)
54668e4e 1788 {
3d5a34b2 1789 if (regexec(&Pattern,Grp.Name(),0,0,0) != 0)
54668e4e 1790 continue;
3d5a34b2
DK		 1791 Pkg = Grp.FindPkg("native");
1792 if (unlikely(Pkg.end() == true))
1793 continue;
1794
54668e4e
MV		 1795 ioprintf(c1out,_("Note, selecting %s for regex '%s'\n"),
1796 Pkg.Name(),S);
07801a6d 1797
54668e4e
MV		 1798 if (VerTag != 0)
1799 if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1800 return false;
185091b7 1801
54668e4e
MV		 1802 Hit |= TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,
1803 ExpectedInst,false);
1804 }
1805 regfree(&Pattern);
1806
1807 if (Hit == false)
1808 return _error->Error(_("Couldn't find package %s"),S);
1809 }
1810 else
1811 {
b2e465d6
AL		 1812 if (VerTag != 0)
1813 if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1814 return false;
54668e4e 1815 if (TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,ExpectedInst) == false)
b2e465d6 1816 return false;
e4b74e4b
MV		 1817
1818 // see if we need to fix the auto-mark flag
1819 // e.g. apt-get install foo
1820 // where foo is marked automatic
fd59a713
MV		 1821 if(!Remove &&
1822 Cache[Pkg].Install() == false &&
085bedac 1823 (Cache[Pkg].Flags & pkgCache::Flag::Auto) &&
e57a5bff 1824 _config->FindB("APT::Get::ReInstall",false) == false &&
6cd9fbd7 1825 _config->FindB("APT::Get::Only-Upgrade",false) == false &&
e57a5bff 1826 _config->FindB("APT::Get::Download-Only",false) == false)
e4b74e4b 1827 {
da543ed8 1828 ioprintf(c1out,_("%s set to manually installed.\n"),
75ce2062 1829 Pkg.FullName(true).c_str());
e4b74e4b
MV		 1830 Cache->MarkAuto(Pkg,false);
1831 AutoMarkChanged++;
1832 }
54668e4e
MV		 1833 }
1834 }
0a8e3465 1835
54668e4e
MV		 1836 /* If we are in the Broken fixing mode we do not attempt to fix the
1837 problems. This is if the user invoked install without -f and gave
1838 packages */
1839 if (BrokenFix == true && Cache->BrokenCount() != 0)
1840 {
b5647402 1841 c1out << _("You might want to run 'apt-get -f install' to correct these:") << endl;
54668e4e 1842 ShowBroken(c1out,Cache,false);
7c57fe64 1843
54668e4e
MV		 1844 return _error->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1845 }
7c57fe64 1846
54668e4e
MV		 1847 // Call the scored problem resolver
1848 Fix.InstallProtect();
1849 if (Fix.Resolve(true) == false)
1850 _error->Discard();
0a8e3465 1851
54668e4e
MV		 1852 // Now we check the state of the packages,
1853 if (Cache->BrokenCount() != 0)
303a1703 1854 {
b2e465d6 1855 c1out <<
54668e4e
MV		 1856 _("Some packages could not be installed. This may mean that you have\n"
1857 "requested an impossible situation or if you are using the unstable\n"
1858 "distribution that some required packages have not yet been created\n"
1859 "or been moved out of Incoming.") << endl;
ecd414ef 1860 /*
54668e4e
MV		 1861 if (Packages == 1)
1862 {
1863 c1out << endl;
1864 c1out <<
1865 _("Since you only requested a single operation it is extremely likely that\n"
1866 "the package is simply not installable and a bug report against\n"
1867 "that package should be filed.") << endl;
1868 }
ecd414ef 1869 */
303a1703 1870
54668e4e
MV		 1871 c1out << _("The following information may help to resolve the situation:") << endl;
1872 c1out << endl;
1873 ShowBroken(c1out,Cache,false);
1874 return _error->Error(_("Broken packages"));
1875 }
120365ce 1876 }
5a68ea79
MV		 1877 if (!DoAutomaticRemove(Cache))
1878 return false;
afb1e2e3 1879
0a8e3465
AL		 1880 /* Print out a list of packages that are going to be installed extra
1881 to what the user asked */
1882 if (Cache->InstCount() != ExpectedInst)
1883 {
1884 string List;
ac625538 1885 string VersionsList;
1089ca89 1886 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
0a8e3465 1887 {
1089ca89 1888 pkgCache::PkgIterator I(Cache,Cache.List[J]);
0a8e3465
AL		 1889 if ((*Cache)[I].Install() == false)
1890 continue;
1891
1892 const char **J;
1893 for (J = CmdL.FileList + 1; *J != 0; J++)
1894 if (strcmp(*J,I.Name()) == 0)
1895 break;
1896
ac625538 1897 if (*J == 0) {
75ce2062 1898 List += I.FullName(true) + " ";
80fa0d8a
MV		 1899 VersionsList += string(Cache[I].CandVersion) + "\n";
1900 }
0a8e3465
AL		 1901 }
1902
ac625538 1903 ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
0a8e3465
AL		 1904 }
1905
a7e41689
AL		 1906 /* Print out a list of suggested and recommended packages */
1907 {
1908 string SuggestsList, RecommendsList, List;
72122b62 1909 string SuggestsVersions, RecommendsVersions;
a7e41689
AL		 1910 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1911 {
29f37db8 1912 pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
a7e41689
AL		 1913
1914 /* Just look at the ones we want to install */
29f37db8 1915 if ((*Cache)[Pkg].Install() == false)
a7e41689
AL		 1916 continue;
1917
29f37db8
MV		 1918 // get the recommends/suggests for the candidate ver
1919 pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
1920 for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
1921 {
1922 pkgCache::DepIterator Start;
1923 pkgCache::DepIterator End;
1924 D.GlobOr(Start,End); // advances D
1925
cd33a786
MV		 1926 // FIXME: we really should display a or-group as a or-group to the user
1927 // the problem is that ShowList is incapable of doing this
29f37db8
MV		 1928 string RecommendsOrList,RecommendsOrVersions;
1929 string SuggestsOrList,SuggestsOrVersions;
1930 bool foundInstalledInOrGroup = false;
1931 for(;;)
1932 {
1933 /* Skip if package is installed already, or is about to be */
75ce2062 1934 string target = Start.TargetPkg().FullName(true) + " ";
2d847a59
DK		 1935 pkgCache::PkgIterator const TarPkg = Start.TargetPkg();
1936 if (TarPkg->SelectedState == pkgCache::State::Install ||
1937 TarPkg->SelectedState == pkgCache::State::Hold ||
1938 Cache[Start.TargetPkg()].Install())
29f37db8
MV		 1939 {
1940 foundInstalledInOrGroup=true;
1941 break;
1942 }
1943
1944 /* Skip if we already saw it */
1945 if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
1946 {
1947 foundInstalledInOrGroup=true;
1948 break;
1949 }
1950
1951 // this is a dep on a virtual pkg, check if any package that provides it
1952 // should be installed
1953 if(Start.TargetPkg().ProvidesList() != 0)
1954 {
1955 pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
1956 for (; I.end() == false; I++)
1957 {
1958 pkgCache::PkgIterator Pkg = I.OwnerPkg();
1959 if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
1960 Pkg.CurrentVer() != 0)
1961 foundInstalledInOrGroup=true;
1962 }
1963 }
1964
1965 if (Start->Type == pkgCache::Dep::Suggests)
1966 {
1967 SuggestsOrList += target;
1968 SuggestsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1969 }
1970
1971 if (Start->Type == pkgCache::Dep::Recommends)
1972 {
1973 RecommendsOrList += target;
1974 RecommendsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1975 }
1976
1977 if (Start >= End)
1978 break;
1979 Start++;
1980 }
1981
1982 if(foundInstalledInOrGroup == false)
1983 {
1984 RecommendsList += RecommendsOrList;
1985 RecommendsVersions += RecommendsOrVersions;
1986 SuggestsList += SuggestsOrList;
1987 SuggestsVersions += SuggestsOrVersions;
1988 }
1989
1990 }
a7e41689 1991 }
29f37db8 1992
72122b62
AL		 1993 ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
1994 ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
a7e41689
AL		 1995
1996 }
1997
e4b74e4b
MV		 1998 // if nothing changed in the cache, but only the automark information
1999 // we write the StateFile here, otherwise it will be written in
2000 // cache.commit()
2001 if (AutoMarkChanged > 0 &&
2002 Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
9964a721
MV		 2003 Cache->BadCount() == 0 &&
2004 _config->FindB("APT::Get::Simulate",false) == false)
e4b74e4b
MV		 2005 Cache->writeStateFile(NULL);
2006
03e39e59 2007 // See if we need to prompt
2c3bc8bb 2008 if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0)
2c3bc8bb 2009 return InstallPackages(Cache,false,false);
13e8426f 2010
03e39e59 2011 return InstallPackages(Cache,false);
0a8e3465
AL		 2012}
2013 /*}}}*/
2014// DoDistUpgrade - Automatic smart upgrader /*{{{*/
2015// ---------------------------------------------------------------------
2016/* Intelligent upgrader that will install and remove packages at will */
2017bool DoDistUpgrade(CommandLine &CmdL)
2018{
2019 CacheFile Cache;
c37b9502 2020 if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
0a8e3465
AL		 2021 return false;
2022
db0db9fe 2023 c0out << _("Calculating upgrade... ") << flush;
0a8e3465
AL		 2024 if (pkgDistUpgrade(*Cache) == false)
2025 {
b2e465d6 2026 c0out << _("Failed") << endl;
421c8d10 2027 ShowBroken(c1out,Cache,false);
0a8e3465
AL		 2028 return false;
2029 }
2030
b2e465d6 2031 c0out << _("Done") << endl;
0a8e3465
AL		 2032
2033 return InstallPackages(Cache,true);
2034}
2035 /*}}}*/
2036// DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
2037// ---------------------------------------------------------------------
2038/* Follows dselect's selections */
2039bool DoDSelectUpgrade(CommandLine &CmdL)
2040{
2041 CacheFile Cache;
c37b9502 2042 if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
0a8e3465
AL		 2043 return false;
2044
a4decc40
MV		 2045 pkgDepCache::ActionGroup group(Cache);
2046
0a8e3465
AL		 2047 // Install everything with the install flag set
2048 pkgCache::PkgIterator I = Cache->PkgBegin();
2049 for (;I.end() != true; I++)
2050 {
2051 /* Install the package only if it is a new install, the autoupgrader
2052 will deal with the rest */
2053 if (I->SelectedState == pkgCache::State::Install)
2054 Cache->MarkInstall(I,false);
2055 }
2056
2057 /* Now install their deps too, if we do this above then order of
2058 the status file is significant for | groups */
2059 for (I = Cache->PkgBegin();I.end() != true; I++)
2060 {
2061 /* Install the package only if it is a new install, the autoupgrader
2062 will deal with the rest */
2063 if (I->SelectedState == pkgCache::State::Install)
2f45c76a 2064 Cache->MarkInstall(I,true);
0a8e3465
AL		 2065 }
2066
2067 // Apply erasures now, they override everything else.
2068 for (I = Cache->PkgBegin();I.end() != true; I++)
2069 {
2070 // Remove packages
2071 if (I->SelectedState == pkgCache::State::DeInstall ||
2072 I->SelectedState == pkgCache::State::Purge)
d556d1a1 2073 Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
0a8e3465
AL		 2074 }
2075
2f45c76a
AL		 2076 /* Resolve any problems that dselect created, allupgrade cannot handle
2077 such things. We do so quite agressively too.. */
2078 if (Cache->BrokenCount() != 0)
2079 {
2080 pkgProblemResolver Fix(Cache);
2081
2082 // Hold back held packages.
b2e465d6 2083 if (_config->FindB("APT::Ignore-Hold",false) == false)
2f45c76a
AL		 2084 {
2085 for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
2086 {
2087 if (I->SelectedState == pkgCache::State::Hold)
2088 {
2089 Fix.Protect(I);
2090 Cache->MarkKeep(I);
2091 }
2092 }
2093 }
2094
2095 if (Fix.Resolve() == false)
2096 {
421c8d10 2097 ShowBroken(c1out,Cache,false);
2a7e07c7 2098 return _error->Error(_("Internal error, problem resolver broke stuff"));
2f45c76a
AL		 2099 }
2100 }
2101
2102 // Now upgrade everything
0a8e3465
AL		 2103 if (pkgAllUpgrade(Cache) == false)
2104 {
421c8d10 2105 ShowBroken(c1out,Cache,false);
2a7e07c7 2106 return _error->Error(_("Internal error, problem resolver broke stuff"));
0a8e3465
AL		 2107 }
2108
2109 return InstallPackages(Cache,false);
2110}
2111 /*}}}*/
2112// DoClean - Remove download archives /*{{{*/
2113// ---------------------------------------------------------------------
2114/* */
2115bool DoClean(CommandLine &CmdL)
2116{
8b067c22
AL		 2117 if (_config->FindB("APT::Get::Simulate") == true)
2118 {
2119 cout << "Del " << _config->FindDir("Dir::Cache::archives") << "* " <<
2120 _config->FindDir("Dir::Cache::archives") << "partial/*" << endl;
2121 return true;
2122 }
2123
1b6d659c
AL		 2124 // Lock the archive directory
2125 FileFd Lock;
2126 if (_config->FindB("Debug::NoLocking",false) == false)
2127 {
2128 Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2129 if (_error->PendingError() == true)
b2e465d6 2130 return _error->Error(_("Unable to lock the download directory"));
1b6d659c
AL		 2131 }
2132
7a1b1f8b
AL		 2133 pkgAcquire Fetcher;
2134 Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
2135 Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
0a8e3465
AL		 2136 return true;
2137}
2138 /*}}}*/
1bc849af
AL		 2139// DoAutoClean - Smartly remove downloaded archives /*{{{*/
2140// ---------------------------------------------------------------------
2141/* This is similar to clean but it only purges things that cannot be
2142 downloaded, that is old versions of cached packages. */
65a1e968
AL		 2143class LogCleaner : public pkgArchiveCleaner
2144{
2145 protected:
2146 virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
2147 {
4cc8bab0 2148 c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
c1e78ee5
AL		 2149
2150 if (_config->FindB("APT::Get::Simulate") == false)
2151 unlink(File);
65a1e968
AL		 2152 };
2153};
2154
1bc849af
AL		 2155bool DoAutoClean(CommandLine &CmdL)
2156{
1b6d659c
AL		 2157 // Lock the archive directory
2158 FileFd Lock;
2159 if (_config->FindB("Debug::NoLocking",false) == false)
2160 {
2161 Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2162 if (_error->PendingError() == true)
b2e465d6 2163 return _error->Error(_("Unable to lock the download directory"));
1b6d659c
AL		 2164 }
2165
1bc849af 2166 CacheFile Cache;
2d11135a 2167 if (Cache.Open() == false)
1bc849af
AL		 2168 return false;
2169
65a1e968 2170 LogCleaner Cleaner;
1bc849af
AL		 2171
2172 return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
2173 Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
2174}
2175 /*}}}*/
0a8e3465
AL		 2176// DoCheck - Perform the check operation /*{{{*/
2177// ---------------------------------------------------------------------
2178/* Opening automatically checks the system, this command is mostly used
2179 for debugging */
2180bool DoCheck(CommandLine &CmdL)
2181{
2182 CacheFile Cache;
2183 Cache.Open();
2d11135a 2184 Cache.CheckDeps();
0a8e3465
AL		 2185
2186 return true;
2187}
2188 /*}}}*/
36375005
AL		 2189// DoSource - Fetch a source archive /*{{{*/
2190// ---------------------------------------------------------------------
2d11135a 2191/* Fetch souce packages */
fb0ee66e
AL		 2192struct DscFile
2193{
2194 string Package;
2195 string Version;
2196 string Dsc;
2197};
2198
36375005
AL		 2199bool DoSource(CommandLine &CmdL)
2200{
2201 CacheFile Cache;
2d11135a 2202 if (Cache.Open(false) == false)
36375005
AL		 2203 return false;
2204
2d11135a 2205 if (CmdL.FileSize() <= 1)
b2e465d6 2206 return _error->Error(_("Must specify at least one package to fetch source for"));
2d11135a 2207
36375005
AL		 2208 // Read the source list
2209 pkgSourceList List;
2210 if (List.ReadMainList() == false)
b2e465d6 2211 return _error->Error(_("The list of sources could not be read."));
36375005
AL		 2212
2213 // Create the text record parsers
2214 pkgRecords Recs(Cache);
2215 pkgSrcRecords SrcRecs(List);
2216 if (_error->PendingError() == true)
2217 return false;
2218
2219 // Create the download object
2220 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1cd1c398
DK		 2221 pkgAcquire Fetcher;
2222 if (Fetcher.Setup(&Stat) == false)
2223 return false;
fb0ee66e
AL		 2224
2225 DscFile *Dsc = new DscFile[CmdL.FileSize()];
36375005 2226
092ae175
MV		 2227 // insert all downloaded uris into this set to avoid downloading them
2228 // twice
2229 set<string> queued;
36375005 2230 // Load the requestd sources into the fetcher
fb0ee66e
AL		 2231 unsigned J = 0;
2232 for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
36375005
AL		 2233 {
2234 string Src;
b2e465d6 2235 pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
36375005
AL		 2236
2237 if (Last == 0)
b2e465d6 2238 return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
36375005
AL		 2239
2240 // Back track
2241 vector<pkgSrcRecords::File> Lst;
b2e465d6 2242 if (Last->Files(Lst) == false)
36375005
AL		 2243 return false;
2244
2245 // Load them into the fetcher
2246 for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
2247 I != Lst.end(); I++)
2248 {
2249 // Try to guess what sort of file it is we are getting.
b2e465d6 2250 if (I->Type == "dsc")
fb0ee66e 2251 {
fb0ee66e
AL		 2252 Dsc[J].Package = Last->Package();
2253 Dsc[J].Version = Last->Version();
2254 Dsc[J].Dsc = flNotDir(I->Path);
2255 }
2256
17c0e8e1
AL		 2257 // Diff only mode only fetches .diff files
2258 if (_config->FindB("APT::Get::Diff-Only",false) == true &&
b2e465d6 2259 I->Type != "diff")
17c0e8e1
AL		 2260 continue;
2261
2262 // Tar only mode only fetches .tar files
2263 if (_config->FindB("APT::Get::Tar-Only",false) == true &&
b2e465d6 2264 I->Type != "tar")
17c0e8e1 2265 continue;
092ae175 2266
1979e742
MV		 2267 // Dsc only mode only fetches .dsc files
2268 if (_config->FindB("APT::Get::Dsc-Only",false) == true &&
2269 I->Type != "dsc")
2270 continue;
2271
092ae175
MV		 2272 // don't download the same uri twice (should this be moved to
2273 // the fetcher interface itself?)
2274 if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
2275 continue;
2276 queued.insert(Last->Index().ArchiveURI(I->Path));
2277
2278 // check if we have a file with that md5 sum already localy
2279 if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
2280 {
2281 FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
2282 MD5Summation sum;
2283 sum.AddFD(Fd.Fd(), Fd.Size());
2284 Fd.Close();
2285 if((string)sum.Result() == I->MD5Hash)
2286 {
443cb67c 2287 ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
092ae175
MV		 2288 flNotDir(I->Path).c_str());
2289 continue;
2290 }
2291 }
2292
b2e465d6
AL		 2293 new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
2294 I->MD5Hash,I->Size,
2295 Last->Index().SourceInfo(*Last,*I),Src);
36375005
AL		 2296 }
2297 }
2298
2299 // Display statistics
b2e465d6
AL		 2300 double FetchBytes = Fetcher.FetchNeeded();
2301 double FetchPBytes = Fetcher.PartialPresent();
2302 double DebBytes = Fetcher.TotalNeeded();
36375005
AL		 2303
2304 // Check for enough free space
f332b62b 2305 struct statvfs Buf;
36375005 2306 string OutputDir = ".";
c1ce032a
DK		 2307 if (statvfs(OutputDir.c_str(),&Buf) != 0) {
2308 if (errno == EOVERFLOW)
2309 return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
2310 OutputDir.c_str());
2311 else
2312 return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
2313 OutputDir.c_str());
2314 } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
885d204b
OS		 2315 {
2316 struct statfs Stat;
f64196e8
DK		 2317 if (statfs(OutputDir.c_str(),&Stat) != 0
2318#if HAVE_STRUCT_STATFS_F_TYPE
2319 || unsigned(Stat.f_type) != RAMFS_MAGIC
2320#endif
2321 )
885d204b
OS		 2322 return _error->Error(_("You don't have enough free space in %s"),
2323 OutputDir.c_str());
2324 }
36375005
AL		 2325
2326 // Number of bytes
36375005 2327 if (DebBytes != FetchBytes)
b2e465d6
AL		 2328 ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
2329 SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
36375005 2330 else
b2e465d6
AL		 2331 ioprintf(c1out,_("Need to get %sB of source archives.\n"),
2332 SizeToStr(DebBytes).c_str());
2333
2c0c53b3
AL		 2334 if (_config->FindB("APT::Get::Simulate",false) == true)
2335 {
2336 for (unsigned I = 0; I != J; I++)
db0db9fe 2337 ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
3a4477a4 2338 delete[] Dsc;
2c0c53b3
AL		 2339 return true;
2340 }
2341
36375005
AL		 2342 // Just print out the uris an exit if the --print-uris flag was used
2343 if (_config->FindB("APT::Get::Print-URIs") == true)
2344 {
2345 pkgAcquire::UriIterator I = Fetcher.UriBegin();
2346 for (; I != Fetcher.UriEnd(); I++)
2347 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
495e5cb2 2348 I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
3a4477a4 2349 delete[] Dsc;
36375005
AL		 2350 return true;
2351 }
2352
2353 // Run it
024d1123 2354 if (Fetcher.Run() == pkgAcquire::Failed)
36375005
AL		 2355 return false;
2356
2357 // Print error messages
fb0ee66e 2358 bool Failed = false;
076d01b0 2359 for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
36375005
AL		 2360 {
2361 if ((*I)->Status == pkgAcquire::Item::StatDone &&
2362 (*I)->Complete == true)
2363 continue;
2364
b2e465d6
AL		 2365 fprintf(stderr,_("Failed to fetch %s %s\n"),(*I)->DescURI().c_str(),
2366 (*I)->ErrorText.c_str());
fb0ee66e 2367 Failed = true;
36375005 2368 }
fb0ee66e 2369 if (Failed == true)
b2e465d6 2370 return _error->Error(_("Failed to fetch some archives."));
fb0ee66e
AL		 2371
2372 if (_config->FindB("APT::Get::Download-only",false) == true)
b2e465d6
AL		 2373 {
2374 c1out << _("Download complete and in download only mode") << endl;
3a4477a4 2375 delete[] Dsc;
fb0ee66e 2376 return true;
b2e465d6
AL		 2377 }
2378
fb0ee66e 2379 // Unpack the sources
54676e1a
AL		 2380 pid_t Process = ExecFork();
2381
2382 if (Process == 0)
fb0ee66e 2383 {
827d04d3 2384 bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
54676e1a 2385 for (unsigned I = 0; I != J; I++)
fb0ee66e 2386 {
b2e465d6 2387 string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
fb0ee66e 2388
17c0e8e1
AL		 2389 // Diff only mode only fetches .diff files
2390 if (_config->FindB("APT::Get::Diff-Only",false) == true ||
a3eaf954
AL		 2391 _config->FindB("APT::Get::Tar-Only",false) == true ||
2392 Dsc[I].Dsc.empty() == true)
17c0e8e1 2393 continue;
a3eaf954 2394
54676e1a
AL		 2395 // See if the package is already unpacked
2396 struct stat Stat;
827d04d3 2397 if (fixBroken == false && stat(Dir.c_str(),&Stat) == 0 &&
54676e1a
AL		 2398 S_ISDIR(Stat.st_mode) != 0)
2399 {
b2e465d6
AL		 2400 ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
2401 Dir.c_str());
54676e1a
AL		 2402 }
2403 else
2404 {
2405 // Call dpkg-source
2406 char S[500];
2407 snprintf(S,sizeof(S),"%s -x %s",
2408 _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2409 Dsc[I].Dsc.c_str());
2410 if (system(S) != 0)
2411 {
b2e465d6 2412 fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
14cd494a 2413 fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
54676e1a
AL		 2414 _exit(1);
2415 }
2416 }
2417
2418 // Try to compile it with dpkg-buildpackage
2419 if (_config->FindB("APT::Get::Compile",false) == true)
2420 {
2421 // Call dpkg-buildpackage
2422 char S[500];
2423 snprintf(S,sizeof(S),"cd %s && %s %s",
2424 Dir.c_str(),
2425 _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2426 _config->Find("DPkg::Build-Options","-b -uc").c_str());
2427
2428 if (system(S) != 0)
2429 {
b2e465d6 2430 fprintf(stderr,_("Build command '%s' failed.\n"),S);
54676e1a
AL		 2431 _exit(1);
2432 }
2433 }
2434 }
2435
2436 _exit(0);
2437 }
3a4477a4
DK		 2438 delete[] Dsc;
2439
54676e1a
AL		 2440 // Wait for the subprocess
2441 int Status = 0;
2442 while (waitpid(Process,&Status,0) != Process)
2443 {
2444 if (errno == EINTR)
2445 continue;
2446 return _error->Errno("waitpid","Couldn't wait for subprocess");
2447 }
2448
2449 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
b2e465d6
AL		 2450 return _error->Error(_("Child process failed"));
2451
2452 return true;
2453}
2454 /*}}}*/
2455// DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/
2456// ---------------------------------------------------------------------
2457/* This function will look at the build depends list of the given source
2458 package and install the necessary packages to make it true, or fail. */
2459bool DoBuildDep(CommandLine &CmdL)
2460{
2461 CacheFile Cache;
2462 if (Cache.Open(true) == false)
2463 return false;
2464
2465 if (CmdL.FileSize() <= 1)
2466 return _error->Error(_("Must specify at least one package to check builddeps for"));
2467
2468 // Read the source list
2469 pkgSourceList List;
2470 if (List.ReadMainList() == false)
2471 return _error->Error(_("The list of sources could not be read."));
54676e1a 2472
b2e465d6
AL		 2473 // Create the text record parsers
2474 pkgRecords Recs(Cache);
2475 pkgSrcRecords SrcRecs(List);
2476 if (_error->PendingError() == true)
2477 return false;
2478
2479 // Create the download object
2480 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1cd1c398
DK		 2481 pkgAcquire Fetcher;
2482 if (Fetcher.Setup(&Stat) == false)
2483 return false;
b2e465d6
AL		 2484
2485 unsigned J = 0;
2486 for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2487 {
2488 string Src;
2489 pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2490 if (Last == 0)
2491 return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2492
2493 // Process the build-dependencies
2494 vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
af3f8112 2495 if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only",true)) == false)
b2e465d6
AL		 2496 return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
2497
7d6f9f8f
AL		 2498 // Also ensure that build-essential packages are present
2499 Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
2500 if (Opts)
2501 Opts = Opts->Child;
2502 for (; Opts; Opts = Opts->Next)
2503 {
2504 if (Opts->Value.empty() == true)
2505 continue;
2506
2507 pkgSrcRecords::Parser::BuildDepRec rec;
2508 rec.Package = Opts->Value;
2509 rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
2510 rec.Op = 0;
58d76831 2511 BuildDeps.push_back(rec);
7d6f9f8f
AL		 2512 }
2513
b2e465d6
AL		 2514 if (BuildDeps.size() == 0)
2515 {
2516 ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
2517 continue;
2518 }
2519
2520 // Install the requested packages
2521 unsigned int ExpectedInst = 0;
2522 vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
2523 pkgProblemResolver Fix(Cache);
58d76831 2524 bool skipAlternatives = false; // skip remaining alternatives in an or group
b2e465d6
AL		 2525 for (D = BuildDeps.begin(); D != BuildDeps.end(); D++)
2526 {
58d76831
AL		 2527 bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
2528
2529 if (skipAlternatives == true)
2530 {
2531 if (!hasAlternatives)
2532 skipAlternatives = false; // end of or group
2533 continue;
2534 }
2535
aa2d22be
AL		 2536 if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
2537 (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
d3fc0061 2538 {
aa2d22be
AL		 2539 pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2540 // Build-conflicts on unknown packages are silently ignored
2541 if (Pkg.end() == true)
2542 continue;
2543
2544 pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2545
2546 /*
2547 * Remove if we have an installed version that satisfies the
2548 * version criteria
2549 */
2550 if (IV.end() == false &&
2551 Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2552 TryToInstall(Pkg,Cache,Fix,true,false,ExpectedInst);
d3fc0061 2553 }
aa2d22be
AL		 2554 else // BuildDep || BuildDepIndep
2555 {
2556 pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
58d76831
AL		 2557 if (_config->FindB("Debug::BuildDeps",false) == true)
2558 cout << "Looking for " << (*D).Package << "...\n";
2559
aa2d22be
AL		 2560 if (Pkg.end() == true)
2561 {
58d76831
AL		 2562 if (_config->FindB("Debug::BuildDeps",false) == true)
2563 cout << " (not found)" << (*D).Package << endl;
2564
2565 if (hasAlternatives)
2566 continue;
2567
2568 return _error->Error(_("%s dependency for %s cannot be satisfied "
2569 "because the package %s cannot be found"),
2570 Last->BuildDepType((*D).Type),Src.c_str(),
2571 (*D).Package.c_str());
aa2d22be
AL		 2572 }
2573
2574 /*
2575 * if there are alternatives, we've already picked one, so skip
2576 * the rest
2577 *
2578 * TODO: this means that if there's a build-dep on A|B and B is
2579 * installed, we'll still try to install A; more importantly,
2580 * if A is currently broken, we cannot go back and try B. To fix
2581 * this would require we do a Resolve cycle for each package we
2582 * add to the install list. Ugh
2583 */
aa2d22be 2584
cfa5659c
AL		 2585 /*
2586 * If this is a virtual package, we need to check the list of
2587 * packages that provide it and see if any of those are
2588 * installed
2589 */
2590 pkgCache::PrvIterator Prv = Pkg.ProvidesList();
a8a0fdcf
AL		 2591 for (; Prv.end() != true; Prv++)
2592 {
58d76831 2593 if (_config->FindB("Debug::BuildDeps",false) == true)
75ce2062 2594 cout << " Checking provider " << Prv.OwnerPkg().FullName() << endl;
58d76831 2595
cfa5659c
AL		 2596 if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
2597 break;
cb99271c 2598 }
e5002e30
AL		 2599
2600 // Get installed version and version we are going to install
2601 pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
e5002e30 2602
58d76831
AL		 2603 if ((*D).Version[0] != '\0') {
2604 // Versioned dependency
cb99271c
AL		 2605
2606 pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
2607
2608 for (; CV.end() != true; CV++)
2609 {
2610 if (Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2611 break;
2612 }
2613 if (CV.end() == true)
085bedac 2614 {
34e88622
AL		 2615 if (hasAlternatives)
2616 {
2617 continue;
2618 }
2619 else
2620 {
cb99271c
AL		 2621 return _error->Error(_("%s dependency for %s cannot be satisfied "
2622 "because no available versions of package %s "
2623 "can satisfy version requirements"),
2624 Last->BuildDepType((*D).Type),Src.c_str(),
2625 (*D).Package.c_str());
34e88622 2626 }
085bedac 2627 }
e5002e30 2628 }
58d76831
AL		 2629 else
2630 {
2631 // Only consider virtual packages if there is no versioned dependency
2632 if (Prv.end() == false)
2633 {
2634 if (_config->FindB("Debug::BuildDeps",false) == true)
75ce2062 2635 cout << " Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
58d76831
AL		 2636 skipAlternatives = hasAlternatives;
2637 continue;
2638 }
2639 }
cfa5659c 2640
58d76831
AL		 2641 if (IV.end() == false)
2642 {
2643 if (_config->FindB("Debug::BuildDeps",false) == true)
2644 cout << " Is installed\n";
2645
2646 if (Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2647 {
2648 skipAlternatives = hasAlternatives;
2649 continue;
2650 }
2651
2652 if (_config->FindB("Debug::BuildDeps",false) == true)
2653 cout << " ...but the installed version doesn't meet the version requirement\n";
2654
2655 if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
2656 {
2657 return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2658 Last->BuildDepType((*D).Type),
2659 Src.c_str(),
75ce2062 2660 Pkg.FullName(true).c_str());
58d76831
AL		 2661 }
2662 }
2663
2664
2665 if (_config->FindB("Debug::BuildDeps",false) == true)
2666 cout << " Trying to install " << (*D).Package << endl;
2667
2668 if (TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst) == true)
2669 {
2670 // We successfully installed something; skip remaining alternatives
2671 skipAlternatives = hasAlternatives;
d59228b0 2672 if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
496a05c6 2673 Cache->MarkAuto(Pkg, true);
58d76831
AL		 2674 continue;
2675 }
2676 else if (hasAlternatives)
2677 {
2678 if (_config->FindB("Debug::BuildDeps",false) == true)
2679 cout << " Unsatisfiable, trying alternatives\n";
2680 continue;
2681 }
2682 else
2683 {
2684 return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
2685 Last->BuildDepType((*D).Type),
2686 Src.c_str(),
2687 (*D).Package.c_str());
2688 }
b2e465d6
AL		 2689 }
2690 }
2691
2692 Fix.InstallProtect();
2693 if (Fix.Resolve(true) == false)
2694 _error->Discard();
2695
2696 // Now we check the state of the packages,
2697 if (Cache->BrokenCount() != 0)
0dae8ac5
DK		 2698 {
2699 ShowBroken(cout, Cache, false);
2700 return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
2701 }
b2e465d6
AL		 2702 }
2703
2704 if (InstallPackages(Cache, false, true) == false)
2705 return _error->Error(_("Failed to process build dependencies"));
36375005
AL		 2706 return true;
2707}
2708 /*}}}*/
b2e465d6
AL		 2709// DoMoo - Never Ask, Never Tell /*{{{*/
2710// ---------------------------------------------------------------------
2711/* */
2712bool DoMoo(CommandLine &CmdL)
2713{
2714 cout <<
2715 " (__) \n"
2716 " (oo) \n"
2717 " /------\\/ \n"
2718 " / | || \n"
2719 " * /\\---/\\ \n"
2720 " ~~ ~~ \n"
2721 "....\"Have you mooed today?\"...\n";
2722
2723 return true;
2724}
2725 /*}}}*/
0a8e3465
AL		 2726// ShowHelp - Show a help screen /*{{{*/
2727// ---------------------------------------------------------------------
2728/* */
212ad54a 2729bool ShowHelp(CommandLine &CmdL)
0a8e3465 2730{
5b28c804
OS		 2731 ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
2732 COMMON_ARCH,__DATE__,__TIME__);
b2e465d6 2733
04aa15a8 2734 if (_config->FindB("version") == true)
b2e465d6 2735 {
db0db9fe 2736 cout << _("Supported modules:") << endl;
b2e465d6
AL		 2737
2738 for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
2739 {
2740 pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
2741 if (_system != 0 && _system->VS == VS)
2742 cout << '*';
2743 else
2744 cout << ' ';
2745 cout << "Ver: " << VS->Label << endl;
2746
2747 /* Print out all the packaging systems that will work with
2748 this VS */
2749 for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
2750 {
2751 pkgSystem *Sys = pkgSystem::GlobalList[J];
2752 if (_system == Sys)
2753 cout << '*';
2754 else
2755 cout << ' ';
2756 if (Sys->VS->TestCompatibility(*VS) == true)
2757 cout << "Pkg: " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
2758 }
2759 }
2760
2761 for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
2762 {
2763 pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
2764 cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
2765 }
2766
2767 for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
2768 {
2769 pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
2770 cout << " Idx: " << Type->Label << endl;
2771 }
2772
2773 return true;
2774 }
2775
2776 cout <<
2777 _("Usage: apt-get [options] command\n"
2778 " apt-get [options] install|remove pkg1 [pkg2 ...]\n"
2779 " apt-get [options] source pkg1 [pkg2 ...]\n"
2780 "\n"
2781 "apt-get is a simple command line interface for downloading and\n"
2782 "installing packages. The most frequently used commands are update\n"
2783 "and install.\n"
2784 "\n"
2785 "Commands:\n"
2786 " update - Retrieve new lists of packages\n"
2787 " upgrade - Perform an upgrade\n"
2788 " install - Install new packages (pkg is libc6 not libc6.deb)\n"
2789 " remove - Remove packages\n"
12bffed7 2790 " autoremove - Remove automatically all unused packages\n"
73fc19d0 2791 " purge - Remove packages and config files\n"
b2e465d6
AL		 2792 " source - Download source archives\n"
2793 " build-dep - Configure build-dependencies for source packages\n"
2794 " dist-upgrade - Distribution upgrade, see apt-get(8)\n"
2795 " dselect-upgrade - Follow dselect selections\n"
2796 " clean - Erase downloaded archive files\n"
2797 " autoclean - Erase old downloaded archive files\n"
2798 " check - Verify that there are no broken dependencies\n"
2799 "\n"
2800 "Options:\n"
2801 " -h This help text.\n"
2802 " -q Loggable output - no progress indicator\n"
2803 " -qq No output except for errors\n"
2804 " -d Download only - do NOT install or unpack archives\n"
2805 " -s No-act. Perform ordering simulation\n"
2806 " -y Assume Yes to all queries and do not prompt\n"
0748d509 2807 " -f Attempt to correct a system with broken dependencies in place\n"
b2e465d6
AL		 2808 " -m Attempt to continue if archives are unlocatable\n"
2809 " -u Show a list of upgraded packages as well\n"
2810 " -b Build the source package after fetching it\n"
ac625538 2811 " -V Show verbose version numbers\n"
b2e465d6 2812 " -c=? Read this configuration file\n"
a2884e32 2813 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
b2e465d6
AL		 2814 "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
2815 "pages for more information and options.\n"
2816 " This APT has Super Cow Powers.\n");
2817 return true;
0a8e3465
AL		 2818}
2819 /*}}}*/
2820// GetInitialize - Initialize things for apt-get /*{{{*/
2821// ---------------------------------------------------------------------
2822/* */
2823void GetInitialize()
2824{
2825 _config->Set("quiet",0);
2826 _config->Set("help",false);
2827 _config->Set("APT::Get::Download-Only",false);
2828 _config->Set("APT::Get::Simulate",false);
2829 _config->Set("APT::Get::Assume-Yes",false);
2830 _config->Set("APT::Get::Fix-Broken",false);
83d89a9f 2831 _config->Set("APT::Get::Force-Yes",false);
640c5d94 2832 _config->Set("APT::Get::List-Cleanup",true);
afb1e2e3 2833 _config->Set("APT::Get::AutomaticRemove",false);
0a8e3465
AL		 2834}
2835 /*}}}*/
d7827aca
AL		 2836// SigWinch - Window size change signal handler /*{{{*/
2837// ---------------------------------------------------------------------
2838/* */
2839void SigWinch(int)
2840{
2841 // Riped from GNU ls
2842#ifdef TIOCGWINSZ
2843 struct winsize ws;
2844
2845 if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
2846 ScreenWidth = ws.ws_col - 1;
2847#endif
2848}
2849 /*}}}*/
92fcbfc1 2850int main(int argc,const char *argv[]) /*{{{*/
0a8e3465
AL		 2851{
2852 CommandLine::Args Args[] = {
2853 {'h',"help","help",0},
04aa15a8 2854 {'v',"version","version",0},
ac625538 2855 {'V',"verbose-versions","APT::Get::Show-Versions",0},
0a8e3465
AL		 2856 {'q',"quiet","quiet",CommandLine::IntLevel},
2857 {'q',"silent","quiet",CommandLine::IntLevel},
2858 {'d',"download-only","APT::Get::Download-Only",0},
fb0ee66e
AL		 2859 {'b',"compile","APT::Get::Compile",0},
2860 {'b',"build","APT::Get::Compile",0},
d150b09d
AL		 2861 {'s',"simulate","APT::Get::Simulate",0},
2862 {'s',"just-print","APT::Get::Simulate",0},
2863 {'s',"recon","APT::Get::Simulate",0},
6df23d2f 2864 {'s',"dry-run","APT::Get::Simulate",0},
d150b09d
AL		 2865 {'s',"no-act","APT::Get::Simulate",0},
2866 {'y',"yes","APT::Get::Assume-Yes",0},
0a8e3465
AL		 2867 {'y',"assume-yes","APT::Get::Assume-Yes",0},
2868 {'f',"fix-broken","APT::Get::Fix-Broken",0},
2869 {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
30e1eab5 2870 {'m',"ignore-missing","APT::Get::Fix-Missing",0},
b2e465d6
AL		 2871 {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
2872 {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
2873 {0,"download","APT::Get::Download",0},
30e1eab5 2874 {0,"fix-missing","APT::Get::Fix-Missing",0},
b2e465d6
AL		 2875 {0,"ignore-hold","APT::Ignore-Hold",0},
2876 {0,"upgrade","APT::Get::upgrade",0},
6cd9fbd7 2877 {0,"only-upgrade","APT::Get::Only-Upgrade",0},
83d89a9f 2878 {0,"force-yes","APT::Get::force-yes",0},
f7a08e33 2879 {0,"print-uris","APT::Get::Print-URIs",0},
5fafc0ef 2880 {0,"diff-only","APT::Get::Diff-Only",0},
a0895a74 2881 {0,"debian-only","APT::Get::Diff-Only",0},
1979e742
MV		 2882 {0,"tar-only","APT::Get::Tar-Only",0},
2883 {0,"dsc-only","APT::Get::Dsc-Only",0},
fc4b5c9f 2884 {0,"purge","APT::Get::Purge",0},
9df71a5b 2885 {0,"list-cleanup","APT::Get::List-Cleanup",0},
d0c59649 2886 {0,"reinstall","APT::Get::ReInstall",0},
d150b09d 2887 {0,"trivial-only","APT::Get::Trivial-Only",0},
b2e465d6
AL		 2888 {0,"remove","APT::Get::Remove",0},
2889 {0,"only-source","APT::Get::Only-Source",0},
45430cbf 2890 {0,"arch-only","APT::Get::Arch-Only",0},
f8ac1720 2891 {0,"auto-remove","APT::Get::AutomaticRemove",0},
7db98ffc 2892 {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
e9ae3677 2893 {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean},
4ef9a929 2894 {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
0a8e3465
AL		 2895 {'c',"config-file",0,CommandLine::ConfigFile},
2896 {'o',"option",0,CommandLine::ArbItem},
2897 {0,0,0,0}};
83d89a9f
AL		 2898 CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
2899 {"upgrade",&DoUpgrade},
2900 {"install",&DoInstall},
2901 {"remove",&DoInstall},
24401c09 2902 {"purge",&DoInstall},
74a05226 2903 {"autoremove",&DoInstall},
9efa2e91 2904 {"purge",&DoInstall},
83d89a9f
AL		 2905 {"dist-upgrade",&DoDistUpgrade},
2906 {"dselect-upgrade",&DoDSelectUpgrade},
b2e465d6 2907 {"build-dep",&DoBuildDep},
83d89a9f 2908 {"clean",&DoClean},
1bc849af 2909 {"autoclean",&DoAutoClean},
83d89a9f 2910 {"check",&DoCheck},
67111687 2911 {"source",&DoSource},
b2e465d6 2912 {"moo",&DoMoo},
67111687 2913 {"help",&ShowHelp},
83d89a9f 2914 {0,0}};
67111687
AL		 2915
2916 // Set up gettext support
2917 setlocale(LC_ALL,"");
2918 textdomain(PACKAGE);
2919
0a8e3465
AL		 2920 // Parse the command line and initialize the package library
2921 CommandLine CmdL(Args,_config);
b2e465d6
AL		 2922 if (pkgInitConfig(*_config) == false ||
2923 CmdL.Parse(argc,argv) == false ||
2924 pkgInitSystem(*_config,_system) == false)
0a8e3465 2925 {
b2e465d6
AL		 2926 if (_config->FindB("version") == true)
2927 ShowHelp(CmdL);
2928
0a8e3465
AL		 2929 _error->DumpErrors();
2930 return 100;
2931 }
2932
2933 // See if the help should be shown
2934 if (_config->FindB("help") == true ||
04aa15a8 2935 _config->FindB("version") == true ||
0a8e3465 2936 CmdL.FileSize() == 0)
b2e465d6
AL		 2937 {
2938 ShowHelp(CmdL);
2939 return 0;
2940 }
55a5a46c
MV		 2941
2942 // simulate user-friendly if apt-get has no root privileges
2943 if (getuid() != 0 && _config->FindB("APT::Get::Simulate") == true)
2944 {
ecf59bfc
DK		 2945 if (_config->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
2946 cout << _("NOTE: This is only a simulation!\n"
2947 " apt-get needs root privileges for real execution.\n"
2948 " Keep also in mind that locking is deactivated,\n"
2949 " so don't depend on the relevance to the real current situation!"
2950 ) << std::endl;
55a5a46c
MV		 2951 _config->Set("Debug::NoLocking",true);
2952 }
2953
a9a5908d 2954 // Deal with stdout not being a tty
00581c6b 2955 if (!isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
a9a5908d 2956 _config->Set("quiet","1");
01b64152 2957
0a8e3465
AL		 2958 // Setup the output streams
2959 c0out.rdbuf(cout.rdbuf());
2960 c1out.rdbuf(cout.rdbuf());
2961 c2out.rdbuf(cout.rdbuf());
2962 if (_config->FindI("quiet",0) > 0)
2963 c0out.rdbuf(devnull.rdbuf());
2964 if (_config->FindI("quiet",0) > 1)
2965 c1out.rdbuf(devnull.rdbuf());
d7827aca
AL		 2966
2967 // Setup the signals
2968 signal(SIGPIPE,SIG_IGN);
2969 signal(SIGWINCH,SigWinch);
2970 SigWinch(0);
b2e465d6 2971
0a8e3465 2972 // Match the operation
83d89a9f 2973 CmdL.DispatchArg(Cmds);
0a8e3465
AL		 2974
2975 // Print any errors or warnings found during parsing
2976 if (_error->empty() == false)
2977 {
2978 bool Errors = _error->PendingError();
2979 _error->DumpErrors();
0a8e3465
AL		 2980 return Errors == true?100:0;
2981 }
2982
2983 return 0;
2984}
92fcbfc1 2985 /*}}}*/
ntk's bugfix for apt