HCoop / ntk / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* apt-pkg/contrib/weakptr.h:
[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();
259f688a
MV		 1318 // exit right away from the Pkg.VersionList() loop if we
1319 // don't have any versions
1320 if (Ver.end() == true)
1321 break;
e84adb76
DK		 1322 }
1323 // We match against a concrete version (or a part of this version)
1324 if (VerTag.empty() == false &&
1325 (fuzzy == true || Cache.VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
1326 (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
1327 continue;
1328
fb3dc579
MV		 1329 for (pkgCache::VerFileIterator VF = Ver.FileList();
1330 VF.end() == false; VF++)
aca056a9 1331 {
fb3dc579
MV		 1332 /* If this is the status file, and the current version is not the
1333 version in the status file (ie it is not installed, or somesuch)
1334 then it is not a candidate for installation, ever. This weeds
1335 out bogus entries that may be due to config-file states, or
1336 other. */
1337 if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
1338 pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
1339 continue;
1340
fb3dc579
MV		 1341 // or we match against a release
1342 if(VerTag.empty() == false ||
1343 (VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
1344 (VF.File().Codename() != 0 && VF.File().Codename() == DefRel))
1345 {
1346 pkgRecords::Parser &Parse = Recs.Lookup(VF);
1347 Src = Parse.SourcePkg();
61690a7e
MV		 1348 // no SourcePkg name, so it is the "binary" name
1349 if (Src.empty() == true)
1350 Src = TmpSrc;
e84adb76
DK		 1351 // the Version we have is possibly fuzzy or includes binUploads,
1352 // so we use the Version of the SourcePkg (empty if same as package)
1353 VerTag = Parse.SourceVer();
61690a7e
MV		 1354 if (VerTag.empty() == true)
1355 VerTag = Ver.VerStr();
fb3dc579
MV		 1356 break;
1357 }
aca056a9 1358 }
61690a7e
MV		 1359 if (Src.empty() == false)
1360 break;
aca056a9 1361 }
fb3dc579
MV		 1362 if (Src.empty() == true)
1363 {
61690a7e 1364 // Sources files have no codename information
ddff663f
MV		 1365 if (VerTag.empty() == true && DefRel.empty() == false)
1366 {
1367 _error->Error(_("Ignore unavailable target release '%s' of package '%s'"), DefRel.c_str(), TmpSrc.c_str());
1368 return 0;
1369 }
fb3dc579 1370 }
026f60e2 1371 }
61690a7e 1372 if (Src.empty() == true)
b2e465d6 1373 {
61690a7e
MV		 1374 // if we don't have found a fitting package yet so we will
1375 // choose a good candidate and proceed with that.
1376 // Maybe we will find a source later on with the right VerTag
ce6162be 1377 pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
fb3dc579 1378 if (Ver.end() == false)
b2e465d6
AL		 1379 {
1380 pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1381 Src = Parse.SourcePkg();
61690a7e
MV		 1382 if (VerTag.empty() == true)
1383 VerTag = Parse.SourceVer();
b2e465d6 1384 }
fb3dc579
MV		 1385 }
1386 }
1387
1388 if (Src.empty() == true)
1389 Src = TmpSrc;
1390 else
1391 {
1392 /* if we have a source pkg name, make sure to only search
1393 for srcpkg names, otherwise apt gets confused if there
1394 is a binary package "pkg1" and a source package "pkg1"
1395 with the same name but that comes from different packages */
1396 MatchSrcOnly = true;
1397 if (Src != TmpSrc)
1398 {
1399 ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
1400 }
b2e465d6 1401 }
89ad8e7c 1402
b2e465d6
AL		 1403 // The best hit
1404 pkgSrcRecords::Parser *Last = 0;
1405 unsigned long Offset = 0;
1406 string Version;
89ad8e7c 1407
b2e465d6
AL		 1408 /* Iterate over all of the hits, which includes the resulting
1409 binary packages in the search */
1410 pkgSrcRecords::Parser *Parse;
fb3dc579 1411 while (true)
b2e465d6 1412 {
fb3dc579
MV		 1413 SrcRecs.Restart();
1414 while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
b2e465d6 1415 {
fb3dc579
MV		 1416 const string Ver = Parse->Version();
1417
1418 // Ignore all versions which doesn't fit
e84adb76
DK		 1419 if (VerTag.empty() == false &&
1420 Cache.VS().CmpVersion(VerTag, Ver) != 0) // exact match
b2e465d6 1421 continue;
fb3dc579
MV		 1422
1423 // Newer version or an exact match? Save the hit
1424 if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0) {
1425 Last = Parse;
1426 Offset = Parse->Offset();
1427 Version = Ver;
1428 }
1429
1430 // was the version check above an exact match? If so, we don't need to look further
1431 if (VerTag.empty() == false && VerTag.size() == Ver.size())
1432 break;
b2e465d6 1433 }
fb3dc579
MV		 1434 if (Last != 0 || VerTag.empty() == true)
1435 break;
1436 //if (VerTag.empty() == false && Last == 0)
ddff663f
MV		 1437 _error->Error(_("Ignore unavailable version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
1438 return 0;
b2e465d6 1439 }
fb3dc579 1440
ce6162be 1441 if (Last == 0 || Last->Jump(Offset) == false)
b2e465d6 1442 return 0;
fb3dc579 1443
b2e465d6
AL		 1444 return Last;
1445}
1446 /*}}}*/
0a8e3465
AL		 1447// DoUpdate - Update the package lists /*{{{*/
1448// ---------------------------------------------------------------------
1449/* */
b2e465d6 1450bool DoUpdate(CommandLine &CmdL)
0a8e3465 1451{
b2e465d6
AL		 1452 if (CmdL.FileSize() != 1)
1453 return _error->Error(_("The update command takes no arguments"));
1454
0919e3f9
AL		 1455 // Get the source list
1456 pkgSourceList List;
1457 if (List.ReadMainList() == false)
1458 return false;
1459
89b70b5a 1460 // Create the progress
0919e3f9 1461 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
89b70b5a 1462
f0863b21
AL		 1463 // Just print out the uris an exit if the --print-uris flag was used
1464 if (_config->FindB("APT::Get::Print-URIs") == true)
1465 {
a722b2c5
DK		 1466 // force a hashsum for compatibility reasons
1467 _config->CndSet("Acquire::ForceHash", "md5sum");
1468
89b70b5a 1469 // get a fetcher
1cd1c398
DK		 1470 pkgAcquire Fetcher;
1471 if (Fetcher.Setup(&Stat) == false)
1472 return false;
89b70b5a 1473
7db98ffc
MZ		 1474 // Populate it with the source selection and get all Indexes
1475 // (GetAll=true)
1476 if (List.GetIndexes(&Fetcher,true) == false)
1477 return false;
1478
f0863b21
AL		 1479 pkgAcquire::UriIterator I = Fetcher.UriBegin();
1480 for (; I != Fetcher.UriEnd(); I++)
1481 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
495e5cb2 1482 I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
f0863b21
AL		 1483 return true;
1484 }
7db98ffc 1485
89b70b5a 1486 // do the work
0919e3f9 1487 CacheFile Cache;
e88d983a
OS		 1488 if (_config->FindB("APT::Get::Download",true) == true)
1489 ListUpdate(Stat, List);
1490
89b70b5a 1491 // Rebuild the cache.
0077d829 1492 if (Cache.BuildCaches() == false)
0919e3f9
AL		 1493 return false;
1494
1495 return true;
afb1e2e3
MV		 1496}
1497 /*}}}*/
1498// DoAutomaticRemove - Remove all automatic unused packages /*{{{*/
1499// ---------------------------------------------------------------------
1500/* Remove unused automatic packages */
1501bool DoAutomaticRemove(CacheFile &Cache)
1502{
9d2938d4 1503 bool Debug = _config->FindI("Debug::pkgAutoRemove",false);
b255ff1a 1504 bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);
7898bd97 1505 bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");
afb1e2e3 1506
03dbbc98 1507 pkgDepCache::ActionGroup group(*Cache);
9d2938d4 1508 if(Debug)
120365ce 1509 std::cout << "DoAutomaticRemove()" << std::endl;
afb1e2e3 1510
03dbbc98
DK		 1511 // we don't want to autoremove and we don't want to see it, so why calculating?
1512 if (doAutoRemove == false && hideAutoRemove == true)
1513 return true;
1514
1515 if (doAutoRemove == true &&
1516 _config->FindB("APT::Get::Remove",true) == false)
afb1e2e3 1517 {
3d0de656
MV		 1518 c1out << _("We are not supposed to delete stuff, can't start "
1519 "AutoRemover") << std::endl;
03dbbc98 1520 return false;
3d0de656 1521 }
74a05226 1522
03dbbc98
DK		 1523 bool purgePkgs = _config->FindB("APT::Get::Purge", false);
1524 bool smallList = (hideAutoRemove == false &&
1525 strcasecmp(_config->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
1526
9d2938d4 1527 string autoremovelist, autoremoveversions;
03dbbc98 1528 unsigned long autoRemoveCount = 0;
9d2938d4
MV		 1529 // look over the cache to see what can be removed
1530 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); ! Pkg.end(); ++Pkg)
afb1e2e3 1531 {
9d2938d4
MV		 1532 if (Cache[Pkg].Garbage)
1533 {
1534 if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
1535 if(Debug)
75ce2062 1536 std::cout << "We could delete %s" << Pkg.FullName(true).c_str() << std::endl;
03dbbc98 1537
3d0de656 1538 if (doAutoRemove)
9d2938d4
MV		 1539 {
1540 if(Pkg.CurrentVer() != 0 &&
1541 Pkg->CurrentState != pkgCache::State::ConfigFiles)
03dbbc98 1542 Cache->MarkDelete(Pkg, purgePkgs);
9d2938d4 1543 else
74a05226 1544 Cache->MarkKeep(Pkg, false, false);
9d2938d4 1545 }
03dbbc98
DK		 1546 else
1547 {
1548 // only show stuff in the list that is not yet marked for removal
1549 if(Cache[Pkg].Delete() == false)
1550 {
f0f2f956 1551 ++autoRemoveCount;
03dbbc98 1552 // we don't need to fill the strings if we don't need them
f0f2f956 1553 if (smallList == false)
03dbbc98 1554 {
75ce2062 1555 autoremovelist += Pkg.FullName(true) + " ";
03dbbc98
DK		 1556 autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
1557 }
1558 }
1559 }
9d2938d4 1560 }
afb1e2e3 1561 }
03dbbc98
DK		 1562 // if we don't remove them, we should show them!
1563 if (doAutoRemove == false && (autoremovelist.empty() == false || autoRemoveCount != 0))
1564 {
1565 if (smallList == false)
f0f2f956
DK		 1566 ShowList(c1out, P_("The following package is automatically installed and is no longer required:",
1567 "The following packages were automatically installed and are no longer required:",
1568 autoRemoveCount), autoremovelist, autoremoveversions);
03dbbc98 1569 else
f0f2f956
DK		 1570 ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
1571 "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);
9d2938d4 1572 c1out << _("Use 'apt-get autoremove' to remove them.") << std::endl;
03dbbc98
DK		 1573 }
1574 // Now see if we had destroyed anything (if we had done anything)
1575 else if (Cache->BrokenCount() != 0)
afb1e2e3
MV		 1576 {
1577 c1out << _("Hmm, seems like the AutoRemover destroyed something which really\n"
1578 "shouldn't happen. Please file a bug report against apt.") << endl;
1579 c1out << endl;
1580 c1out << _("The following information may help to resolve the situation:") << endl;
1581 c1out << endl;
1582 ShowBroken(c1out,Cache,false);
1583
1584 return _error->Error(_("Internal Error, AutoRemover broke stuff"));
1585 }
1586 return true;
db1e7193 1587}
92fcbfc1 1588 /*}}}*/
db1e7193
MV		 1589// DoUpgrade - Upgrade all packages /*{{{*/
1590// ---------------------------------------------------------------------
1591/* Upgrade all packages without installing new packages or erasing old
1592 packages */
1593bool DoUpgrade(CommandLine &CmdL)
1594{
1595 CacheFile Cache;
1596 if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
1597 return false;
1598
1599 // Do the upgrade
1600 if (pkgAllUpgrade(Cache) == false)
1601 {
1602 ShowBroken(c1out,Cache,false);
1603 return _error->Error(_("Internal error, AllUpgrade broke stuff"));
1604 }
1605
1606 return InstallPackages(Cache,true);
afb1e2e3
MV		 1607}
1608 /*}}}*/
c158ff49
MV		 1609// DoInstallTask - Install task from the command line /*{{{*/
1610// ---------------------------------------------------------------------
1611/* Install named task */
39cc1bbd
MV		 1612bool TryInstallTask(pkgDepCache &Cache, pkgProblemResolver &Fix,
1613 bool BrokenFix,
1614 unsigned int& ExpectedInst,
394eadc8
MV		 1615 const char *taskname,
1616 bool Remove)
c158ff49
MV		 1617{
1618 const char *start, *end;
1619 pkgCache::PkgIterator Pkg;
39cc1bbd
MV		 1620 char buf[64*1024];
1621 regex_t Pattern;
c158ff49 1622
39cc1bbd 1623 // get the records
c158ff49 1624 pkgRecords Recs(Cache);
c158ff49 1625
39cc1bbd
MV		 1626 // build regexp for the task
1627 char S[300];
f03dd1e0
MV		 1628 snprintf(S, sizeof(S), "^Task:.*[, ]%s([, ]|$)", taskname);
1629 if(regcomp(&Pattern,S, REG_EXTENDED | REG_NOSUB | REG_NEWLINE) != 0)
1630 return _error->Error("Failed to compile task regexp");
39cc1bbd
MV		 1631
1632 bool found = false;
1633 bool res = true;
85bd111a
MV		 1634
1635 // two runs, first ignore dependencies, second install any missing
1636 for(int IgnoreBroken=1; IgnoreBroken >= 0; IgnoreBroken--)
c158ff49 1637 {
85bd111a
MV		 1638 for (Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
1639 {
1640 pkgCache::VerIterator ver = Cache[Pkg].CandidateVerIter(Cache);
1641 if(ver.end())
1642 continue;
1643 pkgRecords::Parser &parser = Recs.Lookup(ver.FileList());
1644 parser.GetRec(start,end);
1645 strncpy(buf, start, end-start);
1646 buf[end-start] = 0x0;
1647 if (regexec(&Pattern,buf,0,0,0) != 0)
1648 continue;
1649 res &= TryToInstall(Pkg,Cache,Fix,Remove,IgnoreBroken,ExpectedInst);
1650 found = true;
1651 }
c158ff49 1652 }
c158ff49 1653
9dbe6ae4
MV		 1654 // now let the problem resolver deal with any issues
1655 Fix.Resolve(true);
1656
39cc1bbd
MV		 1657 if(!found)
1658 _error->Error(_("Couldn't find task %s"),taskname);
1659
1660 regfree(&Pattern);
1661 return res;
c158ff49 1662}
92fcbfc1 1663 /*}}}*/
0a8e3465
AL		 1664// DoInstall - Install packages from the command line /*{{{*/
1665// ---------------------------------------------------------------------
1666/* Install named packages */
1667bool DoInstall(CommandLine &CmdL)
1668{
1669 CacheFile Cache;
c37b9502
AL		 1670 if (Cache.OpenForInstall() == false ||
1671 Cache.CheckDeps(CmdL.FileSize() != 1) == false)
0a8e3465
AL		 1672 return false;
1673
7c57fe64
AL		 1674 // Enter the special broken fixing mode if the user specified arguments
1675 bool BrokenFix = false;
1676 if (Cache->BrokenCount() != 0)
1677 BrokenFix = true;
1678
e4b74e4b 1679 unsigned int AutoMarkChanged = 0;
a6568219
AL		 1680 unsigned int ExpectedInst = 0;
1681 unsigned int Packages = 0;
0a8e3465
AL		 1682 pkgProblemResolver Fix(Cache);
1683
303a1703
AL		 1684 bool DefRemove = false;
1685 if (strcasecmp(CmdL.FileList[0],"remove") == 0)
1686 DefRemove = true;
e47c7d16
MV		 1687 else if (strcasecmp(CmdL.FileList[0], "purge") == 0)
1688 {
1689 _config->Set("APT::Get::Purge", true);
1690 DefRemove = true;
1691 }
74a05226 1692 else if (strcasecmp(CmdL.FileList[0], "autoremove") == 0)
0a8e3465 1693 {
54668e4e
MV		 1694 _config->Set("APT::Get::AutomaticRemove", "true");
1695 DefRemove = true;
1696 }
54668e4e 1697 // new scope for the ActionGroup
0a8e3465 1698 {
54668e4e
MV		 1699 pkgDepCache::ActionGroup group(Cache);
1700 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
0a8e3465 1701 {
54668e4e
MV		 1702 // Duplicate the string
1703 unsigned int Length = strlen(*I);
1704 char S[300];
1705 if (Length >= sizeof(S))
fc4b5c9f 1706 continue;
54668e4e
MV		 1707 strcpy(S,*I);
1708
1709 // See if we are removing and special indicators..
1710 bool Remove = DefRemove;
1711 char *VerTag = 0;
1712 bool VerIsRel = false;
5a68ea79
MV		 1713
1714 // this is a task!
1715 if (Length >= 1 && S[Length - 1] == '^')
1716 {
1717 S[--Length] = 0;
1718 // tasks must always be confirmed
1719 ExpectedInst += 1000;
1720 // see if we can install it
394eadc8 1721 TryInstallTask(Cache, Fix, BrokenFix, ExpectedInst, S, Remove);
5a68ea79
MV		 1722 continue;
1723 }
1724
54668e4e 1725 while (Cache->FindPkg(S).end() == true)
b2e465d6 1726 {
54668e4e
MV		 1727 // Handle an optional end tag indicating what to do
1728 if (Length >= 1 && S[Length - 1] == '-')
1729 {
1730 Remove = true;
1731 S[--Length] = 0;
1732 continue;
1733 }
b2e465d6 1734
54668e4e
MV		 1735 if (Length >= 1 && S[Length - 1] == '+')
1736 {
1737 Remove = false;
1738 S[--Length] = 0;
1739 continue;
1740 }
b2e465d6 1741
54668e4e
MV		 1742 char *Slash = strchr(S,'=');
1743 if (Slash != 0)
1744 {
1745 VerIsRel = false;
1746 *Slash = 0;
1747 VerTag = Slash + 1;
1748 }
c373c37a 1749
54668e4e
MV		 1750 Slash = strchr(S,'/');
1751 if (Slash != 0)
1752 {
1753 VerIsRel = true;
1754 *Slash = 0;
1755 VerTag = Slash + 1;
1756 }
c373c37a 1757
54668e4e 1758 break;
b2e465d6 1759 }
54668e4e
MV		 1760
1761 // Locate the package
1762 pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
1763 Packages++;
1764 if (Pkg.end() == true)
303a1703 1765 {
54668e4e
MV		 1766 // Check if the name is a regex
1767 const char *I;
1768 for (I = S; *I != 0; I++)
1769 if (*I == '?' || *I == '*' || *I == '|' ||
1770 *I == '[' || *I == '^' || *I == '$')
1771 break;
1772 if (*I == 0)
1773 return _error->Error(_("Couldn't find package %s"),S);
1774
1775 // Regexs must always be confirmed
1776 ExpectedInst += 1000;
1777
1778 // Compile the regex pattern
1779 regex_t Pattern;
1780 int Res;
1781 if ((Res = regcomp(&Pattern,S,REG_EXTENDED | REG_ICASE |
1782 REG_NOSUB)) != 0)
1783 {
1784 char Error[300];
1785 regerror(Res,&Pattern,Error,sizeof(Error));
1786 return _error->Error(_("Regex compilation error - %s"),Error);
1787 }
1788
1789 // Run over the matches
1790 bool Hit = false;
3d5a34b2 1791 for (pkgCache::GrpIterator Grp = Cache->GrpBegin(); Grp.end() == false; ++Grp)
54668e4e 1792 {
3d5a34b2 1793 if (regexec(&Pattern,Grp.Name(),0,0,0) != 0)
54668e4e 1794 continue;
3d5a34b2
DK		 1795 Pkg = Grp.FindPkg("native");
1796 if (unlikely(Pkg.end() == true))
1797 continue;
1798
54668e4e
MV		 1799 ioprintf(c1out,_("Note, selecting %s for regex '%s'\n"),
1800 Pkg.Name(),S);
07801a6d 1801
54668e4e
MV		 1802 if (VerTag != 0)
1803 if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1804 return false;
185091b7 1805
54668e4e
MV		 1806 Hit |= TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,
1807 ExpectedInst,false);
1808 }
1809 regfree(&Pattern);
1810
1811 if (Hit == false)
1812 return _error->Error(_("Couldn't find package %s"),S);
1813 }
1814 else
1815 {
b2e465d6
AL		 1816 if (VerTag != 0)
1817 if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1818 return false;
54668e4e 1819 if (TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,ExpectedInst) == false)
b2e465d6 1820 return false;
e4b74e4b
MV		 1821
1822 // see if we need to fix the auto-mark flag
1823 // e.g. apt-get install foo
1824 // where foo is marked automatic
fd59a713
MV		 1825 if(!Remove &&
1826 Cache[Pkg].Install() == false &&
085bedac 1827 (Cache[Pkg].Flags & pkgCache::Flag::Auto) &&
e57a5bff 1828 _config->FindB("APT::Get::ReInstall",false) == false &&
6cd9fbd7 1829 _config->FindB("APT::Get::Only-Upgrade",false) == false &&
e57a5bff 1830 _config->FindB("APT::Get::Download-Only",false) == false)
e4b74e4b 1831 {
da543ed8 1832 ioprintf(c1out,_("%s set to manually installed.\n"),
75ce2062 1833 Pkg.FullName(true).c_str());
e4b74e4b
MV		 1834 Cache->MarkAuto(Pkg,false);
1835 AutoMarkChanged++;
1836 }
54668e4e
MV		 1837 }
1838 }
0a8e3465 1839
54668e4e
MV		 1840 /* If we are in the Broken fixing mode we do not attempt to fix the
1841 problems. This is if the user invoked install without -f and gave
1842 packages */
1843 if (BrokenFix == true && Cache->BrokenCount() != 0)
1844 {
b5647402 1845 c1out << _("You might want to run 'apt-get -f install' to correct these:") << endl;
54668e4e 1846 ShowBroken(c1out,Cache,false);
7c57fe64 1847
54668e4e
MV		 1848 return _error->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1849 }
7c57fe64 1850
54668e4e
MV		 1851 // Call the scored problem resolver
1852 Fix.InstallProtect();
1853 if (Fix.Resolve(true) == false)
1854 _error->Discard();
0a8e3465 1855
54668e4e
MV		 1856 // Now we check the state of the packages,
1857 if (Cache->BrokenCount() != 0)
303a1703 1858 {
b2e465d6 1859 c1out <<
54668e4e
MV		 1860 _("Some packages could not be installed. This may mean that you have\n"
1861 "requested an impossible situation or if you are using the unstable\n"
1862 "distribution that some required packages have not yet been created\n"
1863 "or been moved out of Incoming.") << endl;
ecd414ef 1864 /*
54668e4e
MV		 1865 if (Packages == 1)
1866 {
1867 c1out << endl;
1868 c1out <<
1869 _("Since you only requested a single operation it is extremely likely that\n"
1870 "the package is simply not installable and a bug report against\n"
1871 "that package should be filed.") << endl;
1872 }
ecd414ef 1873 */
303a1703 1874
54668e4e
MV		 1875 c1out << _("The following information may help to resolve the situation:") << endl;
1876 c1out << endl;
1877 ShowBroken(c1out,Cache,false);
1878 return _error->Error(_("Broken packages"));
1879 }
120365ce 1880 }
5a68ea79
MV		 1881 if (!DoAutomaticRemove(Cache))
1882 return false;
afb1e2e3 1883
0a8e3465
AL		 1884 /* Print out a list of packages that are going to be installed extra
1885 to what the user asked */
1886 if (Cache->InstCount() != ExpectedInst)
1887 {
1888 string List;
ac625538 1889 string VersionsList;
1089ca89 1890 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
0a8e3465 1891 {
1089ca89 1892 pkgCache::PkgIterator I(Cache,Cache.List[J]);
0a8e3465
AL		 1893 if ((*Cache)[I].Install() == false)
1894 continue;
1895
1896 const char **J;
1897 for (J = CmdL.FileList + 1; *J != 0; J++)
1898 if (strcmp(*J,I.Name()) == 0)
1899 break;
1900
ac625538 1901 if (*J == 0) {
75ce2062 1902 List += I.FullName(true) + " ";
80fa0d8a
MV		 1903 VersionsList += string(Cache[I].CandVersion) + "\n";
1904 }
0a8e3465
AL		 1905 }
1906
ac625538 1907 ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
0a8e3465
AL		 1908 }
1909
a7e41689
AL		 1910 /* Print out a list of suggested and recommended packages */
1911 {
1912 string SuggestsList, RecommendsList, List;
72122b62 1913 string SuggestsVersions, RecommendsVersions;
a7e41689
AL		 1914 for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1915 {
29f37db8 1916 pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
a7e41689
AL		 1917
1918 /* Just look at the ones we want to install */
29f37db8 1919 if ((*Cache)[Pkg].Install() == false)
a7e41689
AL		 1920 continue;
1921
29f37db8
MV		 1922 // get the recommends/suggests for the candidate ver
1923 pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
1924 for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
1925 {
1926 pkgCache::DepIterator Start;
1927 pkgCache::DepIterator End;
1928 D.GlobOr(Start,End); // advances D
1929
cd33a786
MV		 1930 // FIXME: we really should display a or-group as a or-group to the user
1931 // the problem is that ShowList is incapable of doing this
29f37db8
MV		 1932 string RecommendsOrList,RecommendsOrVersions;
1933 string SuggestsOrList,SuggestsOrVersions;
1934 bool foundInstalledInOrGroup = false;
1935 for(;;)
1936 {
1937 /* Skip if package is installed already, or is about to be */
75ce2062 1938 string target = Start.TargetPkg().FullName(true) + " ";
29f37db8
MV		 1939
1940 if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install
1941 || Cache[Start.TargetPkg()].Install())
1942 {
1943 foundInstalledInOrGroup=true;
1944 break;
1945 }
1946
1947 /* Skip if we already saw it */
1948 if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
1949 {
1950 foundInstalledInOrGroup=true;
1951 break;
1952 }
1953
1954 // this is a dep on a virtual pkg, check if any package that provides it
1955 // should be installed
1956 if(Start.TargetPkg().ProvidesList() != 0)
1957 {
1958 pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
1959 for (; I.end() == false; I++)
1960 {
1961 pkgCache::PkgIterator Pkg = I.OwnerPkg();
1962 if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
1963 Pkg.CurrentVer() != 0)
1964 foundInstalledInOrGroup=true;
1965 }
1966 }
1967
1968 if (Start->Type == pkgCache::Dep::Suggests)
1969 {
1970 SuggestsOrList += target;
1971 SuggestsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1972 }
1973
1974 if (Start->Type == pkgCache::Dep::Recommends)
1975 {
1976 RecommendsOrList += target;
1977 RecommendsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1978 }
1979
1980 if (Start >= End)
1981 break;
1982 Start++;
1983 }
1984
1985 if(foundInstalledInOrGroup == false)
1986 {
1987 RecommendsList += RecommendsOrList;
1988 RecommendsVersions += RecommendsOrVersions;
1989 SuggestsList += SuggestsOrList;
1990 SuggestsVersions += SuggestsOrVersions;
1991 }
1992
1993 }
a7e41689 1994 }
29f37db8 1995
72122b62
AL		 1996 ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
1997 ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
a7e41689
AL		 1998
1999 }
2000
e4b74e4b
MV		 2001 // if nothing changed in the cache, but only the automark information
2002 // we write the StateFile here, otherwise it will be written in
2003 // cache.commit()
2004 if (AutoMarkChanged > 0 &&
2005 Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
9964a721
MV		 2006 Cache->BadCount() == 0 &&
2007 _config->FindB("APT::Get::Simulate",false) == false)
e4b74e4b
MV		 2008 Cache->writeStateFile(NULL);
2009
03e39e59 2010 // See if we need to prompt
2c3bc8bb 2011 if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0)
2c3bc8bb 2012 return InstallPackages(Cache,false,false);
13e8426f 2013
03e39e59 2014 return InstallPackages(Cache,false);
0a8e3465
AL		 2015}
2016 /*}}}*/
2017// DoDistUpgrade - Automatic smart upgrader /*{{{*/
2018// ---------------------------------------------------------------------
2019/* Intelligent upgrader that will install and remove packages at will */
2020bool DoDistUpgrade(CommandLine &CmdL)
2021{
2022 CacheFile Cache;
c37b9502 2023 if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
0a8e3465
AL		 2024 return false;
2025
db0db9fe 2026 c0out << _("Calculating upgrade... ") << flush;
0a8e3465
AL		 2027 if (pkgDistUpgrade(*Cache) == false)
2028 {
b2e465d6 2029 c0out << _("Failed") << endl;
421c8d10 2030 ShowBroken(c1out,Cache,false);
0a8e3465
AL		 2031 return false;
2032 }
2033
b2e465d6 2034 c0out << _("Done") << endl;
0a8e3465
AL		 2035
2036 return InstallPackages(Cache,true);
2037}
2038 /*}}}*/
2039// DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
2040// ---------------------------------------------------------------------
2041/* Follows dselect's selections */
2042bool DoDSelectUpgrade(CommandLine &CmdL)
2043{
2044 CacheFile Cache;
c37b9502 2045 if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
0a8e3465
AL		 2046 return false;
2047
a4decc40
MV		 2048 pkgDepCache::ActionGroup group(Cache);
2049
0a8e3465
AL		 2050 // Install everything with the install flag set
2051 pkgCache::PkgIterator I = Cache->PkgBegin();
2052 for (;I.end() != true; I++)
2053 {
2054 /* Install the package only if it is a new install, the autoupgrader
2055 will deal with the rest */
2056 if (I->SelectedState == pkgCache::State::Install)
2057 Cache->MarkInstall(I,false);
2058 }
2059
2060 /* Now install their deps too, if we do this above then order of
2061 the status file is significant for | groups */
2062 for (I = Cache->PkgBegin();I.end() != true; I++)
2063 {
2064 /* Install the package only if it is a new install, the autoupgrader
2065 will deal with the rest */
2066 if (I->SelectedState == pkgCache::State::Install)
2f45c76a 2067 Cache->MarkInstall(I,true);
0a8e3465
AL		 2068 }
2069
2070 // Apply erasures now, they override everything else.
2071 for (I = Cache->PkgBegin();I.end() != true; I++)
2072 {
2073 // Remove packages
2074 if (I->SelectedState == pkgCache::State::DeInstall ||
2075 I->SelectedState == pkgCache::State::Purge)
d556d1a1 2076 Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
0a8e3465
AL		 2077 }
2078
2f45c76a
AL		 2079 /* Resolve any problems that dselect created, allupgrade cannot handle
2080 such things. We do so quite agressively too.. */
2081 if (Cache->BrokenCount() != 0)
2082 {
2083 pkgProblemResolver Fix(Cache);
2084
2085 // Hold back held packages.
b2e465d6 2086 if (_config->FindB("APT::Ignore-Hold",false) == false)
2f45c76a
AL		 2087 {
2088 for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
2089 {
2090 if (I->SelectedState == pkgCache::State::Hold)
2091 {
2092 Fix.Protect(I);
2093 Cache->MarkKeep(I);
2094 }
2095 }
2096 }
2097
2098 if (Fix.Resolve() == false)
2099 {
421c8d10 2100 ShowBroken(c1out,Cache,false);
2a7e07c7 2101 return _error->Error(_("Internal error, problem resolver broke stuff"));
2f45c76a
AL		 2102 }
2103 }
2104
2105 // Now upgrade everything
0a8e3465
AL		 2106 if (pkgAllUpgrade(Cache) == false)
2107 {
421c8d10 2108 ShowBroken(c1out,Cache,false);
2a7e07c7 2109 return _error->Error(_("Internal error, problem resolver broke stuff"));
0a8e3465
AL		 2110 }
2111
2112 return InstallPackages(Cache,false);
2113}
2114 /*}}}*/
2115// DoClean - Remove download archives /*{{{*/
2116// ---------------------------------------------------------------------
2117/* */
2118bool DoClean(CommandLine &CmdL)
2119{
8b067c22
AL		 2120 if (_config->FindB("APT::Get::Simulate") == true)
2121 {
2122 cout << "Del " << _config->FindDir("Dir::Cache::archives") << "* " <<
2123 _config->FindDir("Dir::Cache::archives") << "partial/*" << endl;
2124 return true;
2125 }
2126
1b6d659c
AL		 2127 // Lock the archive directory
2128 FileFd Lock;
2129 if (_config->FindB("Debug::NoLocking",false) == false)
2130 {
2131 Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2132 if (_error->PendingError() == true)
b2e465d6 2133 return _error->Error(_("Unable to lock the download directory"));
1b6d659c
AL		 2134 }
2135
7a1b1f8b
AL		 2136 pkgAcquire Fetcher;
2137 Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
2138 Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
0a8e3465
AL		 2139 return true;
2140}
2141 /*}}}*/
1bc849af
AL		 2142// DoAutoClean - Smartly remove downloaded archives /*{{{*/
2143// ---------------------------------------------------------------------
2144/* This is similar to clean but it only purges things that cannot be
2145 downloaded, that is old versions of cached packages. */
65a1e968
AL		 2146class LogCleaner : public pkgArchiveCleaner
2147{
2148 protected:
2149 virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
2150 {
4cc8bab0 2151 c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
c1e78ee5
AL		 2152
2153 if (_config->FindB("APT::Get::Simulate") == false)
2154 unlink(File);
65a1e968
AL		 2155 };
2156};
2157
1bc849af
AL		 2158bool DoAutoClean(CommandLine &CmdL)
2159{
1b6d659c
AL		 2160 // Lock the archive directory
2161 FileFd Lock;
2162 if (_config->FindB("Debug::NoLocking",false) == false)
2163 {
2164 Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2165 if (_error->PendingError() == true)
b2e465d6 2166 return _error->Error(_("Unable to lock the download directory"));
1b6d659c
AL		 2167 }
2168
1bc849af 2169 CacheFile Cache;
2d11135a 2170 if (Cache.Open() == false)
1bc849af
AL		 2171 return false;
2172
65a1e968 2173 LogCleaner Cleaner;
1bc849af
AL		 2174
2175 return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
2176 Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
2177}
2178 /*}}}*/
0a8e3465
AL		 2179// DoCheck - Perform the check operation /*{{{*/
2180// ---------------------------------------------------------------------
2181/* Opening automatically checks the system, this command is mostly used
2182 for debugging */
2183bool DoCheck(CommandLine &CmdL)
2184{
2185 CacheFile Cache;
2186 Cache.Open();
2d11135a 2187 Cache.CheckDeps();
0a8e3465
AL		 2188
2189 return true;
2190}
2191 /*}}}*/
36375005
AL		 2192// DoSource - Fetch a source archive /*{{{*/
2193// ---------------------------------------------------------------------
2d11135a 2194/* Fetch souce packages */
fb0ee66e
AL		 2195struct DscFile
2196{
2197 string Package;
2198 string Version;
2199 string Dsc;
2200};
2201
36375005
AL		 2202bool DoSource(CommandLine &CmdL)
2203{
2204 CacheFile Cache;
2d11135a 2205 if (Cache.Open(false) == false)
36375005
AL		 2206 return false;
2207
2d11135a 2208 if (CmdL.FileSize() <= 1)
b2e465d6 2209 return _error->Error(_("Must specify at least one package to fetch source for"));
2d11135a 2210
36375005
AL		 2211 // Read the source list
2212 pkgSourceList List;
2213 if (List.ReadMainList() == false)
b2e465d6 2214 return _error->Error(_("The list of sources could not be read."));
36375005
AL		 2215
2216 // Create the text record parsers
2217 pkgRecords Recs(Cache);
2218 pkgSrcRecords SrcRecs(List);
2219 if (_error->PendingError() == true)
2220 return false;
2221
2222 // Create the download object
2223 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1cd1c398
DK		 2224 pkgAcquire Fetcher;
2225 if (Fetcher.Setup(&Stat) == false)
2226 return false;
fb0ee66e
AL		 2227
2228 DscFile *Dsc = new DscFile[CmdL.FileSize()];
36375005 2229
092ae175
MV		 2230 // insert all downloaded uris into this set to avoid downloading them
2231 // twice
2232 set<string> queued;
36375005 2233 // Load the requestd sources into the fetcher
fb0ee66e
AL		 2234 unsigned J = 0;
2235 for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
36375005
AL		 2236 {
2237 string Src;
b2e465d6 2238 pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
36375005
AL		 2239
2240 if (Last == 0)
b2e465d6 2241 return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
36375005
AL		 2242
2243 // Back track
2244 vector<pkgSrcRecords::File> Lst;
b2e465d6 2245 if (Last->Files(Lst) == false)
36375005
AL		 2246 return false;
2247
2248 // Load them into the fetcher
2249 for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
2250 I != Lst.end(); I++)
2251 {
2252 // Try to guess what sort of file it is we are getting.
b2e465d6 2253 if (I->Type == "dsc")
fb0ee66e 2254 {
fb0ee66e
AL		 2255 Dsc[J].Package = Last->Package();
2256 Dsc[J].Version = Last->Version();
2257 Dsc[J].Dsc = flNotDir(I->Path);
2258 }
2259
17c0e8e1
AL		 2260 // Diff only mode only fetches .diff files
2261 if (_config->FindB("APT::Get::Diff-Only",false) == true &&
b2e465d6 2262 I->Type != "diff")
17c0e8e1
AL		 2263 continue;
2264
2265 // Tar only mode only fetches .tar files
2266 if (_config->FindB("APT::Get::Tar-Only",false) == true &&
b2e465d6 2267 I->Type != "tar")
17c0e8e1 2268 continue;
092ae175 2269
1979e742
MV		 2270 // Dsc only mode only fetches .dsc files
2271 if (_config->FindB("APT::Get::Dsc-Only",false) == true &&
2272 I->Type != "dsc")
2273 continue;
2274
092ae175
MV		 2275 // don't download the same uri twice (should this be moved to
2276 // the fetcher interface itself?)
2277 if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
2278 continue;
2279 queued.insert(Last->Index().ArchiveURI(I->Path));
2280
2281 // check if we have a file with that md5 sum already localy
2282 if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
2283 {
2284 FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
2285 MD5Summation sum;
2286 sum.AddFD(Fd.Fd(), Fd.Size());
2287 Fd.Close();
2288 if((string)sum.Result() == I->MD5Hash)
2289 {
443cb67c 2290 ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
092ae175
MV		 2291 flNotDir(I->Path).c_str());
2292 continue;
2293 }
2294 }
2295
b2e465d6
AL		 2296 new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
2297 I->MD5Hash,I->Size,
2298 Last->Index().SourceInfo(*Last,*I),Src);
36375005
AL		 2299 }
2300 }
2301
2302 // Display statistics
b2e465d6
AL		 2303 double FetchBytes = Fetcher.FetchNeeded();
2304 double FetchPBytes = Fetcher.PartialPresent();
2305 double DebBytes = Fetcher.TotalNeeded();
36375005
AL		 2306
2307 // Check for enough free space
f332b62b 2308 struct statvfs Buf;
36375005 2309 string OutputDir = ".";
c1ce032a
DK		 2310 if (statvfs(OutputDir.c_str(),&Buf) != 0) {
2311 if (errno == EOVERFLOW)
2312 return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
2313 OutputDir.c_str());
2314 else
2315 return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
2316 OutputDir.c_str());
2317 } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
885d204b
OS		 2318 {
2319 struct statfs Stat;
f64196e8
DK		 2320 if (statfs(OutputDir.c_str(),&Stat) != 0
2321#if HAVE_STRUCT_STATFS_F_TYPE
2322 || unsigned(Stat.f_type) != RAMFS_MAGIC
2323#endif
2324 )
885d204b
OS		 2325 return _error->Error(_("You don't have enough free space in %s"),
2326 OutputDir.c_str());
2327 }
36375005
AL		 2328
2329 // Number of bytes
36375005 2330 if (DebBytes != FetchBytes)
b2e465d6
AL		 2331 ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
2332 SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
36375005 2333 else
b2e465d6
AL		 2334 ioprintf(c1out,_("Need to get %sB of source archives.\n"),
2335 SizeToStr(DebBytes).c_str());
2336
2c0c53b3
AL		 2337 if (_config->FindB("APT::Get::Simulate",false) == true)
2338 {
2339 for (unsigned I = 0; I != J; I++)
db0db9fe 2340 ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
3a4477a4 2341 delete[] Dsc;
2c0c53b3
AL		 2342 return true;
2343 }
2344
36375005
AL		 2345 // Just print out the uris an exit if the --print-uris flag was used
2346 if (_config->FindB("APT::Get::Print-URIs") == true)
2347 {
2348 pkgAcquire::UriIterator I = Fetcher.UriBegin();
2349 for (; I != Fetcher.UriEnd(); I++)
2350 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
495e5cb2 2351 I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
3a4477a4 2352 delete[] Dsc;
36375005
AL		 2353 return true;
2354 }
2355
2356 // Run it
024d1123 2357 if (Fetcher.Run() == pkgAcquire::Failed)
36375005
AL		 2358 return false;
2359
2360 // Print error messages
fb0ee66e 2361 bool Failed = false;
076d01b0 2362 for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
36375005
AL		 2363 {
2364 if ((*I)->Status == pkgAcquire::Item::StatDone &&
2365 (*I)->Complete == true)
2366 continue;
2367
b2e465d6
AL		 2368 fprintf(stderr,_("Failed to fetch %s %s\n"),(*I)->DescURI().c_str(),
2369 (*I)->ErrorText.c_str());
fb0ee66e 2370 Failed = true;
36375005 2371 }
fb0ee66e 2372 if (Failed == true)
b2e465d6 2373 return _error->Error(_("Failed to fetch some archives."));
fb0ee66e
AL		 2374
2375 if (_config->FindB("APT::Get::Download-only",false) == true)
b2e465d6
AL		 2376 {
2377 c1out << _("Download complete and in download only mode") << endl;
3a4477a4 2378 delete[] Dsc;
fb0ee66e 2379 return true;
b2e465d6
AL		 2380 }
2381
fb0ee66e 2382 // Unpack the sources
54676e1a
AL		 2383 pid_t Process = ExecFork();
2384
2385 if (Process == 0)
fb0ee66e 2386 {
54676e1a 2387 for (unsigned I = 0; I != J; I++)
fb0ee66e 2388 {
b2e465d6 2389 string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
fb0ee66e 2390
17c0e8e1
AL		 2391 // Diff only mode only fetches .diff files
2392 if (_config->FindB("APT::Get::Diff-Only",false) == true ||
a3eaf954
AL		 2393 _config->FindB("APT::Get::Tar-Only",false) == true ||
2394 Dsc[I].Dsc.empty() == true)
17c0e8e1 2395 continue;
a3eaf954 2396
54676e1a
AL		 2397 // See if the package is already unpacked
2398 struct stat Stat;
2399 if (stat(Dir.c_str(),&Stat) == 0 &&
2400 S_ISDIR(Stat.st_mode) != 0)
2401 {
b2e465d6
AL		 2402 ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
2403 Dir.c_str());
54676e1a
AL		 2404 }
2405 else
2406 {
2407 // Call dpkg-source
2408 char S[500];
2409 snprintf(S,sizeof(S),"%s -x %s",
2410 _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2411 Dsc[I].Dsc.c_str());
2412 if (system(S) != 0)
2413 {
b2e465d6 2414 fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
14cd494a 2415 fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
54676e1a
AL		 2416 _exit(1);
2417 }
2418 }
2419
2420 // Try to compile it with dpkg-buildpackage
2421 if (_config->FindB("APT::Get::Compile",false) == true)
2422 {
2423 // Call dpkg-buildpackage
2424 char S[500];
2425 snprintf(S,sizeof(S),"cd %s && %s %s",
2426 Dir.c_str(),
2427 _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2428 _config->Find("DPkg::Build-Options","-b -uc").c_str());
2429
2430 if (system(S) != 0)
2431 {
b2e465d6 2432 fprintf(stderr,_("Build command '%s' failed.\n"),S);
54676e1a
AL		 2433 _exit(1);
2434 }
2435 }
2436 }
2437
2438 _exit(0);
2439 }
3a4477a4
DK		 2440 delete[] Dsc;
2441
54676e1a
AL		 2442 // Wait for the subprocess
2443 int Status = 0;
2444 while (waitpid(Process,&Status,0) != Process)
2445 {
2446 if (errno == EINTR)
2447 continue;
2448 return _error->Errno("waitpid","Couldn't wait for subprocess");
2449 }
2450
2451 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
b2e465d6
AL		 2452 return _error->Error(_("Child process failed"));
2453
2454 return true;
2455}
2456 /*}}}*/
2457// DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/
2458// ---------------------------------------------------------------------
2459/* This function will look at the build depends list of the given source
2460 package and install the necessary packages to make it true, or fail. */
2461bool DoBuildDep(CommandLine &CmdL)
2462{
2463 CacheFile Cache;
2464 if (Cache.Open(true) == false)
2465 return false;
2466
2467 if (CmdL.FileSize() <= 1)
2468 return _error->Error(_("Must specify at least one package to check builddeps for"));
2469
2470 // Read the source list
2471 pkgSourceList List;
2472 if (List.ReadMainList() == false)
2473 return _error->Error(_("The list of sources could not be read."));
54676e1a 2474
b2e465d6
AL		 2475 // Create the text record parsers
2476 pkgRecords Recs(Cache);
2477 pkgSrcRecords SrcRecs(List);
2478 if (_error->PendingError() == true)
2479 return false;
2480
2481 // Create the download object
2482 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1cd1c398
DK		 2483 pkgAcquire Fetcher;
2484 if (Fetcher.Setup(&Stat) == false)
2485 return false;
b2e465d6
AL		 2486
2487 unsigned J = 0;
2488 for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2489 {
2490 string Src;
2491 pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2492 if (Last == 0)
2493 return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2494
2495 // Process the build-dependencies
2496 vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
af3f8112 2497 if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only",true)) == false)
b2e465d6
AL		 2498 return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
2499
7d6f9f8f
AL		 2500 // Also ensure that build-essential packages are present
2501 Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
2502 if (Opts)
2503 Opts = Opts->Child;
2504 for (; Opts; Opts = Opts->Next)
2505 {
2506 if (Opts->Value.empty() == true)
2507 continue;
2508
2509 pkgSrcRecords::Parser::BuildDepRec rec;
2510 rec.Package = Opts->Value;
2511 rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
2512 rec.Op = 0;
58d76831 2513 BuildDeps.push_back(rec);
7d6f9f8f
AL		 2514 }
2515
b2e465d6
AL		 2516 if (BuildDeps.size() == 0)
2517 {
2518 ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
2519 continue;
2520 }
2521
2522 // Install the requested packages
2523 unsigned int ExpectedInst = 0;
2524 vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
2525 pkgProblemResolver Fix(Cache);
58d76831 2526 bool skipAlternatives = false; // skip remaining alternatives in an or group
b2e465d6
AL		 2527 for (D = BuildDeps.begin(); D != BuildDeps.end(); D++)
2528 {
58d76831
AL		 2529 bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
2530
2531 if (skipAlternatives == true)
2532 {
2533 if (!hasAlternatives)
2534 skipAlternatives = false; // end of or group
2535 continue;
2536 }
2537
aa2d22be
AL		 2538 if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
2539 (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
d3fc0061 2540 {
aa2d22be
AL		 2541 pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2542 // Build-conflicts on unknown packages are silently ignored
2543 if (Pkg.end() == true)
2544 continue;
2545
2546 pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2547
2548 /*
2549 * Remove if we have an installed version that satisfies the
2550 * version criteria
2551 */
2552 if (IV.end() == false &&
2553 Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2554 TryToInstall(Pkg,Cache,Fix,true,false,ExpectedInst);
d3fc0061 2555 }
aa2d22be
AL		 2556 else // BuildDep || BuildDepIndep
2557 {
2558 pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
58d76831
AL		 2559 if (_config->FindB("Debug::BuildDeps",false) == true)
2560 cout << "Looking for " << (*D).Package << "...\n";
2561
aa2d22be
AL		 2562 if (Pkg.end() == true)
2563 {
58d76831
AL		 2564 if (_config->FindB("Debug::BuildDeps",false) == true)
2565 cout << " (not found)" << (*D).Package << endl;
2566
2567 if (hasAlternatives)
2568 continue;
2569
2570 return _error->Error(_("%s dependency for %s cannot be satisfied "
2571 "because the package %s cannot be found"),
2572 Last->BuildDepType((*D).Type),Src.c_str(),
2573 (*D).Package.c_str());
aa2d22be
AL		 2574 }
2575
2576 /*
2577 * if there are alternatives, we've already picked one, so skip
2578 * the rest
2579 *
2580 * TODO: this means that if there's a build-dep on A|B and B is
2581 * installed, we'll still try to install A; more importantly,
2582 * if A is currently broken, we cannot go back and try B. To fix
2583 * this would require we do a Resolve cycle for each package we
2584 * add to the install list. Ugh
2585 */
aa2d22be 2586
cfa5659c
AL		 2587 /*
2588 * If this is a virtual package, we need to check the list of
2589 * packages that provide it and see if any of those are
2590 * installed
2591 */
2592 pkgCache::PrvIterator Prv = Pkg.ProvidesList();
a8a0fdcf
AL		 2593 for (; Prv.end() != true; Prv++)
2594 {
58d76831 2595 if (_config->FindB("Debug::BuildDeps",false) == true)
75ce2062 2596 cout << " Checking provider " << Prv.OwnerPkg().FullName() << endl;
58d76831 2597
cfa5659c
AL		 2598 if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
2599 break;
cb99271c 2600 }
e5002e30
AL		 2601
2602 // Get installed version and version we are going to install
2603 pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
e5002e30 2604
58d76831
AL		 2605 if ((*D).Version[0] != '\0') {
2606 // Versioned dependency
cb99271c
AL		 2607
2608 pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
2609
2610 for (; CV.end() != true; CV++)
2611 {
2612 if (Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2613 break;
2614 }
2615 if (CV.end() == true)
085bedac 2616 {
34e88622
AL		 2617 if (hasAlternatives)
2618 {
2619 continue;
2620 }
2621 else
2622 {
cb99271c
AL		 2623 return _error->Error(_("%s dependency for %s cannot be satisfied "
2624 "because no available versions of package %s "
2625 "can satisfy version requirements"),
2626 Last->BuildDepType((*D).Type),Src.c_str(),
2627 (*D).Package.c_str());
34e88622 2628 }
085bedac 2629 }
e5002e30 2630 }
58d76831
AL		 2631 else
2632 {
2633 // Only consider virtual packages if there is no versioned dependency
2634 if (Prv.end() == false)
2635 {
2636 if (_config->FindB("Debug::BuildDeps",false) == true)
75ce2062 2637 cout << " Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
58d76831
AL		 2638 skipAlternatives = hasAlternatives;
2639 continue;
2640 }
2641 }
cfa5659c 2642
58d76831
AL		 2643 if (IV.end() == false)
2644 {
2645 if (_config->FindB("Debug::BuildDeps",false) == true)
2646 cout << " Is installed\n";
2647
2648 if (Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2649 {
2650 skipAlternatives = hasAlternatives;
2651 continue;
2652 }
2653
2654 if (_config->FindB("Debug::BuildDeps",false) == true)
2655 cout << " ...but the installed version doesn't meet the version requirement\n";
2656
2657 if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
2658 {
2659 return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2660 Last->BuildDepType((*D).Type),
2661 Src.c_str(),
75ce2062 2662 Pkg.FullName(true).c_str());
58d76831
AL		 2663 }
2664 }
2665
2666
2667 if (_config->FindB("Debug::BuildDeps",false) == true)
2668 cout << " Trying to install " << (*D).Package << endl;
2669
2670 if (TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst) == true)
2671 {
2672 // We successfully installed something; skip remaining alternatives
2673 skipAlternatives = hasAlternatives;
d59228b0 2674 if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
496a05c6 2675 Cache->MarkAuto(Pkg, true);
58d76831
AL		 2676 continue;
2677 }
2678 else if (hasAlternatives)
2679 {
2680 if (_config->FindB("Debug::BuildDeps",false) == true)
2681 cout << " Unsatisfiable, trying alternatives\n";
2682 continue;
2683 }
2684 else
2685 {
2686 return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
2687 Last->BuildDepType((*D).Type),
2688 Src.c_str(),
2689 (*D).Package.c_str());
2690 }
b2e465d6
AL		 2691 }
2692 }
2693
2694 Fix.InstallProtect();
2695 if (Fix.Resolve(true) == false)
2696 _error->Discard();
2697
2698 // Now we check the state of the packages,
2699 if (Cache->BrokenCount() != 0)
0dae8ac5
DK		 2700 {
2701 ShowBroken(cout, Cache, false);
2702 return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
2703 }
b2e465d6
AL		 2704 }
2705
2706 if (InstallPackages(Cache, false, true) == false)
2707 return _error->Error(_("Failed to process build dependencies"));
36375005
AL		 2708 return true;
2709}
2710 /*}}}*/
b2e465d6
AL		 2711// DoMoo - Never Ask, Never Tell /*{{{*/
2712// ---------------------------------------------------------------------
2713/* */
2714bool DoMoo(CommandLine &CmdL)
2715{
2716 cout <<
2717 " (__) \n"
2718 " (oo) \n"
2719 " /------\\/ \n"
2720 " / | || \n"
2721 " * /\\---/\\ \n"
2722 " ~~ ~~ \n"
2723 "....\"Have you mooed today?\"...\n";
2724
2725 return true;
2726}
2727 /*}}}*/
0a8e3465
AL		 2728// ShowHelp - Show a help screen /*{{{*/
2729// ---------------------------------------------------------------------
2730/* */
212ad54a 2731bool ShowHelp(CommandLine &CmdL)
0a8e3465 2732{
5b28c804
OS		 2733 ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
2734 COMMON_ARCH,__DATE__,__TIME__);
b2e465d6 2735
04aa15a8 2736 if (_config->FindB("version") == true)
b2e465d6 2737 {
db0db9fe 2738 cout << _("Supported modules:") << endl;
b2e465d6
AL		 2739
2740 for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
2741 {
2742 pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
2743 if (_system != 0 && _system->VS == VS)
2744 cout << '*';
2745 else
2746 cout << ' ';
2747 cout << "Ver: " << VS->Label << endl;
2748
2749 /* Print out all the packaging systems that will work with
2750 this VS */
2751 for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
2752 {
2753 pkgSystem *Sys = pkgSystem::GlobalList[J];
2754 if (_system == Sys)
2755 cout << '*';
2756 else
2757 cout << ' ';
2758 if (Sys->VS->TestCompatibility(*VS) == true)
2759 cout << "Pkg: " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
2760 }
2761 }
2762
2763 for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
2764 {
2765 pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
2766 cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
2767 }
2768
2769 for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
2770 {
2771 pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
2772 cout << " Idx: " << Type->Label << endl;
2773 }
2774
2775 return true;
2776 }
2777
2778 cout <<
2779 _("Usage: apt-get [options] command\n"
2780 " apt-get [options] install|remove pkg1 [pkg2 ...]\n"
2781 " apt-get [options] source pkg1 [pkg2 ...]\n"
2782 "\n"
2783 "apt-get is a simple command line interface for downloading and\n"
2784 "installing packages. The most frequently used commands are update\n"
2785 "and install.\n"
2786 "\n"
2787 "Commands:\n"
2788 " update - Retrieve new lists of packages\n"
2789 " upgrade - Perform an upgrade\n"
2790 " install - Install new packages (pkg is libc6 not libc6.deb)\n"
2791 " remove - Remove packages\n"
12bffed7 2792 " autoremove - Remove automatically all unused packages\n"
73fc19d0 2793 " purge - Remove packages and config files\n"
b2e465d6
AL		 2794 " source - Download source archives\n"
2795 " build-dep - Configure build-dependencies for source packages\n"
2796 " dist-upgrade - Distribution upgrade, see apt-get(8)\n"
2797 " dselect-upgrade - Follow dselect selections\n"
2798 " clean - Erase downloaded archive files\n"
2799 " autoclean - Erase old downloaded archive files\n"
2800 " check - Verify that there are no broken dependencies\n"
2801 "\n"
2802 "Options:\n"
2803 " -h This help text.\n"
2804 " -q Loggable output - no progress indicator\n"
2805 " -qq No output except for errors\n"
2806 " -d Download only - do NOT install or unpack archives\n"
2807 " -s No-act. Perform ordering simulation\n"
2808 " -y Assume Yes to all queries and do not prompt\n"
0748d509 2809 " -f Attempt to correct a system with broken dependencies in place\n"
b2e465d6
AL		 2810 " -m Attempt to continue if archives are unlocatable\n"
2811 " -u Show a list of upgraded packages as well\n"
2812 " -b Build the source package after fetching it\n"
ac625538 2813 " -V Show verbose version numbers\n"
b2e465d6 2814 " -c=? Read this configuration file\n"
a2884e32 2815 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
b2e465d6
AL		 2816 "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
2817 "pages for more information and options.\n"
2818 " This APT has Super Cow Powers.\n");
2819 return true;
0a8e3465
AL		 2820}
2821 /*}}}*/
2822// GetInitialize - Initialize things for apt-get /*{{{*/
2823// ---------------------------------------------------------------------
2824/* */
2825void GetInitialize()
2826{
2827 _config->Set("quiet",0);
2828 _config->Set("help",false);
2829 _config->Set("APT::Get::Download-Only",false);
2830 _config->Set("APT::Get::Simulate",false);
2831 _config->Set("APT::Get::Assume-Yes",false);
2832 _config->Set("APT::Get::Fix-Broken",false);
83d89a9f 2833 _config->Set("APT::Get::Force-Yes",false);
640c5d94 2834 _config->Set("APT::Get::List-Cleanup",true);
afb1e2e3 2835 _config->Set("APT::Get::AutomaticRemove",false);
0a8e3465
AL		 2836}
2837 /*}}}*/
d7827aca
AL		 2838// SigWinch - Window size change signal handler /*{{{*/
2839// ---------------------------------------------------------------------
2840/* */
2841void SigWinch(int)
2842{
2843 // Riped from GNU ls
2844#ifdef TIOCGWINSZ
2845 struct winsize ws;
2846
2847 if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
2848 ScreenWidth = ws.ws_col - 1;
2849#endif
2850}
2851 /*}}}*/
92fcbfc1 2852int main(int argc,const char *argv[]) /*{{{*/
0a8e3465
AL		 2853{
2854 CommandLine::Args Args[] = {
2855 {'h',"help","help",0},
04aa15a8 2856 {'v',"version","version",0},
ac625538 2857 {'V',"verbose-versions","APT::Get::Show-Versions",0},
0a8e3465
AL		 2858 {'q',"quiet","quiet",CommandLine::IntLevel},
2859 {'q',"silent","quiet",CommandLine::IntLevel},
2860 {'d',"download-only","APT::Get::Download-Only",0},
fb0ee66e
AL		 2861 {'b',"compile","APT::Get::Compile",0},
2862 {'b',"build","APT::Get::Compile",0},
d150b09d
AL		 2863 {'s',"simulate","APT::Get::Simulate",0},
2864 {'s',"just-print","APT::Get::Simulate",0},
2865 {'s',"recon","APT::Get::Simulate",0},
6df23d2f 2866 {'s',"dry-run","APT::Get::Simulate",0},
d150b09d
AL		 2867 {'s',"no-act","APT::Get::Simulate",0},
2868 {'y',"yes","APT::Get::Assume-Yes",0},
0a8e3465
AL		 2869 {'y',"assume-yes","APT::Get::Assume-Yes",0},
2870 {'f',"fix-broken","APT::Get::Fix-Broken",0},
2871 {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
30e1eab5 2872 {'m',"ignore-missing","APT::Get::Fix-Missing",0},
b2e465d6
AL		 2873 {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
2874 {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
2875 {0,"download","APT::Get::Download",0},
30e1eab5 2876 {0,"fix-missing","APT::Get::Fix-Missing",0},
b2e465d6
AL		 2877 {0,"ignore-hold","APT::Ignore-Hold",0},
2878 {0,"upgrade","APT::Get::upgrade",0},
6cd9fbd7 2879 {0,"only-upgrade","APT::Get::Only-Upgrade",0},
83d89a9f 2880 {0,"force-yes","APT::Get::force-yes",0},
f7a08e33 2881 {0,"print-uris","APT::Get::Print-URIs",0},
5fafc0ef 2882 {0,"diff-only","APT::Get::Diff-Only",0},
a0895a74 2883 {0,"debian-only","APT::Get::Diff-Only",0},
1979e742
MV		 2884 {0,"tar-only","APT::Get::Tar-Only",0},
2885 {0,"dsc-only","APT::Get::Dsc-Only",0},
fc4b5c9f 2886 {0,"purge","APT::Get::Purge",0},
9df71a5b 2887 {0,"list-cleanup","APT::Get::List-Cleanup",0},
d0c59649 2888 {0,"reinstall","APT::Get::ReInstall",0},
d150b09d 2889 {0,"trivial-only","APT::Get::Trivial-Only",0},
b2e465d6
AL		 2890 {0,"remove","APT::Get::Remove",0},
2891 {0,"only-source","APT::Get::Only-Source",0},
45430cbf 2892 {0,"arch-only","APT::Get::Arch-Only",0},
f8ac1720 2893 {0,"auto-remove","APT::Get::AutomaticRemove",0},
7db98ffc 2894 {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
e9ae3677 2895 {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean},
4ef9a929 2896 {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
0a8e3465
AL		 2897 {'c',"config-file",0,CommandLine::ConfigFile},
2898 {'o',"option",0,CommandLine::ArbItem},
2899 {0,0,0,0}};
83d89a9f
AL		 2900 CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
2901 {"upgrade",&DoUpgrade},
2902 {"install",&DoInstall},
2903 {"remove",&DoInstall},
24401c09 2904 {"purge",&DoInstall},
74a05226 2905 {"autoremove",&DoInstall},
9efa2e91 2906 {"purge",&DoInstall},
83d89a9f
AL		 2907 {"dist-upgrade",&DoDistUpgrade},
2908 {"dselect-upgrade",&DoDSelectUpgrade},
b2e465d6 2909 {"build-dep",&DoBuildDep},
83d89a9f 2910 {"clean",&DoClean},
1bc849af 2911 {"autoclean",&DoAutoClean},
83d89a9f 2912 {"check",&DoCheck},
67111687 2913 {"source",&DoSource},
b2e465d6 2914 {"moo",&DoMoo},
67111687 2915 {"help",&ShowHelp},
83d89a9f 2916 {0,0}};
67111687
AL		 2917
2918 // Set up gettext support
2919 setlocale(LC_ALL,"");
2920 textdomain(PACKAGE);
2921
0a8e3465
AL		 2922 // Parse the command line and initialize the package library
2923 CommandLine CmdL(Args,_config);
b2e465d6
AL		 2924 if (pkgInitConfig(*_config) == false ||
2925 CmdL.Parse(argc,argv) == false ||
2926 pkgInitSystem(*_config,_system) == false)
0a8e3465 2927 {
b2e465d6
AL		 2928 if (_config->FindB("version") == true)
2929 ShowHelp(CmdL);
2930
0a8e3465
AL		 2931 _error->DumpErrors();
2932 return 100;
2933 }
2934
2935 // See if the help should be shown
2936 if (_config->FindB("help") == true ||
04aa15a8 2937 _config->FindB("version") == true ||
0a8e3465 2938 CmdL.FileSize() == 0)
b2e465d6
AL		 2939 {
2940 ShowHelp(CmdL);
2941 return 0;
2942 }
55a5a46c
MV		 2943
2944 // simulate user-friendly if apt-get has no root privileges
2945 if (getuid() != 0 && _config->FindB("APT::Get::Simulate") == true)
2946 {
ecf59bfc
DK		 2947 if (_config->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
2948 cout << _("NOTE: This is only a simulation!\n"
2949 " apt-get needs root privileges for real execution.\n"
2950 " Keep also in mind that locking is deactivated,\n"
2951 " so don't depend on the relevance to the real current situation!"
2952 ) << std::endl;
55a5a46c
MV		 2953 _config->Set("Debug::NoLocking",true);
2954 }
2955
a9a5908d 2956 // Deal with stdout not being a tty
00581c6b 2957 if (!isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
a9a5908d 2958 _config->Set("quiet","1");
01b64152 2959
0a8e3465
AL		 2960 // Setup the output streams
2961 c0out.rdbuf(cout.rdbuf());
2962 c1out.rdbuf(cout.rdbuf());
2963 c2out.rdbuf(cout.rdbuf());
2964 if (_config->FindI("quiet",0) > 0)
2965 c0out.rdbuf(devnull.rdbuf());
2966 if (_config->FindI("quiet",0) > 1)
2967 c1out.rdbuf(devnull.rdbuf());
d7827aca
AL		 2968
2969 // Setup the signals
2970 signal(SIGPIPE,SIG_IGN);
2971 signal(SIGWINCH,SigWinch);
2972 SigWinch(0);
b2e465d6 2973
0a8e3465 2974 // Match the operation
83d89a9f 2975 CmdL.DispatchArg(Cmds);
0a8e3465
AL		 2976
2977 // Print any errors or warnings found during parsing
2978 if (_error->empty() == false)
2979 {
2980 bool Errors = _error->PendingError();
2981 _error->DumpErrors();
0a8e3465
AL		 2982 return Errors == true?100:0;
2983 }
2984
2985 return 0;
2986}
92fcbfc1 2987 /*}}}*/
ntk's bugfix for apt