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