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