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