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