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