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