]> git.saurik.com Git - apt.git/blob - cmdline/apt-get.cc
projects / apt.git / blob
? search:


75424926d338294247be1a2b5943673d8eae35c5
[apt.git] / cmdline / apt-get.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: apt-get.cc,v 1.70 1999/07/10 05:32:26 jgg 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/dpkgpm.h>
36 #include <apt-pkg/strutl.h>
37 #include <apt-pkg/clean.h>
38 #include <apt-pkg/srcrecords.h>
39 #include <apt-pkg/version.h>
40 #include <apt-pkg/cachefile.h>
41
42 #include <config.h>
43
44 #include "acqprogress.h"
45
46 #include <fstream.h>
47 #include <termios.h>
48 #include <sys/ioctl.h>
49 #include <sys/stat.h>
50 #include <sys/vfs.h>
51 #include <signal.h>
52 #include <unistd.h>
53 #include <stdio.h>
54 #include <errno.h>
55 #include <sys/wait.h>
56 /*}}}*/
57
58 ostream c0out;
59 ostream c1out;
60 ostream c2out;
61 ofstream devnull("/dev/null");
62 unsigned int ScreenWidth = 80;
63
64 // YnPrompt - Yes No Prompt. /*{{{*/
65 // ---------------------------------------------------------------------
66 /* Returns true on a Yes.*/
67 bool YnPrompt()
68 {
69 if (_config->FindB("APT::Get::Assume-Yes",false) == true)
70 {
71 c1out << 'Y' << endl;
72 return true;
73 }
74
75 char C = 0;
76 char Jnk = 0;
77 read(STDIN_FILENO,&C,1);
78 while (C != '\n' && Jnk != '\n') read(STDIN_FILENO,&Jnk,1);
79
80 if (!(C == 'Y' || C == 'y' || C == '\n' || C == '\r'))
81 return false;
82 return true;
83 }
84 /*}}}*/
85 // AnalPrompt - Annoying Yes No Prompt. /*{{{*/
86 // ---------------------------------------------------------------------
87 /* Returns true on a Yes.*/
88 bool AnalPrompt(const char *Text)
89 {
90 char Buf[1024];
91 cin.getline(Buf,sizeof(Buf));
92 if (strcmp(Buf,Text) == 0)
93 return true;
94 return false;
95 }
96 /*}}}*/
97 // ShowList - Show a list /*{{{*/
98 // ---------------------------------------------------------------------
99 /* This prints out a string of space seperated words with a title and
100 a two space indent line wraped to the current screen width. */
101 bool ShowList(ostream &out,string Title,string List)
102 {
103 if (List.empty() == true)
104 return true;
105
106 // Acount for the leading space
107 int ScreenWidth = ::ScreenWidth - 3;
108
109 out << Title << endl;
110 string::size_type Start = 0;
111 while (Start < List.size())
112 {
113 string::size_type End;
114 if (Start + ScreenWidth >= List.size())
115 End = List.size();
116 else
117 End = List.rfind(' ',Start+ScreenWidth);
118
119 if (End == string::npos || End < Start)
120 End = Start + ScreenWidth;
121 out << " " << string(List,Start,End - Start) << endl;
122 Start = End + 1;
123 }
124 return false;
125 }
126 /*}}}*/
127 // ShowBroken - Debugging aide /*{{{*/
128 // ---------------------------------------------------------------------
129 /* This prints out the names of all the packages that are broken along
130 with the name of each each broken dependency and a quite version
131 description. */
132 void ShowBroken(ostream &out,pkgDepCache &Cache)
133 {
134 out << "Sorry, but the following packages have unmet dependencies:" << endl;
135 pkgCache::PkgIterator I = Cache.PkgBegin();
136 for (;I.end() != true; I++)
137 {
138 if (Cache[I].InstBroken() == false)
139 continue;
140
141 // Print out each package and the failed dependencies
142 out <<" " << I.Name() << ":";
143 int Indent = strlen(I.Name()) + 3;
144 bool First = true;
145 if (Cache[I].InstVerIter(Cache).end() == true)
146 {
147 cout << endl;
148 continue;
149 }
150
151 for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false;)
152 {
153 // Compute a single dependency element (glob or)
154 pkgCache::DepIterator Start;
155 pkgCache::DepIterator End;
156 D.GlobOr(Start,End);
157
158 if (Cache.IsImportantDep(End) == false ||
159 (Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall)
160 continue;
161
162 if (First == false)
163 for (int J = 0; J != Indent; J++)
164 out << ' ';
165 First = false;
166
167 out << ' ' << End.DepType() << ": " << End.TargetPkg().Name();
168
169 // Show a quick summary of the version requirements
170 if (End.TargetVer() != 0)
171 out << " (" << End.CompType() << " " << End.TargetVer() <<
172 ")";
173
174 /* Show a summary of the target package if possible. In the case
175 of virtual packages we show nothing */
176
177 pkgCache::PkgIterator Targ = End.TargetPkg();
178 if (Targ->ProvidesList == 0)
179 {
180 out << " but ";
181 pkgCache::VerIterator Ver = Cache[Targ].InstVerIter(Cache);
182 if (Ver.end() == false)
183 out << Ver.VerStr() << " is installed";
184 else
185 {
186 if (Cache[Targ].CandidateVerIter(Cache).end() == true)
187 {
188 if (Targ->ProvidesList == 0)
189 out << "it is not installable";
190 else
191 out << "it is a virtual package";
192 }
193 else
194 out << "it is not installed";
195 }
196 }
197
198 out << endl;
199 }
200 }
201 }
202 /*}}}*/
203 // ShowNew - Show packages to newly install /*{{{*/
204 // ---------------------------------------------------------------------
205 /* */
206 void ShowNew(ostream &out,pkgDepCache &Dep)
207 {
208 /* Print out a list of packages that are going to be removed extra
209 to what the user asked */
210 pkgCache::PkgIterator I = Dep.PkgBegin();
211 string List;
212 for (;I.end() != true; I++)
213 if (Dep[I].NewInstall() == true)
214 List += string(I.Name()) + " ";
215 ShowList(out,"The following NEW packages will be installed:",List);
216 }
217 /*}}}*/
218 // ShowDel - Show packages to delete /*{{{*/
219 // ---------------------------------------------------------------------
220 /* */
221 void ShowDel(ostream &out,pkgDepCache &Dep)
222 {
223 /* Print out a list of packages that are going to be removed extra
224 to what the user asked */
225 pkgCache::PkgIterator I = Dep.PkgBegin();
226 string List;
227 for (;I.end() != true; I++)
228 {
229 if (Dep[I].Delete() == true)
230 {
231 if ((Dep[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
232 List += string(I.Name()) + "* ";
233 else
234 List += string(I.Name()) + " ";
235 }
236 }
237
238 ShowList(out,"The following packages will be REMOVED:",List);
239 }
240 /*}}}*/
241 // ShowKept - Show kept packages /*{{{*/
242 // ---------------------------------------------------------------------
243 /* */
244 void ShowKept(ostream &out,pkgDepCache &Dep)
245 {
246 pkgCache::PkgIterator I = Dep.PkgBegin();
247 string List;
248 for (;I.end() != true; I++)
249 {
250 // Not interesting
251 if (Dep[I].Upgrade() == true || Dep[I].Upgradable() == false ||
252 I->CurrentVer == 0 || Dep[I].Delete() == true)
253 continue;
254
255 List += string(I.Name()) + " ";
256 }
257 ShowList(out,"The following packages have been kept back",List);
258 }
259 /*}}}*/
260 // ShowUpgraded - Show upgraded packages /*{{{*/
261 // ---------------------------------------------------------------------
262 /* */
263 void ShowUpgraded(ostream &out,pkgDepCache &Dep)
264 {
265 pkgCache::PkgIterator I = Dep.PkgBegin();
266 string List;
267 for (;I.end() != true; I++)
268 {
269 // Not interesting
270 if (Dep[I].Upgrade() == false || Dep[I].NewInstall() == true)
271 continue;
272
273 List += string(I.Name()) + " ";
274 }
275 ShowList(out,"The following packages will be upgraded",List);
276 }
277 /*}}}*/
278 // ShowHold - Show held but changed packages /*{{{*/
279 // ---------------------------------------------------------------------
280 /* */
281 bool ShowHold(ostream &out,pkgDepCache &Dep)
282 {
283 pkgCache::PkgIterator I = Dep.PkgBegin();
284 string List;
285 for (;I.end() != true; I++)
286 {
287 if (Dep[I].InstallVer != (pkgCache::Version *)I.CurrentVer() &&
288 I->SelectedState == pkgCache::State::Hold)
289 List += string(I.Name()) + " ";
290 }
291
292 return ShowList(out,"The following held packages will be changed:",List);
293 }
294 /*}}}*/
295 // ShowEssential - Show an essential package warning /*{{{*/
296 // ---------------------------------------------------------------------
297 /* This prints out a warning message that is not to be ignored. It shows
298 all essential packages and their dependents that are to be removed.
299 It is insanely risky to remove the dependents of an essential package! */
300 bool ShowEssential(ostream &out,pkgDepCache &Dep)
301 {
302 pkgCache::PkgIterator I = Dep.PkgBegin();
303 string List;
304 bool *Added = new bool[Dep.HeaderP->PackageCount];
305 for (unsigned int I = 0; I != Dep.HeaderP->PackageCount; I++)
306 Added[I] = false;
307
308 for (;I.end() != true; I++)
309 {
310 if ((I->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential)
311 continue;
312
313 // The essential package is being removed
314 if (Dep[I].Delete() == true)
315 {
316 if (Added[I->ID] == false)
317 {
318 Added[I->ID] = true;
319 List += string(I.Name()) + " ";
320 }
321 }
322
323 if (I->CurrentVer == 0)
324 continue;
325
326 // Print out any essential package depenendents that are to be removed
327 for (pkgDepCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; D++)
328 {
329 // Skip everything but depends
330 if (D->Type != pkgCache::Dep::PreDepends &&
331 D->Type != pkgCache::Dep::Depends)
332 continue;
333
334 pkgCache::PkgIterator P = D.SmartTargetPkg();
335 if (Dep[P].Delete() == true)
336 {
337 if (Added[P->ID] == true)
338 continue;
339 Added[P->ID] = true;
340
341 char S[300];
342 sprintf(S,"%s (due to %s) ",P.Name(),I.Name());
343 List += S;
344 }
345 }
346 }
347
348 delete [] Added;
349 if (List.empty() == false)
350 out << "WARNING: The following essential packages will be removed" << endl;
351 return ShowList(out,"This should NOT be done unless you know exactly what you are doing!",List);
352 }
353 /*}}}*/
354 // Stats - Show some statistics /*{{{*/
355 // ---------------------------------------------------------------------
356 /* */
357 void Stats(ostream &out,pkgDepCache &Dep)
358 {
359 unsigned long Upgrade = 0;
360 unsigned long Install = 0;
361 for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; I++)
362 {
363 if (Dep[I].NewInstall() == true)
364 Install++;
365 else
366 if (Dep[I].Upgrade() == true)
367 Upgrade++;
368 }
369
370 out << Upgrade << " packages upgraded, " <<
371 Install << " newly installed, " <<
372 Dep.DelCount() << " to remove and " <<
373 Dep.KeepCount() << " not upgraded." << endl;
374
375 if (Dep.BadCount() != 0)
376 out << Dep.BadCount() << " packages not fully installed or removed." << endl;
377 }
378 /*}}}*/
379
380 // class CacheFile - Cover class for some dependency cache functions /*{{{*/
381 // ---------------------------------------------------------------------
382 /* */
383 class CacheFile : public pkgCacheFile
384 {
385 public:
386
387 bool CheckDeps(bool AllowBroken = false);
388 bool Open(bool WithLock = true)
389 {
390 OpTextProgress Prog(*_config);
391 return pkgCacheFile::Open(Prog,WithLock);
392 };
393 };
394 /*}}}*/
395 // CacheFile::Open - Open the cache file /*{{{*/
396 // ---------------------------------------------------------------------
397 /* This routine generates the caches and then opens the dependency cache
398 and verifies that the system is OK. */
399 bool CacheFile::CheckDeps(bool AllowBroken)
400 {
401 if (_error->PendingError() == true)
402 return false;
403
404 // Check that the system is OK
405 if (Cache->DelCount() != 0 || Cache->InstCount() != 0)
406 return _error->Error("Internal Error, non-zero counts");
407
408 // Apply corrections for half-installed packages
409 if (pkgApplyStatus(*Cache) == false)
410 return false;
411
412 // Nothing is broken
413 if (Cache->BrokenCount() == 0 || AllowBroken == true)
414 return true;
415
416 // Attempt to fix broken things
417 if (_config->FindB("APT::Get::Fix-Broken",false) == true)
418 {
419 c1out << "Correcting dependencies..." << flush;
420 if (pkgFixBroken(*Cache) == false || Cache->BrokenCount() != 0)
421 {
422 c1out << " failed." << endl;
423 ShowBroken(c1out,*this);
424
425 return _error->Error("Unable to correct dependencies");
426 }
427 if (pkgMinimizeUpgrade(*Cache) == false)
428 return _error->Error("Unable to minimize the upgrade set");
429
430 c1out << " Done" << endl;
431 }
432 else
433 {
434 c1out << "You might want to run `apt-get -f install' to correct these." << endl;
435 ShowBroken(c1out,*this);
436
437 return _error->Error("Unmet dependencies. Try using -f.");
438 }
439
440 return true;
441 }
442 /*}}}*/
443
444 // InstallPackages - Actually download and install the packages /*{{{*/
445 // ---------------------------------------------------------------------
446 /* This displays the informative messages describing what is going to
447 happen and then calls the download routines */
448 bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,bool Saftey = true)
449 {
450 if (_config->FindB("APT::Get::Purge",false) == true)
451 {
452 pkgCache::PkgIterator I = Cache->PkgBegin();
453 for (; I.end() == false; I++)
454 {
455 if (I.Purge() == false && Cache[I].Mode == pkgDepCache::ModeDelete)
456 Cache->MarkDelete(I,true);
457 }
458 }
459
460 bool Fail = false;
461 bool Essential = false;
462
463 // Show all the various warning indicators
464 ShowDel(c1out,Cache);
465 ShowNew(c1out,Cache);
466 if (ShwKept == true)
467 ShowKept(c1out,Cache);
468 Fail |= !ShowHold(c1out,Cache);
469 if (_config->FindB("APT::Get::Show-Upgraded",false) == true)
470 ShowUpgraded(c1out,Cache);
471 Essential = !ShowEssential(c1out,Cache);
472 Fail |= Essential;
473 Stats(c1out,Cache);
474
475 // Sanity check
476 if (Cache->BrokenCount() != 0)
477 {
478 ShowBroken(c1out,Cache);
479 return _error->Error("Internal Error, InstallPackages was called with broken packages!");
480 }
481
482 if (Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
483 Cache->BadCount() == 0)
484 return true;
485
486 // Run the simulator ..
487 if (_config->FindB("APT::Get::Simulate") == true)
488 {
489 pkgSimulate PM(Cache);
490 pkgPackageManager::OrderResult Res = PM.DoInstall();
491 if (Res == pkgPackageManager::Failed)
492 return false;
493 if (Res != pkgPackageManager::Completed)
494 return _error->Error("Internal Error, Ordering didn't finish");
495 return true;
496 }
497
498 // Create the text record parser
499 pkgRecords Recs(Cache);
500 if (_error->PendingError() == true)
501 return false;
502
503 // Lock the archive directory
504 FileFd Lock;
505 if (_config->FindB("Debug::NoLocking",false) == false)
506 {
507 Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
508 if (_error->PendingError() == true)
509 return _error->Error("Unable to lock the download directory");
510 }
511
512 // Create the download object
513 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
514 pkgAcquire Fetcher(&Stat);
515
516 // Read the source list
517 pkgSourceList List;
518 if (List.ReadMainList() == false)
519 return _error->Error("The list of sources could not be read.");
520
521 // Create the package manager and prepare to download
522 pkgDPkgPM PM(Cache);
523 if (PM.GetArchives(&Fetcher,&List,&Recs) == false ||
524 _error->PendingError() == true)
525 return false;
526
527 // Display statistics
528 unsigned long FetchBytes = Fetcher.FetchNeeded();
529 unsigned long FetchPBytes = Fetcher.PartialPresent();
530 unsigned long DebBytes = Fetcher.TotalNeeded();
531 if (DebBytes != Cache->DebSize())
532 {
533 c0out << DebBytes << ',' << Cache->DebSize() << endl;
534 c0out << "How odd.. The sizes didn't match, email apt@packages.debian.org" << endl;
535 }
536
537 // Check for enough free space
538 struct statfs Buf;
539 string OutputDir = _config->FindDir("Dir::Cache::Archives");
540 if (statfs(OutputDir.c_str(),&Buf) != 0)
541 return _error->Errno("statfs","Couldn't determine free space in %s",
542 OutputDir.c_str());
543 if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
544 return _error->Error("Sorry, you don't have enough free space in %s",
545 OutputDir.c_str());
546
547 // Number of bytes
548 c1out << "Need to get ";
549 if (DebBytes != FetchBytes)
550 c1out << SizeToStr(FetchBytes) << "B/" << SizeToStr(DebBytes) << 'B';
551 else
552 c1out << SizeToStr(DebBytes) << 'B';
553
554 c1out << " of archives. After unpacking ";
555
556 // Size delta
557 if (Cache->UsrSize() >= 0)
558 c1out << SizeToStr(Cache->UsrSize()) << "B will be used." << endl;
559 else
560 c1out << SizeToStr(-1*Cache->UsrSize()) << "B will be freed." << endl;
561
562 if (_error->PendingError() == true)
563 return false;
564
565 // Fail safe check
566 if (_config->FindI("quiet",0) >= 2 ||
567 _config->FindB("APT::Get::Assume-Yes",false) == true)
568 {
569 if (Fail == true && _config->FindB("APT::Get::Force-Yes",false) == false)
570 return _error->Error("There are problems and -y was used without --force-yes");
571 }
572
573 if (Essential == true && Saftey == true)
574 {
575 c2out << "You are about to do something potentially harmful" << endl;
576 c2out << "To continue type in the phrase 'Yes, I understand this may be bad'" << endl;
577 c2out << " ?] " << flush;
578 if (AnalPrompt("Yes, I understand this may be bad") == false)
579 {
580 c2out << "Abort." << endl;
581 exit(1);
582 }
583 }
584 else
585 {
586 // Prompt to continue
587 if (Ask == true || Fail == true)
588 {
589 if (_config->FindI("quiet",0) < 2 &&
590 _config->FindB("APT::Get::Assume-Yes",false) == false)
591 {
592 c2out << "Do you want to continue? [Y/n] " << flush;
593
594 if (YnPrompt() == false)
595 {
596 c2out << "Abort." << endl;
597 exit(1);
598 }
599 }
600 }
601 }
602
603 // Just print out the uris an exit if the --print-uris flag was used
604 if (_config->FindB("APT::Get::Print-URIs") == true)
605 {
606 pkgAcquire::UriIterator I = Fetcher.UriBegin();
607 for (; I != Fetcher.UriEnd(); I++)
608 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
609 I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl;
610 return true;
611 }
612
613 // Run it
614 while (1)
615 {
616 if (_config->FindB("APT::Get::No-Download",false) == false)
617 if( Fetcher.Run() == pkgAcquire::Failed)
618 return false;
619
620 // Print out errors
621 bool Failed = false;
622 bool Transient = false;
623 for (pkgAcquire::Item **I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
624 {
625 if ((*I)->Status == pkgAcquire::Item::StatDone &&
626 (*I)->Complete == true)
627 continue;
628
629 (*I)->Finished();
630
631 if ((*I)->Status == pkgAcquire::Item::StatIdle)
632 {
633 Transient = true;
634 // Failed = true;
635 continue;
636 }
637
638 cerr << "Failed to fetch " << (*I)->DescURI() << endl;
639 cerr << " " << (*I)->ErrorText << endl;
640 Failed = true;
641 }
642
643 if (_config->FindB("APT::Get::Download-Only",false) == true)
644 {
645 if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
646 return _error->Error("Some files failed to download");
647 return true;
648 }
649
650 if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
651 {
652 /*if (Transient == true)
653 {
654 c2out << "Upgrading with disk swapping is not supported in this version." << endl;
655 c2out << "Try running multiple times with --fix-missing" << endl;
656 }*/
657
658 return _error->Error("Unable to fetch some archives, maybe try with --fix-missing?");
659 }
660
661 if (Transient == true && Failed == true)
662 return _error->Error("--fix-missing and media swapping is not currently supported");
663
664 // Try to deal with missing package files
665 if (Failed == true && PM.FixMissing() == false)
666 {
667 cerr << "Unable to correct missing packages." << endl;
668 return _error->Error("Aborting Install.");
669 }
670
671 Cache.ReleaseLock();
672 pkgPackageManager::OrderResult Res = PM.DoInstall();
673 if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
674 return false;
675 if (Res == pkgPackageManager::Completed)
676 return true;
677
678 // Reload the fetcher object and loop again for media swapping
679 Fetcher.Shutdown();
680 if (PM.GetArchives(&Fetcher,&List,&Recs) == false)
681 return false;
682 }
683 }
684 /*}}}*/
685
686 // DoUpdate - Update the package lists /*{{{*/
687 // ---------------------------------------------------------------------
688 /* */
689 bool DoUpdate(CommandLine &)
690 {
691 // Get the source list
692 pkgSourceList List;
693 if (List.ReadMainList() == false)
694 return false;
695
696 // Lock the list directory
697 FileFd Lock;
698 if (_config->FindB("Debug::NoLocking",false) == false)
699 {
700 Lock.Fd(GetLock(_config->FindDir("Dir::State::Lists") + "lock"));
701 if (_error->PendingError() == true)
702 return _error->Error("Unable to lock the list directory");
703 }
704
705 // Create the download object
706 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
707 pkgAcquire Fetcher(&Stat);
708
709 // Populate it with the source selection
710 pkgSourceList::const_iterator I;
711 for (I = List.begin(); I != List.end(); I++)
712 {
713 new pkgAcqIndex(&Fetcher,I);
714 if (_error->PendingError() == true)
715 return false;
716 }
717
718 // Run it
719 if (Fetcher.Run() == pkgAcquire::Failed)
720 return false;
721
722 bool Failed = false;
723 for (pkgAcquire::Item **I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
724 {
725 if ((*I)->Status == pkgAcquire::Item::StatDone)
726 continue;
727
728 (*I)->Finished();
729
730 Failed = true;
731 }
732
733 // Clean out any old list files
734 if (_config->FindB("APT::Get::List-Cleanup",false) == false)
735 {
736 if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false ||
737 Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false)
738 return false;
739 }
740
741 // Prepare the cache.
742 CacheFile Cache;
743 if (Cache.Open() == false)
744 return false;
745
746 if (Failed == true)
747 return _error->Error("Some index files failed to download, they have been ignored, or old ones used instead.");
748 return true;
749 }
750 /*}}}*/
751 // DoUpgrade - Upgrade all packages /*{{{*/
752 // ---------------------------------------------------------------------
753 /* Upgrade all packages without installing new packages or erasing old
754 packages */
755 bool DoUpgrade(CommandLine &CmdL)
756 {
757 CacheFile Cache;
758 if (Cache.Open() == false || Cache.CheckDeps() == false)
759 return false;
760
761 // Do the upgrade
762 if (pkgAllUpgrade(Cache) == false)
763 {
764 ShowBroken(c1out,Cache);
765 return _error->Error("Internal Error, AllUpgrade broke stuff");
766 }
767
768 return InstallPackages(Cache,true);
769 }
770 /*}}}*/
771 // DoInstall - Install packages from the command line /*{{{*/
772 // ---------------------------------------------------------------------
773 /* Install named packages */
774 bool DoInstall(CommandLine &CmdL)
775 {
776 CacheFile Cache;
777 if (Cache.Open() == false || Cache.CheckDeps(CmdL.FileSize() != 1) == false)
778 return false;
779
780 // Enter the special broken fixing mode if the user specified arguments
781 bool BrokenFix = false;
782 if (Cache->BrokenCount() != 0)
783 BrokenFix = true;
784
785 unsigned int ExpectedInst = 0;
786 unsigned int Packages = 0;
787 pkgProblemResolver Fix(Cache);
788
789 bool DefRemove = false;
790 if (strcasecmp(CmdL.FileList[0],"remove") == 0)
791 DefRemove = true;
792
793 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
794 {
795 // Duplicate the string
796 unsigned int Length = strlen(*I);
797 char S[300];
798 if (Length >= sizeof(S))
799 continue;
800 strcpy(S,*I);
801
802 // See if we are removing the package
803 bool Remove = DefRemove;
804 while (Cache->FindPkg(S).end() == true)
805 {
806 // Handle an optional end tag indicating what to do
807 if (S[Length - 1] == '-')
808 {
809 Remove = true;
810 S[--Length] = 0;
811 continue;
812 }
813
814 if (S[Length - 1] == '+')
815 {
816 Remove = false;
817 S[--Length] = 0;
818 continue;
819 }
820 break;
821 }
822
823 // Locate the package
824 pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
825 Packages++;
826 if (Pkg.end() == true)
827 return _error->Error("Couldn't find package %s",S);
828
829 // Handle the no-upgrade case
830 if (_config->FindB("APT::Get::no-upgrade",false) == true &&
831 Pkg->CurrentVer != 0)
832 {
833 c1out << "Skipping " << Pkg.Name() << ", it is already installed and no-upgrade is set." << endl;
834 continue;
835 }
836
837 // Check if there is something new to install
838 pkgDepCache::StateCache &State = (*Cache)[Pkg];
839 if (State.CandidateVer == 0)
840 {
841 if (Pkg->ProvidesList != 0)
842 {
843 c1out << "Package " << S << " is a virtual package provided by:" << endl;
844
845 pkgCache::PrvIterator I = Pkg.ProvidesList();
846 for (; I.end() == false; I++)
847 {
848 pkgCache::PkgIterator Pkg = I.OwnerPkg();
849
850 if ((*Cache)[Pkg].CandidateVerIter(*Cache) == I.OwnerVer())
851 {
852 if ((*Cache)[Pkg].Install() == true && (*Cache)[Pkg].NewInstall() == false)
853 c1out << " " << Pkg.Name() << " " << I.OwnerVer().VerStr() <<
854 " [Installed]"<< endl;
855 else
856 c1out << " " << Pkg.Name() << " " << I.OwnerVer().VerStr() << endl;
857 }
858 }
859 c1out << "You should explicly select one to install." << endl;
860 }
861 else
862 {
863 c1out << "Package " << S << " has no available version, but exists in the database." << endl;
864 c1out << "This typically means that the package was mentioned in a dependency and " << endl;
865 c1out << "never uploaded, or that it is an obsolete package." << endl;
866
867 string List;
868 pkgCache::DepIterator Dep = Pkg.RevDependsList();
869 for (; Dep.end() == false; Dep++)
870 {
871 if (Dep->Type != pkgCache::Dep::Replaces)
872 continue;
873 List += string(Dep.ParentPkg().Name()) + " ";
874 }
875 ShowList(c1out,"However the following packages replace it:",List);
876 }
877
878 return _error->Error("Package %s has no installation candidate",S);
879 }
880
881 Fix.Protect(Pkg);
882 if (Remove == true)
883 {
884 Fix.Remove(Pkg);
885 Cache->MarkDelete(Pkg,_config->FindB("APT::Get::Purge",false));
886 continue;
887 }
888
889 // Install it
890 Cache->MarkInstall(Pkg,false);
891 if (State.Install() == false)
892 c1out << "Sorry, " << S << " is already the newest version" << endl;
893 else
894 ExpectedInst++;
895
896 // Install it with autoinstalling enabled.
897 if (State.InstBroken() == true && BrokenFix == false)
898 Cache->MarkInstall(Pkg,true);
899 }
900
901 /* If we are in the Broken fixing mode we do not attempt to fix the
902 problems. This is if the user invoked install without -f and gave
903 packages */
904 if (BrokenFix == true && Cache->BrokenCount() != 0)
905 {
906 c1out << "You might want to run `apt-get -f install' to correct these:" << endl;
907 ShowBroken(c1out,Cache);
908
909 return _error->Error("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution).");
910 }
911
912 // Call the scored problem resolver
913 Fix.InstallProtect();
914 if (Fix.Resolve(true) == false)
915 _error->Discard();
916
917 // Now we check the state of the packages,
918 if (Cache->BrokenCount() != 0)
919 {
920 c1out << "Some packages could not be installed. This may mean that you have" << endl;
921 c1out << "requested an impossible situation or if you are using the unstable" << endl;
922 c1out << "distribution that some required packages have not yet been created" << endl;
923 c1out << "or been moved out of Incoming." << endl;
924 if (Packages == 1)
925 {
926 c1out << endl;
927 c1out << "Since you only requested a single operation it is extremely likely that" << endl;
928 c1out << "the package is simply not installable and a bug report against" << endl;
929 c1out << "that package should be filed." << endl;
930 }
931
932 c1out << "The following information may help to resolve the situation:" << endl;
933 c1out << endl;
934 ShowBroken(c1out,Cache);
935 return _error->Error("Sorry, broken packages");
936 }
937
938 /* Print out a list of packages that are going to be installed extra
939 to what the user asked */
940 if (Cache->InstCount() != ExpectedInst)
941 {
942 string List;
943 pkgCache::PkgIterator I = Cache->PkgBegin();
944 for (;I.end() != true; I++)
945 {
946 if ((*Cache)[I].Install() == false)
947 continue;
948
949 const char **J;
950 for (J = CmdL.FileList + 1; *J != 0; J++)
951 if (strcmp(*J,I.Name()) == 0)
952 break;
953
954 if (*J == 0)
955 List += string(I.Name()) + " ";
956 }
957
958 ShowList(c1out,"The following extra packages will be installed:",List);
959 }
960
961 // See if we need to prompt
962 if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0)
963 return InstallPackages(Cache,false,false);
964
965 return InstallPackages(Cache,false);
966 }
967 /*}}}*/
968 // DoDistUpgrade - Automatic smart upgrader /*{{{*/
969 // ---------------------------------------------------------------------
970 /* Intelligent upgrader that will install and remove packages at will */
971 bool DoDistUpgrade(CommandLine &CmdL)
972 {
973 CacheFile Cache;
974 if (Cache.Open() == false || Cache.CheckDeps() == false)
975 return false;
976
977 c0out << "Calculating Upgrade... " << flush;
978 if (pkgDistUpgrade(*Cache) == false)
979 {
980 c0out << "Failed" << endl;
981 ShowBroken(c1out,Cache);
982 return false;
983 }
984
985 c0out << "Done" << endl;
986
987 return InstallPackages(Cache,true);
988 }
989 /*}}}*/
990 // DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
991 // ---------------------------------------------------------------------
992 /* Follows dselect's selections */
993 bool DoDSelectUpgrade(CommandLine &CmdL)
994 {
995 CacheFile Cache;
996 if (Cache.Open() == false || Cache.CheckDeps() == false)
997 return false;
998
999 // Install everything with the install flag set
1000 pkgCache::PkgIterator I = Cache->PkgBegin();
1001 for (;I.end() != true; I++)
1002 {
1003 /* Install the package only if it is a new install, the autoupgrader
1004 will deal with the rest */
1005 if (I->SelectedState == pkgCache::State::Install)
1006 Cache->MarkInstall(I,false);
1007 }
1008
1009 /* Now install their deps too, if we do this above then order of
1010 the status file is significant for | groups */
1011 for (I = Cache->PkgBegin();I.end() != true; I++)
1012 {
1013 /* Install the package only if it is a new install, the autoupgrader
1014 will deal with the rest */
1015 if (I->SelectedState == pkgCache::State::Install)
1016 Cache->MarkInstall(I,true);
1017 }
1018
1019 // Apply erasures now, they override everything else.
1020 for (I = Cache->PkgBegin();I.end() != true; I++)
1021 {
1022 // Remove packages
1023 if (I->SelectedState == pkgCache::State::DeInstall ||
1024 I->SelectedState == pkgCache::State::Purge)
1025 Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
1026 }
1027
1028 /* Resolve any problems that dselect created, allupgrade cannot handle
1029 such things. We do so quite agressively too.. */
1030 if (Cache->BrokenCount() != 0)
1031 {
1032 pkgProblemResolver Fix(Cache);
1033
1034 // Hold back held packages.
1035 if (_config->FindB("APT::Ingore-Hold",false) == false)
1036 {
1037 for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
1038 {
1039 if (I->SelectedState == pkgCache::State::Hold)
1040 {
1041 Fix.Protect(I);
1042 Cache->MarkKeep(I);
1043 }
1044 }
1045 }
1046
1047 if (Fix.Resolve() == false)
1048 {
1049 ShowBroken(c1out,Cache);
1050 return _error->Error("Internal Error, problem resolver broke stuff");
1051 }
1052 }
1053
1054 // Now upgrade everything
1055 if (pkgAllUpgrade(Cache) == false)
1056 {
1057 ShowBroken(c1out,Cache);
1058 return _error->Error("Internal Error, problem resolver broke stuff");
1059 }
1060
1061 return InstallPackages(Cache,false);
1062 }
1063 /*}}}*/
1064 // DoClean - Remove download archives /*{{{*/
1065 // ---------------------------------------------------------------------
1066 /* */
1067 bool DoClean(CommandLine &CmdL)
1068 {
1069 pkgAcquire Fetcher;
1070 Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
1071 Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
1072 return true;
1073 }
1074 /*}}}*/
1075 // DoAutoClean - Smartly remove downloaded archives /*{{{*/
1076 // ---------------------------------------------------------------------
1077 /* This is similar to clean but it only purges things that cannot be
1078 downloaded, that is old versions of cached packages. */
1079 class LogCleaner : public pkgArchiveCleaner
1080 {
1081 protected:
1082 virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
1083 {
1084 cout << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
1085
1086 if (_config->FindB("APT::Get::Simulate") == false)
1087 unlink(File);
1088 };
1089 };
1090
1091 bool DoAutoClean(CommandLine &CmdL)
1092 {
1093 CacheFile Cache;
1094 if (Cache.Open() == false)
1095 return false;
1096
1097 LogCleaner Cleaner;
1098
1099 return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
1100 Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
1101 }
1102 /*}}}*/
1103 // DoCheck - Perform the check operation /*{{{*/
1104 // ---------------------------------------------------------------------
1105 /* Opening automatically checks the system, this command is mostly used
1106 for debugging */
1107 bool DoCheck(CommandLine &CmdL)
1108 {
1109 CacheFile Cache;
1110 Cache.Open();
1111 Cache.CheckDeps();
1112
1113 return true;
1114 }
1115 /*}}}*/
1116 // DoSource - Fetch a source archive /*{{{*/
1117 // ---------------------------------------------------------------------
1118 /* Fetch souce packages */
1119 struct DscFile
1120 {
1121 string Package;
1122 string Version;
1123 string Dsc;
1124 };
1125
1126 bool DoSource(CommandLine &CmdL)
1127 {
1128 CacheFile Cache;
1129 if (Cache.Open(false) == false)
1130 return false;
1131
1132 if (CmdL.FileSize() <= 1)
1133 return _error->Error("Must specify at least one package to fetch source for");
1134
1135 // Read the source list
1136 pkgSourceList List;
1137 if (List.ReadMainList() == false)
1138 return _error->Error("The list of sources could not be read.");
1139
1140 // Create the text record parsers
1141 pkgRecords Recs(Cache);
1142 pkgSrcRecords SrcRecs(List);
1143 if (_error->PendingError() == true)
1144 return false;
1145
1146 // Create the download object
1147 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1148 pkgAcquire Fetcher(&Stat);
1149
1150 DscFile *Dsc = new DscFile[CmdL.FileSize()];
1151
1152 // Load the requestd sources into the fetcher
1153 unsigned J = 0;
1154 for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
1155 {
1156 string Src;
1157
1158 /* Lookup the version of the package we would install if we were to
1159 install a version and determine the source package name, then look
1160 in the archive for a source package of the same name. In theory
1161 we could stash the version string as well and match that too but
1162 today there aren't multi source versions in the archive. */
1163 pkgCache::PkgIterator Pkg = Cache->FindPkg(*I);
1164 if (Pkg.end() == false)
1165 {
1166 pkgCache::VerIterator Ver = Cache->GetCandidateVer(Pkg);
1167 if (Ver.end() == false)
1168 {
1169 pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1170 Src = Parse.SourcePkg();
1171 }
1172 }
1173
1174 // No source package name..
1175 if (Src.empty() == true)
1176 Src = *I;
1177
1178 // The best hit
1179 pkgSrcRecords::Parser *Last = 0;
1180 unsigned long Offset = 0;
1181 string Version;
1182 bool IsMatch = false;
1183
1184 // Iterate over all of the hits
1185 pkgSrcRecords::Parser *Parse;
1186 SrcRecs.Restart();
1187 while ((Parse = SrcRecs.Find(Src.c_str(),false)) != 0)
1188 {
1189 string Ver = Parse->Version();
1190
1191 // Skip name mismatches
1192 if (IsMatch == true && Parse->Package() != Src)
1193 continue;
1194
1195 // Newer version or an exact match
1196 if (Last == 0 || pkgVersionCompare(Version,Ver) < 0 ||
1197 (Parse->Package() == Src && IsMatch == false))
1198 {
1199 IsMatch = Parse->Package() == Src;
1200 Last = Parse;
1201 Offset = Parse->Offset();
1202 Version = Ver;
1203 }
1204 }
1205
1206 if (Last == 0)
1207 return _error->Error("Unable to find a source package for %s",Src.c_str());
1208
1209 // Back track
1210 vector<pkgSrcRecords::File> Lst;
1211 if (Last->Jump(Offset) == false || Last->Files(Lst) == false)
1212 return false;
1213
1214 // Load them into the fetcher
1215 for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
1216 I != Lst.end(); I++)
1217 {
1218 // Try to guess what sort of file it is we are getting.
1219 string Comp;
1220 if (I->Path.find(".dsc") != string::npos)
1221 {
1222 Comp = "dsc";
1223 Dsc[J].Package = Last->Package();
1224 Dsc[J].Version = Last->Version();
1225 Dsc[J].Dsc = flNotDir(I->Path);
1226 }
1227
1228 if (I->Path.find(".tar.gz") != string::npos)
1229 Comp = "tar";
1230 if (I->Path.find(".diff.gz") != string::npos)
1231 Comp = "diff";
1232
1233 new pkgAcqFile(&Fetcher,Last->Source()->ArchiveURI(I->Path),
1234 I->MD5Hash,I->Size,Last->Source()->SourceInfo(Src,
1235 Last->Version(),Comp),Src);
1236 }
1237 }
1238
1239 // Display statistics
1240 unsigned long FetchBytes = Fetcher.FetchNeeded();
1241 unsigned long FetchPBytes = Fetcher.PartialPresent();
1242 unsigned long DebBytes = Fetcher.TotalNeeded();
1243
1244 // Check for enough free space
1245 struct statfs Buf;
1246 string OutputDir = ".";
1247 if (statfs(OutputDir.c_str(),&Buf) != 0)
1248 return _error->Errno("statfs","Couldn't determine free space in %s",
1249 OutputDir.c_str());
1250 if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
1251 return _error->Error("Sorry, you don't have enough free space in %s",
1252 OutputDir.c_str());
1253
1254 // Number of bytes
1255 c1out << "Need to get ";
1256 if (DebBytes != FetchBytes)
1257 c1out << SizeToStr(FetchBytes) << "B/" << SizeToStr(DebBytes) << 'B';
1258 else
1259 c1out << SizeToStr(DebBytes) << 'B';
1260 c1out << " of source archives." << endl;
1261
1262 if (_config->FindB("APT::Get::Simulate",false) == true)
1263 {
1264 for (unsigned I = 0; I != J; I++)
1265 cout << "Fetch Source " << Dsc[I].Package << endl;
1266 return true;
1267 }
1268
1269 // Just print out the uris an exit if the --print-uris flag was used
1270 if (_config->FindB("APT::Get::Print-URIs") == true)
1271 {
1272 pkgAcquire::UriIterator I = Fetcher.UriBegin();
1273 for (; I != Fetcher.UriEnd(); I++)
1274 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
1275 I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl;
1276 return true;
1277 }
1278
1279 // Run it
1280 if (Fetcher.Run() == pkgAcquire::Failed)
1281 return false;
1282
1283 // Print error messages
1284 bool Failed = false;
1285 for (pkgAcquire::Item **I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
1286 {
1287 if ((*I)->Status == pkgAcquire::Item::StatDone &&
1288 (*I)->Complete == true)
1289 continue;
1290
1291 cerr << "Failed to fetch " << (*I)->DescURI() << endl;
1292 cerr << " " << (*I)->ErrorText << endl;
1293 Failed = true;
1294 }
1295 if (Failed == true)
1296 return _error->Error("Failed to fetch some archives.");
1297
1298 if (_config->FindB("APT::Get::Download-only",false) == true)
1299 return true;
1300
1301 // Unpack the sources
1302 pid_t Process = ExecFork();
1303
1304 if (Process == 0)
1305 {
1306 for (unsigned I = 0; I != J; I++)
1307 {
1308 string Dir = Dsc[I].Package + '-' + pkgBaseVersion(Dsc[I].Version.c_str());
1309
1310 // See if the package is already unpacked
1311 struct stat Stat;
1312 if (stat(Dir.c_str(),&Stat) == 0 &&
1313 S_ISDIR(Stat.st_mode) != 0)
1314 {
1315 c0out << "Skipping unpack of already unpacked source in " << Dir << endl;
1316 }
1317 else
1318 {
1319 // Call dpkg-source
1320 char S[500];
1321 snprintf(S,sizeof(S),"%s -x %s",
1322 _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
1323 Dsc[I].Dsc.c_str());
1324 if (system(S) != 0)
1325 {
1326 cerr << "Unpack command '" << S << "' failed." << endl;
1327 _exit(1);
1328 }
1329 }
1330
1331 // Try to compile it with dpkg-buildpackage
1332 if (_config->FindB("APT::Get::Compile",false) == true)
1333 {
1334 // Call dpkg-buildpackage
1335 char S[500];
1336 snprintf(S,sizeof(S),"cd %s && %s %s",
1337 Dir.c_str(),
1338 _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
1339 _config->Find("DPkg::Build-Options","-b -uc").c_str());
1340
1341 if (system(S) != 0)
1342 {
1343 cerr << "Build command '" << S << "' failed." << endl;
1344 _exit(1);
1345 }
1346 }
1347 }
1348
1349 _exit(0);
1350 }
1351
1352 // Wait for the subprocess
1353 int Status = 0;
1354 while (waitpid(Process,&Status,0) != Process)
1355 {
1356 if (errno == EINTR)
1357 continue;
1358 return _error->Errno("waitpid","Couldn't wait for subprocess");
1359 }
1360
1361 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
1362 return _error->Error("Child process failed");
1363
1364 return true;
1365 }
1366 /*}}}*/
1367
1368 // ShowHelp - Show a help screen /*{{{*/
1369 // ---------------------------------------------------------------------
1370 /* */
1371 bool ShowHelp(CommandLine &CmdL)
1372 {
1373 cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
1374 " compiled on " << __DATE__ << " " << __TIME__ << endl;
1375 if (_config->FindB("version") == true)
1376 return 100;
1377
1378 cout << "Usage: apt-get [options] command" << endl;
1379 cout << " apt-get [options] install pkg1 [pkg2 ...]" << endl;
1380 cout << endl;
1381 cout << "apt-get is a simple command line interface for downloading and" << endl;
1382 cout << "installing packages. The most frequently used commands are update" << endl;
1383 cout << "and install." << endl;
1384 cout << endl;
1385 cout << "Commands:" << endl;
1386 cout << " update - Retrieve new lists of packages" << endl;
1387 cout << " upgrade - Perform an upgrade" << endl;
1388 cout << " install - Install new packages (pkg is libc6 not libc6.deb)" << endl;
1389 cout << " remove - Remove packages" << endl;
1390 cout << " source - Download source archives" << endl;
1391 cout << " dist-upgrade - Distribution upgrade, see apt-get(8)" << endl;
1392 cout << " dselect-upgrade - Follow dselect selections" << endl;
1393 cout << " clean - Erase downloaded archive files" << endl;
1394 cout << " autoclean - Erase old downloaded archive files" << endl;
1395 cout << " check - Verify that there are no broken dependencies" << endl;
1396 cout << endl;
1397 cout << "Options:" << endl;
1398 cout << " -h This help text." << endl;
1399 cout << " -q Loggable output - no progress indicator" << endl;
1400 cout << " -qq No output except for errors" << endl;
1401 cout << " -d Download only - do NOT install or unpack archives" << endl;
1402 cout << " -s No-act. Perform ordering simulation" << endl;
1403 cout << " -y Assume Yes to all queries and do not prompt" << endl;
1404 cout << " -f Attempt to continue if the integrity check fails" << endl;
1405 cout << " -m Attempt to continue if archives are unlocatable" << endl;
1406 cout << " -u Show a list of upgraded packages as well" << endl;
1407 cout << " -b Build the source package after fetching it" << endl;
1408 cout << " -c=? Read this configuration file" << endl;
1409 cout << " -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp" << endl;
1410 cout << "See the apt-get(8), sources.list(5) and apt.conf(5) manual" << endl;
1411 cout << "pages for more information and options." << endl;
1412 return 100;
1413 }
1414 /*}}}*/
1415 // GetInitialize - Initialize things for apt-get /*{{{*/
1416 // ---------------------------------------------------------------------
1417 /* */
1418 void GetInitialize()
1419 {
1420 _config->Set("quiet",0);
1421 _config->Set("help",false);
1422 _config->Set("APT::Get::Download-Only",false);
1423 _config->Set("APT::Get::Simulate",false);
1424 _config->Set("APT::Get::Assume-Yes",false);
1425 _config->Set("APT::Get::Fix-Broken",false);
1426 _config->Set("APT::Get::Force-Yes",false);
1427 _config->Set("APT::Get::APT::Get::No-List-Cleanup",true);
1428 }
1429 /*}}}*/
1430 // SigWinch - Window size change signal handler /*{{{*/
1431 // ---------------------------------------------------------------------
1432 /* */
1433 void SigWinch(int)
1434 {
1435 // Riped from GNU ls
1436 #ifdef TIOCGWINSZ
1437 struct winsize ws;
1438
1439 if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
1440 ScreenWidth = ws.ws_col - 1;
1441 #endif
1442 }
1443 /*}}}*/
1444
1445 int main(int argc,const char *argv[])
1446 {
1447 CommandLine::Args Args[] = {
1448 {'h',"help","help",0},
1449 {'v',"version","version",0},
1450 {'q',"quiet","quiet",CommandLine::IntLevel},
1451 {'q',"silent","quiet",CommandLine::IntLevel},
1452 {'d',"download-only","APT::Get::Download-Only",0},
1453 {'b',"compile","APT::Get::Compile",0},
1454 {'b',"build","APT::Get::Compile",0},
1455 {'s',"simulate","APT::Get::Simulate",0},
1456 {'s',"just-print","APT::Get::Simulate",0},
1457 {'s',"recon","APT::Get::Simulate",0},
1458 {'s',"no-act","APT::Get::Simulate",0},
1459 {'y',"yes","APT::Get::Assume-Yes",0},
1460 {'y',"assume-yes","APT::Get::Assume-Yes",0},
1461 {'f',"fix-broken","APT::Get::Fix-Broken",0},
1462 {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
1463 {'m',"ignore-missing","APT::Get::Fix-Missing",0},
1464 {0,"no-download","APT::Get::No-Download",0},
1465 {0,"fix-missing","APT::Get::Fix-Missing",0},
1466 {0,"ignore-hold","APT::Ingore-Hold",0},
1467 {0,"no-upgrade","APT::Get::no-upgrade",0},
1468 {0,"force-yes","APT::Get::force-yes",0},
1469 {0,"print-uris","APT::Get::Print-URIs",0},
1470 {0,"purge","APT::Get::Purge",0},
1471 {0,"list-cleanup","APT::Get::List-Cleanup",0},
1472 {'c',"config-file",0,CommandLine::ConfigFile},
1473 {'o',"option",0,CommandLine::ArbItem},
1474 {0,0,0,0}};
1475 CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
1476 {"upgrade",&DoUpgrade},
1477 {"install",&DoInstall},
1478 {"remove",&DoInstall},
1479 {"dist-upgrade",&DoDistUpgrade},
1480 {"dselect-upgrade",&DoDSelectUpgrade},
1481 {"clean",&DoClean},
1482 {"autoclean",&DoAutoClean},
1483 {"check",&DoCheck},
1484 {"source",&DoSource},
1485 {"help",&ShowHelp},
1486 {0,0}};
1487
1488 // Parse the command line and initialize the package library
1489 CommandLine CmdL(Args,_config);
1490 if (pkgInitialize(*_config) == false ||
1491 CmdL.Parse(argc,argv) == false)
1492 {
1493 _error->DumpErrors();
1494 return 100;
1495 }
1496
1497 // See if the help should be shown
1498 if (_config->FindB("help") == true ||
1499 _config->FindB("version") == true ||
1500 CmdL.FileSize() == 0)
1501 return ShowHelp(CmdL);
1502
1503 // Deal with stdout not being a tty
1504 if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1)
1505 _config->Set("quiet","1");
1506
1507 // Setup the output streams
1508 c0out.rdbuf(cout.rdbuf());
1509 c1out.rdbuf(cout.rdbuf());
1510 c2out.rdbuf(cout.rdbuf());
1511 if (_config->FindI("quiet",0) > 0)
1512 c0out.rdbuf(devnull.rdbuf());
1513 if (_config->FindI("quiet",0) > 1)
1514 c1out.rdbuf(devnull.rdbuf());
1515
1516 // Setup the signals
1517 signal(SIGPIPE,SIG_IGN);
1518 signal(SIGWINCH,SigWinch);
1519 SigWinch(0);
1520
1521 // Match the operation
1522 CmdL.DispatchArg(Cmds);
1523
1524 // Print any errors or warnings found during parsing
1525 if (_error->empty() == false)
1526 {
1527 bool Errors = _error->PendingError();
1528 _error->DumpErrors();
1529 return Errors == true?100:0;
1530 }
1531
1532 return 0;
1533 }
APT (for Cydia)