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