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