]> git.saurik.com Git - apt.git/blame - cmdline/apt-get.cc
cleanup
[apt.git] / cmdline / apt-get.cc
CommitLineData
5ec427c2
AL
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
640c5d94 3// $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
5ec427c2
AL
4/* ######################################################################
5
6 apt-get - Cover for dpkg
7
8 This is an allout cover for dpkg implementing a safer front end. It is
9 based largely on libapt-pkg.
10
11 The syntax is different,
12 apt-get [opt] command [things]
13 Where command is:
14 update - Resyncronize the package files from their sources
15 upgrade - Smart-Download the newest versions of all packages
16 dselect-upgrade - Follows dselect's changes to the Status: field
17 and installes new and removes old packages
1e3f4083 18 dist-upgrade - Powerful upgrader designed to handle the issues with
5ec427c2
AL
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 /*{{{*/
ea542140
DK
28#include <config.h>
29
453b82a3
DK
30#include <apt-pkg/acquire-item.h>
31#include <apt-pkg/algorithms.h>
086bb6d7 32#include <apt-pkg/aptconfiguration.h>
453b82a3
DK
33#include <apt-pkg/cachefile.h>
34#include <apt-pkg/cacheset.h>
35#include <apt-pkg/clean.h>
0a8e3465 36#include <apt-pkg/cmndline.h>
453b82a3 37#include <apt-pkg/debmetaindex.h>
0a8e3465 38#include <apt-pkg/depcache.h>
453b82a3 39#include <apt-pkg/error.h>
472ff00e 40#include <apt-pkg/fileutl.h>
453b82a3
DK
41#include <apt-pkg/indexfile.h>
42#include <apt-pkg/indexrecords.h>
43#include <apt-pkg/init.h>
092ae175 44#include <apt-pkg/md5.h>
453b82a3 45#include <apt-pkg/metaindex.h>
472ff00e 46#include <apt-pkg/pkgrecords.h>
453b82a3
DK
47#include <apt-pkg/pkgsystem.h>
48#include <apt-pkg/progress.h>
49#include <apt-pkg/sourcelist.h>
50#include <apt-pkg/srcrecords.h>
51#include <apt-pkg/strutl.h>
52#include <apt-pkg/version.h>
53#include <apt-pkg/acquire.h>
54#include <apt-pkg/configuration.h>
55#include <apt-pkg/macros.h>
56#include <apt-pkg/pkgcache.h>
57#include <apt-pkg/cacheiterators.h>
82e369c4 58#include <apt-pkg/upgrade.h>
ffee1c2b 59
453b82a3
DK
60#include <apt-private/acqprogress.h>
61#include <apt-private/private-cacheset.h>
62#include <apt-private/private-cachefile.h>
63#include <apt-private/private-cmndline.h>
866893a6 64#include <apt-private/private-download.h>
b9179170 65#include <apt-private/private-install.h>
453b82a3
DK
66#include <apt-private/private-main.h>
67#include <apt-private/private-moo.h>
b9179170 68#include <apt-private/private-output.h>
b9179170 69#include <apt-private/private-update.h>
453b82a3 70#include <apt-private/private-upgrade.h>
cfacba52 71#include <apt-private/private-utils.h>
b9179170 72
453b82a3
DK
73#include <errno.h>
74#include <signal.h>
75#include <stddef.h>
76#include <stdio.h>
77#include <stdlib.h>
78#include <string.h>
a3f1d60c 79#include <sys/ioctl.h>
1bc849af 80#include <sys/stat.h>
885d204b 81#include <sys/statfs.h>
101030ab 82#include <sys/statvfs.h>
b9179170 83#include <sys/wait.h>
453b82a3
DK
84#include <unistd.h>
85#include <algorithm>
86#include <fstream>
87#include <iostream>
88#include <set>
89#include <string>
90#include <vector>
5ec427c2 91
b9179170
MV
92#include <apti18n.h>
93 /*}}}*/
afb1e2e3 94
b9179170 95using namespace std;
642ebc1a 96
b8ad5512 97// TryToInstallBuildDep - Try to install a single package /*{{{*/
c373c37a
AL
98// ---------------------------------------------------------------------
99/* This used to be inlined in DoInstall, but with the advent of regex package
100 name matching it was split out.. */
c3ccac92 101static bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg,pkgCacheFile &Cache,
c373c37a 102 pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
70e706ad 103 bool AllowFail = true)
c373c37a 104{
21d4c9f1 105 if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0)
c373c37a 106 {
21d4c9f1 107 CacheSetHelperAPTGet helper(c1out);
4caf8231 108 helper.showErrors(false);
21d4c9f1
DK
109 pkgCache::VerIterator Ver = helper.canNotFindNewestVer(Cache, Pkg);
110 if (Ver.end() == false)
111 Pkg = Ver.ParentPkg();
112 else if (helper.showVirtualPackageErrors(Cache) == false)
113 return AllowFail;
c373c37a 114 }
61d6a8de 115
ac321486
DK
116 if (_config->FindB("Debug::BuildDeps",false) == true)
117 {
118 if (Remove == true)
119 cout << " Trying to remove " << Pkg << endl;
120 else
121 cout << " Trying to install " << Pkg << endl;
122 }
123
c373c37a
AL
124 if (Remove == true)
125 {
71d73928 126 TryToRemove RemoveAction(Cache, &Fix);
21d4c9f1
DK
127 RemoveAction(Pkg.VersionList());
128 } else if (Cache[Pkg].CandidateVer != 0) {
71d73928 129 TryToInstall InstallAction(Cache, &Fix, BrokenFix);
21d4c9f1 130 InstallAction(Cache[Pkg].CandidateVerIter(Cache));
6806db8a 131 InstallAction.doAutoInstall();
21d4c9f1
DK
132 } else
133 return AllowFail;
60681f93 134
b2e465d6
AL
135 return true;
136}
137 /*}}}*/
7014e148
MV
138
139
140// helper that can go wit hthe next ABI break
141#if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR < 13)
c3ccac92 142static std::string MetaIndexFileNameOnDisk(metaIndex *metaindex)
7014e148
MV
143{
144 // FIXME: this cast is the horror, the horror
145 debReleaseIndex *r = (debReleaseIndex*)metaindex;
146
147 // see if we have a InRelease file
148 std::string PathInRelease = r->MetaIndexFile("InRelease");
149 if (FileExists(PathInRelease))
150 return PathInRelease;
151
152 // and if not return the normal one
153 if (FileExists(PathInRelease))
154 return r->MetaIndexFile("Release");
155
156 return "";
157}
158#endif
159
160// GetReleaseForSourceRecord - Return Suite for the given srcrecord /*{{{*/
161// ---------------------------------------------------------------------
162/* */
c3ccac92 163static std::string GetReleaseForSourceRecord(pkgSourceList *SrcList,
7014e148
MV
164 pkgSrcRecords::Parser *Parse)
165{
166 // try to find release
167 const pkgIndexFile& CurrentIndexFile = Parse->Index();
168
169 for (pkgSourceList::const_iterator S = SrcList->begin();
170 S != SrcList->end(); ++S)
171 {
172 vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
173 for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
174 IF != Indexes->end(); ++IF)
175 {
176 if (&CurrentIndexFile == (*IF))
177 {
178#if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR < 13)
179 std::string path = MetaIndexFileNameOnDisk(*S);
180#else
181 std::string path = (*S)->LocalFileName();
182#endif
183 if (path != "")
184 {
185 indexRecords records;
186 records.Load(path);
187 return records.GetSuite();
188 }
189 }
190 }
191 }
192 return "";
193}
194 /*}}}*/
b2e465d6
AL
195// FindSrc - Find a source record /*{{{*/
196// ---------------------------------------------------------------------
197/* */
c3ccac92 198static pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
b2e465d6 199 pkgSrcRecords &SrcRecs,string &Src,
7014e148 200 CacheFile &CacheFile)
b2e465d6 201{
adf379e7
MV
202 string VerTag, UserRequestedVerTag;
203 string ArchTag = "";
7014e148 204 string RelTag = _config->Find("APT::Default-Release");
b2e465d6 205 string TmpSrc = Name;
7014e148 206 pkgDepCache *Cache = CacheFile.GetDepCache();
aca056a9 207
adf379e7
MV
208 // extract release
209 size_t found = TmpSrc.find_last_of("/");
210 if (found != string::npos)
211 {
212 RelTag = TmpSrc.substr(found+1);
213 TmpSrc = TmpSrc.substr(0,found);
214 }
215 // extract the version
216 found = TmpSrc.find_last_of("=");
217 if (found != string::npos)
218 {
219 VerTag = UserRequestedVerTag = TmpSrc.substr(found+1);
220 TmpSrc = TmpSrc.substr(0,found);
221 }
222 // extract arch
223 found = TmpSrc.find_last_of(":");
224 if (found != string::npos)
225 {
226 ArchTag = TmpSrc.substr(found+1);
ebf6c42d
DK
227 TmpSrc = TmpSrc.substr(0,found);
228 }
aca056a9 229
fb3dc579
MV
230 /* Lookup the version of the package we would install if we were to
231 install a version and determine the source package name, then look
232 in the archive for a source package of the same name. */
233 bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
adf379e7
MV
234 pkgCache::PkgIterator Pkg;
235 if (ArchTag != "")
236 Pkg = Cache->FindPkg(TmpSrc, ArchTag);
237 else
238 Pkg = Cache->FindPkg(TmpSrc);
239
240 // if we can't find a package but the user qualified with a arch,
241 // error out here
242 if (Pkg.end() && ArchTag != "")
243 {
244 Src = Name;
245 _error->Error(_("Can not find a package for architecture '%s'"),
246 ArchTag.c_str());
247 return 0;
248 }
249
fb3dc579 250 if (MatchSrcOnly == false && Pkg.end() == false)
aca056a9 251 {
adf379e7 252 if(VerTag != "" || RelTag != "" || ArchTag != "")
aca056a9 253 {
e84adb76 254 bool fuzzy = false;
fb3dc579
MV
255 // we have a default release, try to locate the pkg. we do it like
256 // this because GetCandidateVer() will not "downgrade", that means
257 // "apt-get source -t stable apt" won't work on a unstable system
f7f0d6c7 258 for (pkgCache::VerIterator Ver = Pkg.VersionList();; ++Ver)
aca056a9 259 {
e84adb76
DK
260 // try first only exact matches, later fuzzy matches
261 if (Ver.end() == true)
262 {
263 if (fuzzy == true)
264 break;
265 fuzzy = true;
266 Ver = Pkg.VersionList();
259f688a
MV
267 // exit right away from the Pkg.VersionList() loop if we
268 // don't have any versions
269 if (Ver.end() == true)
270 break;
e84adb76 271 }
adf379e7 272
37f45a57
MV
273 // ignore arches that are not for us
274 if (ArchTag != "" && Ver.Arch() != ArchTag)
275 continue;
276
adf379e7
MV
277 // pick highest version for the arch unless the user wants
278 // something else
279 if (ArchTag != "" && VerTag == "" && RelTag == "")
adf379e7
MV
280 if(Cache->VS().CmpVersion(VerTag, Ver.VerStr()) < 0)
281 VerTag = Ver.VerStr();
adf379e7 282
e84adb76
DK
283 // We match against a concrete version (or a part of this version)
284 if (VerTag.empty() == false &&
7014e148 285 (fuzzy == true || Cache->VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
e84adb76
DK
286 (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
287 continue;
288
fb3dc579 289 for (pkgCache::VerFileIterator VF = Ver.FileList();
f7f0d6c7 290 VF.end() == false; ++VF)
aca056a9 291 {
fb3dc579
MV
292 /* If this is the status file, and the current version is not the
293 version in the status file (ie it is not installed, or somesuch)
294 then it is not a candidate for installation, ever. This weeds
295 out bogus entries that may be due to config-file states, or
296 other. */
297 if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
298 pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
299 continue;
300
fb3dc579
MV
301 // or we match against a release
302 if(VerTag.empty() == false ||
7014e148
MV
303 (VF.File().Archive() != 0 && VF.File().Archive() == RelTag) ||
304 (VF.File().Codename() != 0 && VF.File().Codename() == RelTag))
fb3dc579
MV
305 {
306 pkgRecords::Parser &Parse = Recs.Lookup(VF);
307 Src = Parse.SourcePkg();
61690a7e
MV
308 // no SourcePkg name, so it is the "binary" name
309 if (Src.empty() == true)
310 Src = TmpSrc;
e84adb76
DK
311 // the Version we have is possibly fuzzy or includes binUploads,
312 // so we use the Version of the SourcePkg (empty if same as package)
313 VerTag = Parse.SourceVer();
61690a7e
MV
314 if (VerTag.empty() == true)
315 VerTag = Ver.VerStr();
fb3dc579
MV
316 break;
317 }
aca056a9 318 }
61690a7e
MV
319 if (Src.empty() == false)
320 break;
aca056a9 321 }
026f60e2 322 }
adf379e7 323
37f45a57
MV
324 if (Src == "" && ArchTag != "")
325 {
c9829e07
MV
326 if (VerTag != "")
327 _error->Error(_("Can not find a package '%s' with version '%s'"),
328 Pkg.FullName().c_str(), VerTag.c_str());
329 if (RelTag != "")
330 _error->Error(_("Can not find a package '%s' with release '%s'"),
331 Pkg.FullName().c_str(), RelTag.c_str());
37f45a57
MV
332 Src = Name;
333 return 0;
334 }
335
336
61690a7e 337 if (Src.empty() == true)
b2e465d6 338 {
61690a7e
MV
339 // if we don't have found a fitting package yet so we will
340 // choose a good candidate and proceed with that.
341 // Maybe we will find a source later on with the right VerTag
7014e148
MV
342 // or RelTag
343 pkgCache::VerIterator Ver = Cache->GetCandidateVer(Pkg);
fb3dc579 344 if (Ver.end() == false)
b2e465d6
AL
345 {
346 pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
347 Src = Parse.SourcePkg();
61690a7e
MV
348 if (VerTag.empty() == true)
349 VerTag = Parse.SourceVer();
b2e465d6 350 }
fb3dc579
MV
351 }
352 }
353
354 if (Src.empty() == true)
7014e148 355 {
fb3dc579 356 Src = TmpSrc;
7014e148 357 }
fb3dc579
MV
358 else
359 {
360 /* if we have a source pkg name, make sure to only search
361 for srcpkg names, otherwise apt gets confused if there
362 is a binary package "pkg1" and a source package "pkg1"
363 with the same name but that comes from different packages */
364 MatchSrcOnly = true;
365 if (Src != TmpSrc)
366 {
367 ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
368 }
b2e465d6 369 }
89ad8e7c 370
b2e465d6
AL
371 // The best hit
372 pkgSrcRecords::Parser *Last = 0;
373 unsigned long Offset = 0;
374 string Version;
7014e148 375 pkgSourceList *SrcList = CacheFile.GetSourceList();
89ad8e7c 376
b2e465d6
AL
377 /* Iterate over all of the hits, which includes the resulting
378 binary packages in the search */
379 pkgSrcRecords::Parser *Parse;
fb3dc579 380 while (true)
b2e465d6 381 {
fb3dc579
MV
382 SrcRecs.Restart();
383 while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
b2e465d6 384 {
fb3dc579
MV
385 const string Ver = Parse->Version();
386
7014e148 387 // See if we need to look for a specific release tag
65dcff55 388 if (RelTag != "" && UserRequestedVerTag == "")
7014e148
MV
389 {
390 const string Rel = GetReleaseForSourceRecord(SrcList, Parse);
391
392 if (Rel == RelTag)
393 {
7014e148
MV
394 Last = Parse;
395 Offset = Parse->Offset();
651ae5ce 396 Version = Ver;
7014e148
MV
397 }
398 }
399
fb3dc579 400 // Ignore all versions which doesn't fit
e84adb76 401 if (VerTag.empty() == false &&
7014e148 402 Cache->VS().CmpVersion(VerTag, Ver) != 0) // exact match
b2e465d6 403 continue;
fb3dc579
MV
404
405 // Newer version or an exact match? Save the hit
7014e148 406 if (Last == 0 || Cache->VS().CmpVersion(Version,Ver) < 0) {
fb3dc579
MV
407 Last = Parse;
408 Offset = Parse->Offset();
409 Version = Ver;
410 }
411
7014e148
MV
412 // was the version check above an exact match?
413 // If so, we don't need to look further
414 if (VerTag.empty() == false && (VerTag == Ver))
fb3dc579 415 break;
b2e465d6 416 }
65dcff55 417 if (UserRequestedVerTag == "" && Version != "" && RelTag != "")
bfa7bfc8 418 ioprintf(c1out, "Selected version '%s' (%s) for %s\n",
651ae5ce
MV
419 Version.c_str(), RelTag.c_str(), Src.c_str());
420
fb3dc579
MV
421 if (Last != 0 || VerTag.empty() == true)
422 break;
017d3f3b 423 _error->Error(_("Can not find version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
ddff663f 424 return 0;
b2e465d6 425 }
fb3dc579 426
ce6162be 427 if (Last == 0 || Last->Jump(Offset) == false)
b2e465d6 428 return 0;
fb3dc579 429
b2e465d6
AL
430 return Last;
431}
432 /*}}}*/
182a6a55 433/* mark packages as automatically/manually installed. {{{*/
c3ccac92 434static bool DoMarkAuto(CommandLine &CmdL)
d63a1458
JAK
435{
436 bool Action = true;
437 int AutoMarkChanged = 0;
438 OpTextProgress progress;
439 CacheFile Cache;
440 if (Cache.Open() == false)
441 return false;
442
443 if (strcasecmp(CmdL.FileList[0],"markauto") == 0)
444 Action = true;
445 else if (strcasecmp(CmdL.FileList[0],"unmarkauto") == 0)
446 Action = false;
447
448 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
449 {
450 const char *S = *I;
451 // Locate the package
452 pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
453 if (Pkg.end() == true) {
454 return _error->Error(_("Couldn't find package %s"),S);
455 }
456 else
457 {
458 if (!Action)
459 ioprintf(c1out,_("%s set to manually installed.\n"), Pkg.Name());
460 else
461 ioprintf(c1out,_("%s set to automatically installed.\n"),
462 Pkg.Name());
463
464 Cache->MarkAuto(Pkg,Action);
465 AutoMarkChanged++;
466 }
467 }
182a6a55
DK
468
469 _error->Notice(_("This command is deprecated. Please use 'apt-mark auto' and 'apt-mark manual' instead."));
470
d63a1458
JAK
471 if (AutoMarkChanged && ! _config->FindB("APT::Get::Simulate",false))
472 return Cache->writeStateFile(NULL);
473 return false;
474}
0a8e3465 475 /*}}}*/
0a8e3465
AL
476// DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
477// ---------------------------------------------------------------------
478/* Follows dselect's selections */
65512241 479static bool DoDSelectUpgrade(CommandLine &)
0a8e3465
AL
480{
481 CacheFile Cache;
c37b9502 482 if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
0a8e3465
AL
483 return false;
484
a4decc40
MV
485 pkgDepCache::ActionGroup group(Cache);
486
0a8e3465
AL
487 // Install everything with the install flag set
488 pkgCache::PkgIterator I = Cache->PkgBegin();
f7f0d6c7 489 for (;I.end() != true; ++I)
0a8e3465
AL
490 {
491 /* Install the package only if it is a new install, the autoupgrader
492 will deal with the rest */
493 if (I->SelectedState == pkgCache::State::Install)
494 Cache->MarkInstall(I,false);
495 }
496
497 /* Now install their deps too, if we do this above then order of
498 the status file is significant for | groups */
f7f0d6c7 499 for (I = Cache->PkgBegin();I.end() != true; ++I)
0a8e3465
AL
500 {
501 /* Install the package only if it is a new install, the autoupgrader
502 will deal with the rest */
503 if (I->SelectedState == pkgCache::State::Install)
2f45c76a 504 Cache->MarkInstall(I,true);
0a8e3465
AL
505 }
506
507 // Apply erasures now, they override everything else.
f7f0d6c7 508 for (I = Cache->PkgBegin();I.end() != true; ++I)
0a8e3465
AL
509 {
510 // Remove packages
511 if (I->SelectedState == pkgCache::State::DeInstall ||
512 I->SelectedState == pkgCache::State::Purge)
d556d1a1 513 Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
0a8e3465
AL
514 }
515
2f45c76a 516 /* Resolve any problems that dselect created, allupgrade cannot handle
1e3f4083 517 such things. We do so quite aggressively too.. */
2f45c76a
AL
518 if (Cache->BrokenCount() != 0)
519 {
520 pkgProblemResolver Fix(Cache);
521
522 // Hold back held packages.
b2e465d6 523 if (_config->FindB("APT::Ignore-Hold",false) == false)
2f45c76a 524 {
f7f0d6c7 525 for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; ++I)
2f45c76a
AL
526 {
527 if (I->SelectedState == pkgCache::State::Hold)
528 {
529 Fix.Protect(I);
530 Cache->MarkKeep(I);
531 }
532 }
533 }
534
535 if (Fix.Resolve() == false)
536 {
421c8d10 537 ShowBroken(c1out,Cache,false);
2a7e07c7 538 return _error->Error(_("Internal error, problem resolver broke stuff"));
2f45c76a
AL
539 }
540 }
541
542 // Now upgrade everything
0a8e3465
AL
543 if (pkgAllUpgrade(Cache) == false)
544 {
421c8d10 545 ShowBroken(c1out,Cache,false);
2a7e07c7 546 return _error->Error(_("Internal error, problem resolver broke stuff"));
0a8e3465
AL
547 }
548
549 return InstallPackages(Cache,false);
550}
551 /*}}}*/
552// DoClean - Remove download archives /*{{{*/
553// ---------------------------------------------------------------------
554/* */
65512241 555static bool DoClean(CommandLine &)
0a8e3465 556{
657ecd4a
DK
557 std::string const archivedir = _config->FindDir("Dir::Cache::archives");
558 std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
559 std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
560
8b067c22
AL
561 if (_config->FindB("APT::Get::Simulate") == true)
562 {
657ecd4a
DK
563 cout << "Del " << archivedir << "* " << archivedir << "partial/*"<< endl
564 << "Del " << pkgcache << " " << srcpkgcache << endl;
8b067c22
AL
565 return true;
566 }
567
1b6d659c
AL
568 // Lock the archive directory
569 FileFd Lock;
570 if (_config->FindB("Debug::NoLocking",false) == false)
571 {
de24f8ce
MV
572 int lock_fd = GetLock(archivedir + "lock");
573 if (lock_fd < 0)
b2e465d6 574 return _error->Error(_("Unable to lock the download directory"));
de24f8ce 575 Lock.Fd(lock_fd);
1b6d659c
AL
576 }
577
7a1b1f8b 578 pkgAcquire Fetcher;
657ecd4a
DK
579 Fetcher.Clean(archivedir);
580 Fetcher.Clean(archivedir + "partial/");
581
8de79b68 582 pkgCacheFile::RemoveCaches();
657ecd4a 583
0a8e3465
AL
584 return true;
585}
586 /*}}}*/
1bc849af
AL
587// DoAutoClean - Smartly remove downloaded archives /*{{{*/
588// ---------------------------------------------------------------------
589/* This is similar to clean but it only purges things that cannot be
590 downloaded, that is old versions of cached packages. */
65a1e968
AL
591class LogCleaner : public pkgArchiveCleaner
592{
593 protected:
594 virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
595 {
4cc8bab0 596 c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
c1e78ee5
AL
597
598 if (_config->FindB("APT::Get::Simulate") == false)
599 unlink(File);
65a1e968
AL
600 };
601};
602
65512241 603static bool DoAutoClean(CommandLine &)
1bc849af 604{
1b6d659c
AL
605 // Lock the archive directory
606 FileFd Lock;
607 if (_config->FindB("Debug::NoLocking",false) == false)
608 {
de24f8ce
MV
609 int lock_fd = GetLock(_config->FindDir("Dir::Cache::Archives") + "lock");
610 if (lock_fd < 0)
b2e465d6 611 return _error->Error(_("Unable to lock the download directory"));
de24f8ce 612 Lock.Fd(lock_fd);
1b6d659c
AL
613 }
614
1bc849af 615 CacheFile Cache;
2d11135a 616 if (Cache.Open() == false)
1bc849af
AL
617 return false;
618
65a1e968 619 LogCleaner Cleaner;
1bc849af
AL
620
621 return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
622 Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
623}
624 /*}}}*/
0e3e112e
MV
625// DoDownload - download a binary /*{{{*/
626// ---------------------------------------------------------------------
c3ccac92 627static bool DoDownload(CommandLine &CmdL)
0e3e112e
MV
628{
629 CacheFile Cache;
630 if (Cache.ReadOnlyOpen() == false)
631 return false;
d57f6084 632
0e3e112e 633 APT::CacheSetHelper helper(c0out);
8f3594c3
MV
634 APT::VersionSet verset = APT::VersionSet::FromCommandLine(Cache,
635 CmdL.FileList + 1, APT::VersionSet::CANDIDATE, helper);
0e3e112e
MV
636
637 if (verset.empty() == true)
638 return false;
639
d57f6084 640 AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet", 0));
42d41ddb 641 pkgAcquire Fetcher;
d57f6084
DK
642 if (Fetcher.Setup(&Stat) == false)
643 return false;
42d41ddb 644
0e3e112e
MV
645 pkgRecords Recs(Cache);
646 pkgSourceList *SrcList = Cache.GetSourceList();
567785b9 647
d57f6084
DK
648 // reuse the usual acquire methods for deb files, but don't drop them into
649 // the usual directories - keep everything in the current directory
650 std::vector<std::string> storefile(verset.size());
651 std::string const cwd = SafeGetCWD();
652 _config->Set("Dir::Cache::Archives", cwd);
653 int i = 0;
8f3594c3 654 for (APT::VersionSet::const_iterator Ver = verset.begin();
d57f6084 655 Ver != verset.end(); ++Ver, ++i)
0e3e112e 656 {
d57f6084
DK
657 pkgAcquire::Item *I = new pkgAcqArchive(&Fetcher, SrcList, &Recs, *Ver, storefile[i]);
658 std::string const filename = cwd + flNotDir(storefile[i]);
659 storefile[i].assign(filename);
660 I->DestFile.assign(filename);
0e3e112e
MV
661 }
662
42d41ddb
DK
663 // Just print out the uris and exit if the --print-uris flag was used
664 if (_config->FindB("APT::Get::Print-URIs") == true)
665 {
666 pkgAcquire::UriIterator I = Fetcher.UriBegin();
f7f0d6c7 667 for (; I != Fetcher.UriEnd(); ++I)
d57f6084 668 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
42d41ddb
DK
669 I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
670 return true;
671 }
672
d57f6084
DK
673 if (_error->PendingError() == true || CheckAuth(Fetcher, false) == false)
674 return false;
675
676 bool Failed = false;
677 if (AcquireRun(Fetcher, 0, &Failed, NULL) == false)
678 return false;
679
680 // copy files in local sources to the current directory
681 for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
6ae22905
MV
682 {
683 std::string const filename = cwd + flNotDir((*I)->DestFile);
684 if ((*I)->Local == true &&
685 filename != (*I)->DestFile &&
686 (*I)->Status == pkgAcquire::Item::StatDone)
d57f6084 687 {
d57f6084
DK
688 std::ifstream src((*I)->DestFile.c_str(), std::ios::binary);
689 std::ofstream dst(filename.c_str(), std::ios::binary);
690 dst << src.rdbuf();
691 }
6ae22905 692 }
d57f6084 693 return Failed == false;
0e3e112e
MV
694}
695 /*}}}*/
0a8e3465
AL
696// DoCheck - Perform the check operation /*{{{*/
697// ---------------------------------------------------------------------
698/* Opening automatically checks the system, this command is mostly used
699 for debugging */
65512241 700static bool DoCheck(CommandLine &)
0a8e3465
AL
701{
702 CacheFile Cache;
703 Cache.Open();
2d11135a 704 Cache.CheckDeps();
0a8e3465
AL
705
706 return true;
707}
708 /*}}}*/
36375005
AL
709// DoSource - Fetch a source archive /*{{{*/
710// ---------------------------------------------------------------------
2d11135a 711/* Fetch souce packages */
fb0ee66e
AL
712struct DscFile
713{
714 string Package;
715 string Version;
716 string Dsc;
717};
718
c3ccac92 719static bool DoSource(CommandLine &CmdL)
36375005
AL
720{
721 CacheFile Cache;
2d11135a 722 if (Cache.Open(false) == false)
36375005
AL
723 return false;
724
2d11135a 725 if (CmdL.FileSize() <= 1)
b2e465d6 726 return _error->Error(_("Must specify at least one package to fetch source for"));
2d11135a 727
36375005 728 // Read the source list
1bb8cd67
DK
729 if (Cache.BuildSourceList() == false)
730 return false;
731 pkgSourceList *List = Cache.GetSourceList();
36375005
AL
732
733 // Create the text record parsers
734 pkgRecords Recs(Cache);
1bb8cd67 735 pkgSrcRecords SrcRecs(*List);
36375005
AL
736 if (_error->PendingError() == true)
737 return false;
738
739 // Create the download object
740 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1cd1c398 741 pkgAcquire Fetcher;
4a53151a 742 Fetcher.SetLog(&Stat);
fb0ee66e 743
500dc070 744 SPtrArray<DscFile> Dsc = new DscFile[CmdL.FileSize()];
36375005 745
092ae175
MV
746 // insert all downloaded uris into this set to avoid downloading them
747 // twice
748 set<string> queued;
8545b536
DK
749
750 // Diff only mode only fetches .diff files
751 bool const diffOnly = _config->FindB("APT::Get::Diff-Only", false);
752 // Tar only mode only fetches .tar files
753 bool const tarOnly = _config->FindB("APT::Get::Tar-Only", false);
754 // Dsc only mode only fetches .dsc files
755 bool const dscOnly = _config->FindB("APT::Get::Dsc-Only", false);
756
36375005 757 // Load the requestd sources into the fetcher
fb0ee66e 758 unsigned J = 0;
a3f1d60c 759 std::string UntrustedList;
fb0ee66e 760 for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
36375005
AL
761 {
762 string Src;
7014e148 763 pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,Cache);
36375005 764
6070a346 765 if (Last == 0) {
b2e465d6 766 return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
6070a346 767 }
a3f1d60c
MV
768
769 if (Last->Index().IsTrusted() == false)
770 UntrustedList += Src + " ";
36375005 771
3238423f
MV
772 string srec = Last->AsStr();
773 string::size_type pos = srec.find("\nVcs-");
774a6687 774 while (pos != string::npos)
3238423f
MV
775 {
776 pos += strlen("\nVcs-");
777 string vcs = srec.substr(pos,srec.find(":",pos)-pos);
774a6687
MV
778 if(vcs == "Browser")
779 {
780 pos = srec.find("\nVcs-", pos);
781 continue;
782 }
3238423f
MV
783 pos += vcs.length()+2;
784 string::size_type epos = srec.find("\n", pos);
785 string uri = srec.substr(pos,epos-pos).c_str();
b799e134 786 ioprintf(c1out, _("NOTICE: '%s' packaging is maintained in "
3238423f 787 "the '%s' version control system at:\n"
8756297c 788 "%s\n"),
3238423f
MV
789 Src.c_str(), vcs.c_str(), uri.c_str());
790 if(vcs == "Bzr")
927677f0 791 ioprintf(c1out,_("Please use:\n"
f3e3a2d4 792 "bzr branch %s\n"
3d513bbd 793 "to retrieve the latest (possibly unreleased) "
b799e134 794 "updates to the package.\n"),
3238423f 795 uri.c_str());
b799e134 796 break;
3238423f
MV
797 }
798
36375005
AL
799 // Back track
800 vector<pkgSrcRecords::File> Lst;
6070a346 801 if (Last->Files(Lst) == false) {
36375005 802 return false;
6070a346 803 }
36375005
AL
804
805 // Load them into the fetcher
806 for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
f7f0d6c7 807 I != Lst.end(); ++I)
36375005
AL
808 {
809 // Try to guess what sort of file it is we are getting.
b2e465d6 810 if (I->Type == "dsc")
fb0ee66e 811 {
fb0ee66e
AL
812 Dsc[J].Package = Last->Package();
813 Dsc[J].Version = Last->Version();
814 Dsc[J].Dsc = flNotDir(I->Path);
815 }
092ae175 816
8545b536
DK
817 // Handle the only options so that multiple can be used at once
818 if (diffOnly == true || tarOnly == true || dscOnly == true)
819 {
820 if ((diffOnly == true && I->Type == "diff") ||
821 (tarOnly == true && I->Type == "tar") ||
822 (dscOnly == true && I->Type == "dsc"))
823 ; // Fine, we want this file downloaded
824 else
825 continue;
826 }
1979e742 827
092ae175
MV
828 // don't download the same uri twice (should this be moved to
829 // the fetcher interface itself?)
830 if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
831 continue;
832 queued.insert(Last->Index().ArchiveURI(I->Path));
cb6a2b3e 833
092ae175 834 // check if we have a file with that md5 sum already localy
1262d358
DK
835 std::string localFile = flNotDir(I->Path);
836 if (FileExists(localFile) == true)
837 if(I->Hashes.VerifyFile(localFile) == true)
092ae175 838 {
443cb67c 839 ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
1262d358 840 localFile.c_str());
092ae175
MV
841 continue;
842 }
1262d358
DK
843
844 // see if we have a hash (Acquire::ForceHash is the only way to have none)
b3501edb 845 if (I->Hashes.usable() == false && _config->FindB("APT::Get::AllowUnauthenticated",false) == false)
1262d358
DK
846 {
847 ioprintf(c1out, "Skipping download of file '%s' as requested hashsum is not available for authentication\n",
848 localFile.c_str());
849 continue;
092ae175
MV
850 }
851
b2e465d6 852 new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
b3501edb 853 I->Hashes, I->Size, Last->Index().SourceInfo(*Last,*I), Src);
36375005
AL
854 }
855 }
a3f1d60c
MV
856
857 // check authentication status of the source as well
858 if (UntrustedList != "" && !AuthPrompt(UntrustedList, false))
859 return false;
36375005
AL
860
861 // Display statistics
3a882565
DK
862 unsigned long long FetchBytes = Fetcher.FetchNeeded();
863 unsigned long long FetchPBytes = Fetcher.PartialPresent();
864 unsigned long long DebBytes = Fetcher.TotalNeeded();
36375005
AL
865
866 // Check for enough free space
f332b62b 867 struct statvfs Buf;
36375005 868 string OutputDir = ".";
c1ce032a
DK
869 if (statvfs(OutputDir.c_str(),&Buf) != 0) {
870 if (errno == EOVERFLOW)
871 return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
872 OutputDir.c_str());
873 else
874 return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
875 OutputDir.c_str());
876 } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
885d204b
OS
877 {
878 struct statfs Stat;
f64196e8
DK
879 if (statfs(OutputDir.c_str(),&Stat) != 0
880#if HAVE_STRUCT_STATFS_F_TYPE
881 || unsigned(Stat.f_type) != RAMFS_MAGIC
882#endif
6070a346 883 ) {
885d204b
OS
884 return _error->Error(_("You don't have enough free space in %s"),
885 OutputDir.c_str());
6070a346
DK
886 }
887 }
36375005
AL
888
889 // Number of bytes
36375005 890 if (DebBytes != FetchBytes)
4d8d8112
DK
891 //TRANSLATOR: The required space between number and unit is already included
892 // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
b2e465d6
AL
893 ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
894 SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
36375005 895 else
4d8d8112
DK
896 //TRANSLATOR: The required space between number and unit is already included
897 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
b2e465d6
AL
898 ioprintf(c1out,_("Need to get %sB of source archives.\n"),
899 SizeToStr(DebBytes).c_str());
900
2c0c53b3
AL
901 if (_config->FindB("APT::Get::Simulate",false) == true)
902 {
903 for (unsigned I = 0; I != J; I++)
db0db9fe 904 ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
2c0c53b3
AL
905 return true;
906 }
907
36375005
AL
908 // Just print out the uris an exit if the --print-uris flag was used
909 if (_config->FindB("APT::Get::Print-URIs") == true)
910 {
911 pkgAcquire::UriIterator I = Fetcher.UriBegin();
f7f0d6c7 912 for (; I != Fetcher.UriEnd(); ++I)
36375005 913 cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
495e5cb2 914 I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
36375005
AL
915 return true;
916 }
36375005 917
866893a6 918 // Run it
fb0ee66e 919 bool Failed = false;
866893a6 920 if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
6070a346 921 {
b2e465d6 922 return _error->Error(_("Failed to fetch some archives."));
6070a346
DK
923 }
924
fb0ee66e 925 if (_config->FindB("APT::Get::Download-only",false) == true)
b2e465d6
AL
926 {
927 c1out << _("Download complete and in download only mode") << endl;
fb0ee66e 928 return true;
b2e465d6
AL
929 }
930
fb0ee66e 931 // Unpack the sources
54676e1a
AL
932 pid_t Process = ExecFork();
933
934 if (Process == 0)
fb0ee66e 935 {
827d04d3 936 bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
f7f0d6c7 937 for (unsigned I = 0; I != J; ++I)
fb0ee66e 938 {
b2e465d6 939 string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
fb0ee66e 940
17c0e8e1
AL
941 // Diff only mode only fetches .diff files
942 if (_config->FindB("APT::Get::Diff-Only",false) == true ||
a3eaf954
AL
943 _config->FindB("APT::Get::Tar-Only",false) == true ||
944 Dsc[I].Dsc.empty() == true)
17c0e8e1 945 continue;
a3eaf954 946
54676e1a
AL
947 // See if the package is already unpacked
948 struct stat Stat;
827d04d3 949 if (fixBroken == false && stat(Dir.c_str(),&Stat) == 0 &&
54676e1a
AL
950 S_ISDIR(Stat.st_mode) != 0)
951 {
b2e465d6
AL
952 ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
953 Dir.c_str());
54676e1a
AL
954 }
955 else
956 {
957 // Call dpkg-source
958 char S[500];
959 snprintf(S,sizeof(S),"%s -x %s",
960 _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
961 Dsc[I].Dsc.c_str());
962 if (system(S) != 0)
963 {
b2e465d6 964 fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
14cd494a 965 fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
54676e1a
AL
966 _exit(1);
967 }
968 }
969
970 // Try to compile it with dpkg-buildpackage
971 if (_config->FindB("APT::Get::Compile",false) == true)
972 {
234675b7
DK
973 string buildopts = _config->Find("APT::Get::Host-Architecture");
974 if (buildopts.empty() == false)
c5102538 975 buildopts = "-a" + buildopts + " ";
ce7f128c
DK
976
977 // get all active build profiles
978 std::string const profiles = APT::Configuration::getBuildProfilesString();
979 if (profiles.empty() == false)
980 buildopts.append(" -P").append(profiles).append(" ");
981
234675b7
DK
982 buildopts.append(_config->Find("DPkg::Build-Options","-b -uc"));
983
54676e1a
AL
984 // Call dpkg-buildpackage
985 char S[500];
986 snprintf(S,sizeof(S),"cd %s && %s %s",
987 Dir.c_str(),
988 _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
234675b7 989 buildopts.c_str());
54676e1a
AL
990
991 if (system(S) != 0)
992 {
b2e465d6 993 fprintf(stderr,_("Build command '%s' failed.\n"),S);
54676e1a
AL
994 _exit(1);
995 }
996 }
997 }
998
999 _exit(0);
1000 }
3a4477a4 1001
54676e1a
AL
1002 // Wait for the subprocess
1003 int Status = 0;
1004 while (waitpid(Process,&Status,0) != Process)
1005 {
1006 if (errno == EINTR)
1007 continue;
1008 return _error->Errno("waitpid","Couldn't wait for subprocess");
1009 }
1010
1011 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
b2e465d6
AL
1012 return _error->Error(_("Child process failed"));
1013
1014 return true;
1015}
1016 /*}}}*/
1017// DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/
1018// ---------------------------------------------------------------------
1019/* This function will look at the build depends list of the given source
1020 package and install the necessary packages to make it true, or fail. */
c3ccac92 1021static bool DoBuildDep(CommandLine &CmdL)
b2e465d6
AL
1022{
1023 CacheFile Cache;
35180212
JAK
1024
1025 _config->Set("APT::Install-Recommends", false);
1026
b2e465d6
AL
1027 if (Cache.Open(true) == false)
1028 return false;
1029
1030 if (CmdL.FileSize() <= 1)
1031 return _error->Error(_("Must specify at least one package to check builddeps for"));
1032
1033 // Read the source list
1bb8cd67
DK
1034 if (Cache.BuildSourceList() == false)
1035 return false;
1036 pkgSourceList *List = Cache.GetSourceList();
54676e1a 1037
b2e465d6
AL
1038 // Create the text record parsers
1039 pkgRecords Recs(Cache);
1bb8cd67 1040 pkgSrcRecords SrcRecs(*List);
b2e465d6
AL
1041 if (_error->PendingError() == true)
1042 return false;
1043
1044 // Create the download object
1045 AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1cd1c398
DK
1046 pkgAcquire Fetcher;
1047 if (Fetcher.Setup(&Stat) == false)
1048 return false;
b2e465d6 1049
234675b7
DK
1050 bool StripMultiArch;
1051 string hostArch = _config->Find("APT::Get::Host-Architecture");
1052 if (hostArch.empty() == false)
1053 {
1054 std::vector<std::string> archs = APT::Configuration::getArchitectures();
1055 if (std::find(archs.begin(), archs.end(), hostArch) == archs.end())
1056 return _error->Error(_("No architecture information available for %s. See apt.conf(5) APT::Architectures for setup"), hostArch.c_str());
1057 StripMultiArch = false;
1058 }
1059 else
1060 StripMultiArch = true;
1061
b2e465d6
AL
1062 unsigned J = 0;
1063 for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
1064 {
1065 string Src;
feab34c5 1066 pkgSrcRecords::Parser *Last = 0;
feab34c5 1067
a5bb5e1e
MV
1068 // an unpacked debian source tree
1069 using APT::String::Startswith;
1070 if ((Startswith(*I, "./") || Startswith(*I, "/")) &&
1071 DirectoryExists(*I))
77da39b9 1072 {
a5bb5e1e 1073 ioprintf(c1out, _("Note, using directory '%s' to get the build dependencies\n"), *I);
77da39b9
MV
1074 // FIXME: how can we make this more elegant?
1075 std::string TypeName = "debian/control File Source Index";
1076 pkgIndexFile::Type *Type = pkgIndexFile::Type::GetType(TypeName.c_str());
1077 if(Type != NULL)
1078 Last = Type->CreateSrcPkgParser(*I);
1079 }
a49e7948 1080 // if its a local file (e.g. .dsc) use this
77da39b9 1081 else if (FileExists(*I))
feab34c5 1082 {
a5bb5e1e
MV
1083 ioprintf(c1out, _("Note, using file '%s' to get the build dependencies\n"), *I);
1084
a49e7948
MV
1085 // see if we can get a parser for this pkgIndexFile type
1086 string TypeName = flExtension(*I) + " File Source Index";
1087 pkgIndexFile::Type *Type = pkgIndexFile::Type::GetType(TypeName.c_str());
1088 if(Type != NULL)
1089 Last = Type->CreateSrcPkgParser(*I);
feab34c5 1090 } else {
a49e7948 1091 // normal case, search the cache for the source file
feab34c5
MV
1092 Last = FindSrc(*I,Recs,SrcRecs,Src,Cache);
1093 }
a49e7948 1094
b2e465d6
AL
1095 if (Last == 0)
1096 return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
1097
1098 // Process the build-dependencies
1099 vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
65f99834
DK
1100 // FIXME: Can't specify architecture to use for [wildcard] matching, so switch default arch temporary
1101 if (hostArch.empty() == false)
1102 {
1103 std::string nativeArch = _config->Find("APT::Architecture");
1104 _config->Set("APT::Architecture", hostArch);
1105 bool Success = Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch);
1106 _config->Set("APT::Architecture", nativeArch);
1107 if (Success == false)
1108 return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
1109 }
1110 else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
1111 return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
feab34c5 1112
7d6f9f8f
AL
1113 // Also ensure that build-essential packages are present
1114 Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
1115 if (Opts)
1116 Opts = Opts->Child;
1117 for (; Opts; Opts = Opts->Next)
1118 {
1119 if (Opts->Value.empty() == true)
1120 continue;
1121
1122 pkgSrcRecords::Parser::BuildDepRec rec;
1123 rec.Package = Opts->Value;
1124 rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
1125 rec.Op = 0;
58d76831 1126 BuildDeps.push_back(rec);
7d6f9f8f
AL
1127 }
1128
f7f0d6c7 1129 if (BuildDeps.empty() == true)
b2e465d6
AL
1130 {
1131 ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
1132 continue;
1133 }
234675b7 1134
b2e465d6 1135 // Install the requested packages
b2e465d6
AL
1136 vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
1137 pkgProblemResolver Fix(Cache);
58d76831 1138 bool skipAlternatives = false; // skip remaining alternatives in an or group
f7f0d6c7 1139 for (D = BuildDeps.begin(); D != BuildDeps.end(); ++D)
b2e465d6 1140 {
58d76831
AL
1141 bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
1142
1143 if (skipAlternatives == true)
1144 {
3fdb6f83
DK
1145 /*
1146 * if there are alternatives, we've already picked one, so skip
1147 * the rest
1148 *
1149 * TODO: this means that if there's a build-dep on A|B and B is
1150 * installed, we'll still try to install A; more importantly,
1151 * if A is currently broken, we cannot go back and try B. To fix
1152 * this would require we do a Resolve cycle for each package we
1153 * add to the install list. Ugh
1154 */
58d76831
AL
1155 if (!hasAlternatives)
1156 skipAlternatives = false; // end of or group
1157 continue;
1158 }
1159
aa2d22be
AL
1160 if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
1161 (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
d3fc0061 1162 {
e3a86238 1163 pkgCache::GrpIterator Grp = Cache->FindGrp((*D).Package);
aa2d22be 1164 // Build-conflicts on unknown packages are silently ignored
e3a86238 1165 if (Grp.end() == true)
aa2d22be
AL
1166 continue;
1167
e3a86238
DK
1168 for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1169 {
1170 pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
1171 /*
1172 * Remove if we have an installed version that satisfies the
1173 * version criteria
1174 */
1175 if (IV.end() == false &&
1176 Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
1177 TryToInstallBuildDep(Pkg,Cache,Fix,true,false);
1178 }
d3fc0061 1179 }
aa2d22be
AL
1180 else // BuildDep || BuildDepIndep
1181 {
58d76831
AL
1182 if (_config->FindB("Debug::BuildDeps",false) == true)
1183 cout << "Looking for " << (*D).Package << "...\n";
1184
234675b7
DK
1185 pkgCache::PkgIterator Pkg;
1186
1187 // Cross-Building?
c307a4f0 1188 if (StripMultiArch == false && D->Type != pkgSrcRecords::Parser::BuildDependIndep)
234675b7
DK
1189 {
1190 size_t const colon = D->Package.find(":");
666faa35
DK
1191 if (colon != string::npos)
1192 {
1193 if (strcmp(D->Package.c_str() + colon, ":any") == 0 || strcmp(D->Package.c_str() + colon, ":native") == 0)
1194 Pkg = Cache->FindPkg(D->Package.substr(0,colon));
1195 else
1196 Pkg = Cache->FindPkg(D->Package);
1197 }
234675b7 1198 else
666faa35 1199 Pkg = Cache->FindPkg(D->Package, hostArch);
234675b7 1200
234675b7 1201 // a bad version either is invalid or doesn't satify dependency
d5dea0be
DK
1202 #define BADVER(Ver) (Ver.end() == true || \
1203 (D->Version.empty() == false && \
1204 Cache->VS().CheckDep(Ver.VerStr(),D->Op,D->Version.c_str()) == false))
234675b7 1205
d5dea0be 1206 APT::VersionList verlist;
234675b7
DK
1207 if (Pkg.end() == false)
1208 {
d5dea0be
DK
1209 pkgCache::VerIterator Ver = (*Cache)[Pkg].InstVerIter(*Cache);
1210 if (BADVER(Ver) == false)
1211 verlist.insert(Ver);
1212 Ver = (*Cache)[Pkg].CandidateVerIter(*Cache);
1213 if (BADVER(Ver) == false)
1214 verlist.insert(Ver);
234675b7 1215 }
d5dea0be 1216 if (verlist.empty() == true)
234675b7 1217 {
666faa35
DK
1218 pkgCache::PkgIterator BuildPkg = Cache->FindPkg(D->Package, "native");
1219 if (BuildPkg.end() == false && Pkg != BuildPkg)
234675b7 1220 {
666faa35 1221 pkgCache::VerIterator Ver = (*Cache)[BuildPkg].InstVerIter(*Cache);
d5dea0be
DK
1222 if (BADVER(Ver) == false)
1223 verlist.insert(Ver);
666faa35 1224 Ver = (*Cache)[BuildPkg].CandidateVerIter(*Cache);
d5dea0be
DK
1225 if (BADVER(Ver) == false)
1226 verlist.insert(Ver);
234675b7
DK
1227 }
1228 }
d5dea0be
DK
1229 #undef BADVER
1230
1231 string forbidden;
1232 // We need to decide if host or build arch, so find a version we can look at
1233 APT::VersionList::const_iterator Ver = verlist.begin();
1234 for (; Ver != verlist.end(); ++Ver)
234675b7 1235 {
d5dea0be 1236 forbidden.clear();
737c7a7b
SL
1237 if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All)
1238 {
1239 if (colon == string::npos)
737c7a7b 1240 Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
a9a370d9
TG
1241 else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1242 forbidden = "Multi-Arch: none";
666faa35
DK
1243 else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1244 Pkg = Ver.ParentPkg().Group().FindPkg("native");
737c7a7b 1245 }
234675b7
DK
1246 else if (Ver->MultiArch == pkgCache::Version::Same)
1247 {
737c7a7b 1248 if (colon == string::npos)
234675b7
DK
1249 Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1250 else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1251 forbidden = "Multi-Arch: same";
666faa35
DK
1252 else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1253 Pkg = Ver.ParentPkg().Group().FindPkg("native");
234675b7 1254 }
2a2a7ef4 1255 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
234675b7 1256 {
666faa35
DK
1257 if (colon == string::npos)
1258 Pkg = Ver.ParentPkg().Group().FindPkg("native");
1259 else if (strcmp(D->Package.c_str() + colon, ":any") == 0 ||
1260 strcmp(D->Package.c_str() + colon, ":native") == 0)
234675b7
DK
1261 forbidden = "Multi-Arch: foreign";
1262 }
2a2a7ef4 1263 else if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
234675b7
DK
1264 {
1265 if (colon == string::npos)
1266 Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1267 else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1268 {
1269 // prefer any installed over preferred non-installed architectures
1270 pkgCache::GrpIterator Grp = Ver.ParentPkg().Group();
1271 // we don't check for version here as we are better of with upgrading than remove and install
1272 for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1273 if (Pkg.CurrentVer().end() == false)
1274 break;
1275 if (Pkg.end() == true)
1276 Pkg = Grp.FindPreferredPkg(true);
1277 }
666faa35
DK
1278 else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1279 Pkg = Ver.ParentPkg().Group().FindPkg("native");
234675b7 1280 }
d5dea0be 1281
234675b7
DK
1282 if (forbidden.empty() == false)
1283 {
1284 if (_config->FindB("Debug::BuildDeps",false) == true)
d5dea0be
DK
1285 cout << D->Package.substr(colon, string::npos) << " is not allowed from " << forbidden << " package " << (*D).Package << " (" << Ver.VerStr() << ")" << endl;
1286 continue;
1287 }
1288
1289 //we found a good version
1290 break;
1291 }
1292 if (Ver == verlist.end())
1293 {
1294 if (_config->FindB("Debug::BuildDeps",false) == true)
1295 cout << " No multiarch info as we have no satisfying installed nor candidate for " << D->Package << " on build or host arch" << endl;
1296
1297 if (forbidden.empty() == false)
1298 {
234675b7
DK
1299 if (hasAlternatives)
1300 continue;
1301 return _error->Error(_("%s dependency for %s can't be satisfied "
1302 "because %s is not allowed on '%s' packages"),
1303 Last->BuildDepType(D->Type), Src.c_str(),
a9a370d9 1304 D->Package.c_str(), forbidden.c_str());
234675b7
DK
1305 }
1306 }
234675b7
DK
1307 }
1308 else
1309 Pkg = Cache->FindPkg(D->Package);
1310
727d8712 1311 if (Pkg.end() == true || (Pkg->VersionList == 0 && Pkg->ProvidesList == 0))
aa2d22be 1312 {
58d76831
AL
1313 if (_config->FindB("Debug::BuildDeps",false) == true)
1314 cout << " (not found)" << (*D).Package << endl;
1315
1316 if (hasAlternatives)
1317 continue;
1318
1319 return _error->Error(_("%s dependency for %s cannot be satisfied "
1320 "because the package %s cannot be found"),
1321 Last->BuildDepType((*D).Type),Src.c_str(),
1322 (*D).Package.c_str());
aa2d22be
AL
1323 }
1324
e5002e30 1325 pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
91bee655
DK
1326 if (IV.end() == false)
1327 {
1328 if (_config->FindB("Debug::BuildDeps",false) == true)
1329 cout << " Is installed\n";
e5002e30 1330
91bee655
DK
1331 if (D->Version.empty() == true ||
1332 Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
1333 {
1334 skipAlternatives = hasAlternatives;
1335 continue;
1336 }
cfa5659c 1337
91bee655
DK
1338 if (_config->FindB("Debug::BuildDeps",false) == true)
1339 cout << " ...but the installed version doesn't meet the version requirement\n";
58d76831 1340
91bee655
DK
1341 if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
1342 return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
1343 Last->BuildDepType((*D).Type), Src.c_str(), Pkg.FullName(true).c_str());
1344 }
58d76831 1345
fe027879
DK
1346 // Only consider virtual packages if there is no versioned dependency
1347 if ((*D).Version.empty() == true)
1348 {
1349 /*
1350 * If this is a virtual package, we need to check the list of
1351 * packages that provide it and see if any of those are
1352 * installed
1353 */
1354 pkgCache::PrvIterator Prv = Pkg.ProvidesList();
f7f0d6c7 1355 for (; Prv.end() != true; ++Prv)
fe027879
DK
1356 {
1357 if (_config->FindB("Debug::BuildDeps",false) == true)
1358 cout << " Checking provider " << Prv.OwnerPkg().FullName() << endl;
58d76831 1359
fe027879
DK
1360 if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
1361 break;
1362 }
58d76831 1363
fe027879
DK
1364 if (Prv.end() == false)
1365 {
1366 if (_config->FindB("Debug::BuildDeps",false) == true)
1367 cout << " Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
1368 skipAlternatives = hasAlternatives;
1369 continue;
1370 }
1371 }
2baf02ca
DK
1372 else // versioned dependency
1373 {
1374 pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
1375 if (CV.end() == true ||
1376 Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == false)
1377 {
1378 if (hasAlternatives)
1379 continue;
1380 else if (CV.end() == false)
1381 return _error->Error(_("%s dependency for %s cannot be satisfied "
1382 "because candidate version of package %s "
1383 "can't satisfy version requirements"),
1384 Last->BuildDepType(D->Type), Src.c_str(),
1385 D->Package.c_str());
1386 else
1387 return _error->Error(_("%s dependency for %s cannot be satisfied "
1388 "because package %s has no candidate version"),
1389 Last->BuildDepType(D->Type), Src.c_str(),
1390 D->Package.c_str());
1391 }
1392 }
58d76831 1393
f1f874bd 1394 if (TryToInstallBuildDep(Pkg,Cache,Fix,false,false,false) == true)
58d76831
AL
1395 {
1396 // We successfully installed something; skip remaining alternatives
1397 skipAlternatives = hasAlternatives;
d59228b0 1398 if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
496a05c6 1399 Cache->MarkAuto(Pkg, true);
58d76831
AL
1400 continue;
1401 }
1402 else if (hasAlternatives)
1403 {
1404 if (_config->FindB("Debug::BuildDeps",false) == true)
1405 cout << " Unsatisfiable, trying alternatives\n";
1406 continue;
1407 }
1408 else
1409 {
1410 return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
1411 Last->BuildDepType((*D).Type),
1412 Src.c_str(),
1413 (*D).Package.c_str());
1414 }
b2e465d6
AL
1415 }
1416 }
f3c736f9 1417
b2e465d6
AL
1418 if (Fix.Resolve(true) == false)
1419 _error->Discard();
1420
1421 // Now we check the state of the packages,
1422 if (Cache->BrokenCount() != 0)
0dae8ac5
DK
1423 {
1424 ShowBroken(cout, Cache, false);
1425 return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
1426 }
b2e465d6
AL
1427 }
1428
1429 if (InstallPackages(Cache, false, true) == false)
1430 return _error->Error(_("Failed to process build dependencies"));
36375005
AL
1431 return true;
1432}
1433 /*}}}*/
a53b07bb
MV
1434// GetChangelogPath - return a path pointing to a changelog file or dir /*{{{*/
1435// ---------------------------------------------------------------------
1436/* This returns a "path" string for the changelog url construction.
1437 * Please note that its not complete, it either needs a "/changelog"
1438 * appended (for the packages.debian.org/changelogs site) or a
1439 * ".changelog" (for third party sites that store the changelog in the
1440 * pool/ next to the deb itself)
1441 * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3"
1442 */
c3ccac92 1443static string GetChangelogPath(CacheFile &Cache,
a53b07bb
MV
1444 pkgCache::PkgIterator Pkg,
1445 pkgCache::VerIterator Ver)
1446{
1447 string path;
1448
1449 pkgRecords Recs(Cache);
1450 pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
1451 string srcpkg = rec.SourcePkg().empty() ? Pkg.Name() : rec.SourcePkg();
c5d6a22c
MV
1452 string ver = Ver.VerStr();
1453 // if there is a source version it always wins
1454 if (rec.SourceVer() != "")
1455 ver = rec.SourceVer();
a53b07bb 1456 path = flNotFile(rec.FileName());
c5d6a22c 1457 path += srcpkg + "_" + StripEpoch(ver);
a53b07bb
MV
1458 return path;
1459}
1460 /*}}}*/
cdb9307c
MV
1461// GuessThirdPartyChangelogUri - return url /*{{{*/
1462// ---------------------------------------------------------------------
a53b07bb
MV
1463/* Contruct a changelog file path for third party sites that do not use
1464 * packages.debian.org/changelogs
1465 * This simply uses the ArchiveURI() of the source pkg and looks for
1466 * a .changelog file there, Example for "mediabuntu":
1467 * apt-get changelog mplayer-doc:
1468 * http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
1469 */
c3ccac92 1470static bool GuessThirdPartyChangelogUri(CacheFile &Cache,
cdb9307c
MV
1471 pkgCache::PkgIterator Pkg,
1472 pkgCache::VerIterator Ver,
1473 string &out_uri)
1474{
cdb9307c 1475 // get the binary deb server path
cdb9307c
MV
1476 pkgCache::VerFileIterator Vf = Ver.FileList();
1477 if (Vf.end() == true)
1478 return false;
1479 pkgCache::PkgFileIterator F = Vf.File();
1480 pkgIndexFile *index;
a53b07bb 1481 pkgSourceList *SrcList = Cache.GetSourceList();
cdb9307c
MV
1482 if(SrcList->FindIndex(F, index) == false)
1483 return false;
a53b07bb 1484
cdb9307c 1485 // get archive uri for the binary deb
a53b07bb
MV
1486 string path_without_dot_changelog = GetChangelogPath(Cache, Pkg, Ver);
1487 out_uri = index->ArchiveURI(path_without_dot_changelog + ".changelog");
cdb9307c
MV
1488
1489 // now strip away the filename and add srcpkg_srcver.changelog
cdb9307c
MV
1490 return true;
1491}
fcb144b9 1492 /*}}}*/
a4c40430
MV
1493// DownloadChangelog - Download the changelog /*{{{*/
1494// ---------------------------------------------------------------------
c3ccac92 1495static bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher,
a53b07bb
MV
1496 pkgCache::VerIterator Ver, string targetfile)
1497/* Download a changelog file for the given package version to
1498 * targetfile. This will first try the server from Apt::Changelogs::Server
1499 * (http://packages.debian.org/changelogs by default) and if that gives
1500 * a 404 tries to get it from the archive directly (see
1501 * GuessThirdPartyChangelogUri for details how)
1502 */
a4c40430 1503{
a53b07bb 1504 string path;
a4c40430 1505 string descr;
c2991635 1506 string server;
a53b07bb 1507 string changelog_uri;
a4c40430
MV
1508
1509 // data structures we need
a53b07bb 1510 pkgCache::PkgIterator Pkg = Ver.ParentPkg();
a4c40430 1511
a53b07bb 1512 // make the server root configurable
c2991635 1513 server = _config->Find("Apt::Changelogs::Server",
a53b07bb
MV
1514 "http://packages.debian.org/changelogs");
1515 path = GetChangelogPath(CacheFile, Pkg, Ver);
1516 strprintf(changelog_uri, "%s/%s/changelog", server.c_str(), path.c_str());
fcb144b9
DK
1517 if (_config->FindB("APT::Get::Print-URIs", false) == true)
1518 {
1519 std::cout << '\'' << changelog_uri << '\'' << std::endl;
1520 return true;
1521 }
1522
88573174 1523 strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), changelog_uri.c_str());
a53b07bb 1524 // queue it
88573174 1525 new pkgAcqFile(&Fetcher, changelog_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
d786352d 1526
fcb144b9
DK
1527 // try downloading it, if that fails, try third-party-changelogs location
1528 // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
1529 Fetcher.Run();
cdb9307c
MV
1530 if (!FileExists(targetfile))
1531 {
1532 string third_party_uri;
a53b07bb 1533 if (GuessThirdPartyChangelogUri(CacheFile, Pkg, Ver, third_party_uri))
cdb9307c 1534 {
88573174
MV
1535 strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), third_party_uri.c_str());
1536 new pkgAcqFile(&Fetcher, third_party_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
fcb144b9 1537 Fetcher.Run();
cdb9307c
MV
1538 }
1539 }
4a6fe09c 1540
a4c40430 1541 if (FileExists(targetfile))
18ae8b29 1542 return true;
a4c40430
MV
1543
1544 // error
18ae8b29 1545 return _error->Error("changelog download failed");
a4c40430
MV
1546}
1547 /*}}}*/
a4c40430
MV
1548// DoChangelog - Get changelog from the command line /*{{{*/
1549// ---------------------------------------------------------------------
c3ccac92 1550static bool DoChangelog(CommandLine &CmdL)
a4c40430
MV
1551{
1552 CacheFile Cache;
1553 if (Cache.ReadOnlyOpen() == false)
1554 return false;
1555
1556 APT::CacheSetHelper helper(c0out);
c4cca791
DK
1557 APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
1558 CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
72dd5bec
DK
1559 if (verset.empty() == true)
1560 return false;
a4c40430 1561 pkgAcquire Fetcher;
fcb144b9
DK
1562
1563 if (_config->FindB("APT::Get::Print-URIs", false) == true)
a98b6615
DH
1564 {
1565 bool Success = true;
c4cca791 1566 for (APT::VersionList::const_iterator Ver = verset.begin();
fcb144b9 1567 Ver != verset.end(); ++Ver)
a98b6615
DH
1568 Success &= DownloadChangelog(Cache, Fetcher, Ver, "");
1569 return Success;
1570 }
fcb144b9 1571
8cc74fb1
MV
1572 AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
1573 Fetcher.Setup(&Stat);
a4c40430 1574
72dd5bec
DK
1575 bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
1576
1577 char tmpname[100];
68e01721 1578 const char* tmpdir = NULL;
72dd5bec
DK
1579 if (downOnly == false)
1580 {
68e01721
MV
1581 std::string systemTemp = GetTempDir();
1582 snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX",
1583 systemTemp.c_str());
72dd5bec
DK
1584 tmpdir = mkdtemp(tmpname);
1585 if (tmpdir == NULL)
1586 return _error->Errno("mkdtemp", "mkdtemp failed");
18ae8b29 1587 }
72dd5bec 1588
c4cca791 1589 for (APT::VersionList::const_iterator Ver = verset.begin();
a4c40430
MV
1590 Ver != verset.end();
1591 ++Ver)
1592 {
72dd5bec
DK
1593 string changelogfile;
1594 if (downOnly == false)
1595 changelogfile.append(tmpname).append("changelog");
1596 else
1597 changelogfile.append(Ver.ParentPkg().Name()).append(".changelog");
1598 if (DownloadChangelog(Cache, Fetcher, Ver, changelogfile) && downOnly == false)
1599 {
a4c40430 1600 DisplayFileInPager(changelogfile);
72dd5bec
DK
1601 // cleanup temp file
1602 unlink(changelogfile.c_str());
1603 }
a4c40430 1604 }
18ae8b29 1605 // clenaup tmp dir
72dd5bec
DK
1606 if (tmpdir != NULL)
1607 rmdir(tmpdir);
4a6fe09c 1608 return true;
a4c40430
MV
1609}
1610 /*}}}*/
0a8e3465
AL
1611// ShowHelp - Show a help screen /*{{{*/
1612// ---------------------------------------------------------------------
1613/* */
65512241 1614static bool ShowHelp(CommandLine &)
0a8e3465 1615{
9179f697 1616 ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
5b28c804 1617 COMMON_ARCH,__DATE__,__TIME__);
b2e465d6 1618
04aa15a8 1619 if (_config->FindB("version") == true)
b2e465d6 1620 {
db0db9fe 1621 cout << _("Supported modules:") << endl;
b2e465d6
AL
1622
1623 for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
1624 {
1625 pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
1626 if (_system != 0 && _system->VS == VS)
1627 cout << '*';
1628 else
1629 cout << ' ';
1630 cout << "Ver: " << VS->Label << endl;
1631
1632 /* Print out all the packaging systems that will work with
1633 this VS */
1634 for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
1635 {
1636 pkgSystem *Sys = pkgSystem::GlobalList[J];
1637 if (_system == Sys)
1638 cout << '*';
1639 else
1640 cout << ' ';
1641 if (Sys->VS->TestCompatibility(*VS) == true)
1642 cout << "Pkg: " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
1643 }
1644 }
1645
1646 for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
1647 {
1648 pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
1649 cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
1650 }
1651
1652 for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
1653 {
1654 pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
1655 cout << " Idx: " << Type->Label << endl;
1656 }
1657
1658 return true;
1659 }
1660
1661 cout <<
1662 _("Usage: apt-get [options] command\n"
1663 " apt-get [options] install|remove pkg1 [pkg2 ...]\n"
1664 " apt-get [options] source pkg1 [pkg2 ...]\n"
1665 "\n"
1666 "apt-get is a simple command line interface for downloading and\n"
1667 "installing packages. The most frequently used commands are update\n"
1668 "and install.\n"
1669 "\n"
1670 "Commands:\n"
1671 " update - Retrieve new lists of packages\n"
1672 " upgrade - Perform an upgrade\n"
1673 " install - Install new packages (pkg is libc6 not libc6.deb)\n"
1674 " remove - Remove packages\n"
12bffed7 1675 " autoremove - Remove automatically all unused packages\n"
73fc19d0 1676 " purge - Remove packages and config files\n"
b2e465d6
AL
1677 " source - Download source archives\n"
1678 " build-dep - Configure build-dependencies for source packages\n"
1679 " dist-upgrade - Distribution upgrade, see apt-get(8)\n"
1680 " dselect-upgrade - Follow dselect selections\n"
1681 " clean - Erase downloaded archive files\n"
1682 " autoclean - Erase old downloaded archive files\n"
1683 " check - Verify that there are no broken dependencies\n"
5f967f2d
MV
1684 " changelog - Download and display the changelog for the given package\n"
1685 " download - Download the binary package into the current directory\n"
b2e465d6
AL
1686 "\n"
1687 "Options:\n"
1688 " -h This help text.\n"
1689 " -q Loggable output - no progress indicator\n"
1690 " -qq No output except for errors\n"
1691 " -d Download only - do NOT install or unpack archives\n"
1692 " -s No-act. Perform ordering simulation\n"
1693 " -y Assume Yes to all queries and do not prompt\n"
0748d509 1694 " -f Attempt to correct a system with broken dependencies in place\n"
b2e465d6
AL
1695 " -m Attempt to continue if archives are unlocatable\n"
1696 " -u Show a list of upgraded packages as well\n"
1697 " -b Build the source package after fetching it\n"
ac625538 1698 " -V Show verbose version numbers\n"
b2e465d6 1699 " -c=? Read this configuration file\n"
a2884e32 1700 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
b2e465d6
AL
1701 "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
1702 "pages for more information and options.\n"
1703 " This APT has Super Cow Powers.\n");
1704 return true;
d7827aca
AL
1705}
1706 /*}}}*/
92fcbfc1 1707int main(int argc,const char *argv[]) /*{{{*/
0a8e3465 1708{
83d89a9f
AL
1709 CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
1710 {"upgrade",&DoUpgrade},
1711 {"install",&DoInstall},
1712 {"remove",&DoInstall},
24401c09 1713 {"purge",&DoInstall},
74a05226 1714 {"autoremove",&DoInstall},
d63a1458
JAK
1715 {"markauto",&DoMarkAuto},
1716 {"unmarkauto",&DoMarkAuto},
83d89a9f
AL
1717 {"dist-upgrade",&DoDistUpgrade},
1718 {"dselect-upgrade",&DoDSelectUpgrade},
b2e465d6 1719 {"build-dep",&DoBuildDep},
83d89a9f 1720 {"clean",&DoClean},
1bc849af 1721 {"autoclean",&DoAutoClean},
83d89a9f 1722 {"check",&DoCheck},
67111687 1723 {"source",&DoSource},
459b5f5d 1724 {"download",&DoDownload},
a4c40430 1725 {"changelog",&DoChangelog},
b2e465d6 1726 {"moo",&DoMoo},
67111687 1727 {"help",&ShowHelp},
83d89a9f 1728 {0,0}};
67111687 1729
b9179170
MV
1730 std::vector<CommandLine::Args> Args = getCommandArgs("apt-get", CommandLine::GetCommand(Cmds, argc, argv));
1731
67111687
AL
1732 // Set up gettext support
1733 setlocale(LC_ALL,"");
1734 textdomain(PACKAGE);
1735
0a8e3465 1736 // Parse the command line and initialize the package library
b9179170 1737 CommandLine CmdL(Args.data(),_config);
b2e465d6
AL
1738 if (pkgInitConfig(*_config) == false ||
1739 CmdL.Parse(argc,argv) == false ||
1740 pkgInitSystem(*_config,_system) == false)
0a8e3465 1741 {
b2e465d6
AL
1742 if (_config->FindB("version") == true)
1743 ShowHelp(CmdL);
1744
0a8e3465
AL
1745 _error->DumpErrors();
1746 return 100;
1747 }
1748
1749 // See if the help should be shown
1750 if (_config->FindB("help") == true ||
04aa15a8 1751 _config->FindB("version") == true ||
0a8e3465 1752 CmdL.FileSize() == 0)
b2e465d6
AL
1753 {
1754 ShowHelp(CmdL);
1755 return 0;
1756 }
55a5a46c 1757
b9179170
MV
1758 // see if we are in simulate mode
1759 CheckSimulateMode(CmdL);
55a5a46c 1760
3163087b
MV
1761 // Init the signals
1762 InitSignals();
1763
0a8e3465 1764 // Setup the output streams
b9179170 1765 InitOutput();
d7827aca 1766
0a8e3465 1767 // Match the operation
83d89a9f 1768 CmdL.DispatchArg(Cmds);
0a8e3465
AL
1769
1770 // Print any errors or warnings found during parsing
65beb572
DK
1771 bool const Errors = _error->PendingError();
1772 if (_config->FindI("quiet",0) > 0)
0a8e3465 1773 _error->DumpErrors();
65beb572
DK
1774 else
1775 _error->DumpErrors(GlobalError::DEBUG);
1776 return Errors == true ? 100 : 0;
0a8e3465 1777}
92fcbfc1 1778 /*}}}*/