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