// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: apt-get.cc,v 1.142 2003/09/19 03:10:01 mdz Exp $
+// $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
/* ######################################################################
apt-get - Cover for dpkg
#include <apt-pkg/version.h>
#include <apt-pkg/cachefile.h>
#include <apt-pkg/sptr.h>
+#include <apt-pkg/md5.h>
#include <apt-pkg/versionmatch.h>
#include <config.h>
#include "acqprogress.h"
+#include <set>
#include <locale.h>
#include <langinfo.h>
#include <fstream>
ostream c1out(0);
ostream c2out(0);
ofstream devnull("/dev/null");
-unsigned int ScreenWidth = 80;
+unsigned int ScreenWidth = 80 - 1; /* - 1 for the cursor */
// class CacheFile - Cover class for some dependency cache functions /*{{{*/
// ---------------------------------------------------------------------
// YnPrompt - Yes No Prompt. /*{{{*/
// ---------------------------------------------------------------------
/* Returns true on a Yes.*/
-bool YnPrompt()
+bool YnPrompt(bool Default=true)
{
if (_config->FindB("APT::Get::Assume-Yes",false) == true)
{
return false;
if (strlen(response) == 0)
- return true;
+ return Default;
regex_t Pattern;
int Res;
// Compute a single dependency element (glob or)
pkgCache::DepIterator Start;
pkgCache::DepIterator End;
- D.GlobOr(Start,End);
+ D.GlobOr(Start,End); // advances D
if (Cache->IsImportantDep(End) == false)
continue;
List += string(I.Name()) + " ";
VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
}
- ShowList(out,_("The following packages have been kept back"),List,VersionsList);
+ ShowList(out,_("The following packages have been kept back:"),List,VersionsList);
}
/*}}}*/
// ShowUpgraded - Show upgraded packages /*{{{*/
List += string(I.Name()) + " ";
VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
}
- ShowList(out,_("The following packages will be upgraded"),List,VersionsList);
+ ShowList(out,_("The following packages will be upgraded:"),List,VersionsList);
}
/*}}}*/
// ShowDowngraded - Show downgraded packages /*{{{*/
List += string(I.Name()) + " ";
VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
}
- return ShowList(out,_("The following packages will be DOWNGRADED"),List,VersionsList);
+ return ShowList(out,_("The following packages will be DOWNGRADED:"),List,VersionsList);
}
/*}}}*/
// ShowHold - Show held but changed packages /*{{{*/
}
delete [] Added;
- return ShowList(out,_("WARNING: The following essential packages will be removed\n"
+ return ShowList(out,_("WARNING: The following essential packages will be removed.\n"
"This should NOT be done unless you know exactly what you are doing!"),List,VersionsList);
}
+
/*}}}*/
// Stats - Show some statistics /*{{{*/
// ---------------------------------------------------------------------
// Check that the system is OK
if (DCache->DelCount() != 0 || DCache->InstCount() != 0)
- return _error->Error("Internal Error, non-zero counts");
+ return _error->Error("Internal error, non-zero counts");
// Apply corrections for half-installed packages
if (pkgApplyStatus(*DCache) == false)
return true;
}
+
+static bool CheckAuth(pkgAcquire& Fetcher)
+{
+ string UntrustedList;
+ for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd(); ++I)
+ {
+ if (!(*I)->IsTrusted())
+ {
+ UntrustedList += string((*I)->ShortDesc()) + " ";
+ }
+ }
+
+ if (UntrustedList == "")
+ {
+ return true;
+ }
+
+ ShowList(c2out,_("WARNING: The following packages cannot be authenticated!"),UntrustedList,"");
+
+ if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
+ {
+ c2out << _("Authentication warning overridden.\n");
+ return true;
+ }
+
+ if (_config->FindI("quiet",0) < 2
+ && _config->FindB("APT::Get::Assume-Yes",false) == false)
+ {
+ c2out << _("Install these packages without verification [y/N]? ") << flush;
+ if (!YnPrompt(false))
+ return _error->Error(_("Some packages could not be authenticated"));
+
+ return true;
+ }
+ else if (_config->FindB("APT::Get::Force-Yes",false) == true)
+ {
+ return true;
+ }
+
+ return _error->Error(_("There are problems and -y was used without --force-yes"));
+}
+
+
/*}}}*/
// InstallPackages - Actually download and install the packages /*{{{*/
/* This displays the informative messages describing what is going to
happen and then calls the download routines */
bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
- bool Saftey = true)
+ bool Safety = true)
{
if (_config->FindB("APT::Get::Purge",false) == true)
{
Essential = !ShowEssential(c1out,Cache);
Fail |= Essential;
Stats(c1out,Cache);
-
+
// Sanity check
if (Cache->BrokenCount() != 0)
{
ShowBroken(c1out,Cache,false);
- return _error->Error("Internal Error, InstallPackages was called with broken packages!");
+ return _error->Error(_("Internal error, InstallPackages was called with broken packages!"));
}
if (Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
// No remove flag
if (Cache->DelCount() != 0 && _config->FindB("APT::Get::Remove",true) == false)
- return _error->Error(_("Packages need to be removed but Remove is disabled."));
+ return _error->Error(_("Packages need to be removed but remove is disabled."));
// Run the simulator ..
if (_config->FindB("APT::Get::Simulate") == true)
{
pkgSimulate PM(Cache);
- pkgPackageManager::OrderResult Res = PM.DoInstall();
+ int status_fd = _config->FindI("APT::Status-Fd",-1);
+ pkgPackageManager::OrderResult Res = PM.DoInstall(status_fd);
if (Res == pkgPackageManager::Failed)
return false;
if (Res != pkgPackageManager::Completed)
- return _error->Error("Internal Error, Ordering didn't finish");
+ return _error->Error(_("Internal error, Ordering didn't finish"));
return true;
}
if (DebBytes != Cache->DebSize())
{
c0out << DebBytes << ',' << Cache->DebSize() << endl;
- c0out << "How odd.. The sizes didn't match, email apt@packages.debian.org" << endl;
+ c0out << _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl;
}
// Number of bytes
struct statvfs Buf;
string OutputDir = _config->FindDir("Dir::Cache::Archives");
if (statvfs(OutputDir.c_str(),&Buf) != 0)
- return _error->Errno("statvfs","Couldn't determine free space in %s",
+ return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
OutputDir.c_str());
if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
return _error->Error(_("You don't have enough free space in %s."),
return _error->Error(_("There are problems and -y was used without --force-yes"));
}
- if (Essential == true && Saftey == true)
+ if (Essential == true && Safety == true)
{
if (_config->FindB("APT::Get::Trivial-Only",false) == true)
return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
const char *Prompt = _("Yes, do as I say!");
ioprintf(c2out,
- _("You are about to do something potentially harmful\n"
+ _("You are about to do something potentially harmful.\n"
"To continue type in the phrase '%s'\n"
" ?] "),Prompt);
c2out << flush;
if (_config->FindI("quiet",0) < 2 &&
_config->FindB("APT::Get::Assume-Yes",false) == false)
{
- c2out << _("Do you want to continue? [Y/n] ") << flush;
+ c2out << _("Do you want to continue [Y/n]? ") << flush;
if (YnPrompt() == false)
{
return true;
}
+ if (!CheckAuth(Fetcher))
+ return false;
+
/* Unlock the dpkg lock if we are not going to be doing an install
after. */
if (_config->FindB("APT::Get::Download-Only",false) == true)
if (Failed == true && PM->FixMissing() == false)
{
cerr << _("Unable to correct missing packages.") << endl;
- return _error->Error(_("Aborting Install."));
+ return _error->Error(_("Aborting install."));
}
_system->UnLock();
- pkgPackageManager::OrderResult Res = PM->DoInstall();
+ int status_fd = _config->FindI("APT::Status-Fd",-1);
+ pkgPackageManager::OrderResult Res = PM->DoInstall(status_fd);
if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
return false;
if (Res == pkgPackageManager::Completed)
else
{
ioprintf(c1out,
- _("Package %s has no available version, but exists in the database.\n"
- "This typically means that the package was mentioned in a dependency and\n"
- "never uploaded, has been obsoleted or is not available with the contents\n"
- "of sources.list\n"),Pkg.Name());
+ _("Package %s is not available, but is referred to by another package.\n"
+ "This may mean that the package is missing, has been obsoleted, or\n"
+ "is only available from another source\n"),Pkg.Name());
string List;
string VersionsList;
string VerTag;
string TmpSrc = Name;
string::size_type Slash = TmpSrc.rfind('=');
+
+ // honor default release
+ string DefRel = _config->Find("APT::Default-Release");
+ pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
+
if (Slash != string::npos)
{
VerTag = string(TmpSrc.begin() + Slash + 1,TmpSrc.end());
TmpSrc = string(TmpSrc.begin(),TmpSrc.begin() + Slash);
+ }
+ else if(!Pkg.end() && DefRel.empty() == false)
+ {
+ // we have a default release, try to locate the pkg. we do it like
+ // this because GetCandidateVer() will not "downgrade", that means
+ // "apt-get source -t stable apt" won't work on a unstable system
+ for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false;
+ Ver++)
+ {
+ for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false;
+ VF++)
+ {
+ /* If this is the status file, and the current version is not the
+ version in the status file (ie it is not installed, or somesuch)
+ then it is not a candidate for installation, ever. This weeds
+ out bogus entries that may be due to config-file states, or
+ other. */
+ if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
+ pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
+ continue;
+
+ //std::cout << VF.File().Archive() << std::endl;
+ if(VF.File().Archive() && (VF.File().Archive() == DefRel))
+ {
+ VerTag = Ver.VerStr();
+ break;
+ }
+ }
+ }
}
-
+
/* Lookup the version of the package we would install if we were to
install a version and determine the source package name, then look
- in the archive for a source package of the same name. In theory
- we could stash the version string as well and match that too but
- today there aren't multi source versions in the archive. */
- if (_config->FindB("APT::Get::Only-Source") == false &&
- VerTag.empty() == true)
+ in the archive for a source package of the same name. */
+ if (_config->FindB("APT::Get::Only-Source") == false)
{
- pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
if (Pkg.end() == false)
{
- pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
+ pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
if (Ver.end() == false)
{
pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
}
}
- if (Last == 0)
- return 0;
-
- if (Last->Jump(Offset) == false)
+ if (Last == 0 || Last->Jump(Offset) == false)
return 0;
return Last;
AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
pkgAcquire Fetcher(&Stat);
- // Populate it with the source selection
- if (List.GetIndexes(&Fetcher) == false)
- return false;
// Just print out the uris an exit if the --print-uris flag was used
if (_config->FindB("APT::Get::Print-URIs") == true)
{
+ // Populate it with the source selection and get all Indexes
+ // (GetAll=true)
+ if (List.GetIndexes(&Fetcher,true) == false)
+ return false;
+
pkgAcquire::UriIterator I = Fetcher.UriBegin();
for (; I != Fetcher.UriEnd(); I++)
cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl;
return true;
}
+
+ // Populate it with the source selection
+ if (List.GetIndexes(&Fetcher) == false)
+ return false;
// Run it
if (Fetcher.Run() == pkgAcquire::Failed)
}
// Clean out any old list files
- if (_config->FindB("APT::Get::List-Cleanup",true) == true)
+ if (!Failed && _config->FindB("APT::Get::List-Cleanup",true) == true)
{
if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false ||
Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false)
if (pkgAllUpgrade(Cache) == false)
{
ShowBroken(c1out,Cache,false);
- return _error->Error(_("Internal Error, AllUpgrade broke stuff"));
+ return _error->Error(_("Internal error, AllUpgrade broke stuff"));
}
return InstallPackages(Cache,true);
string SuggestsVersions, RecommendsVersions;
for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
{
- pkgCache::PkgIterator I(Cache,Cache.List[J]);
+ pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
/* Just look at the ones we want to install */
- if ((*Cache)[I].Install() == false)
+ if ((*Cache)[Pkg].Install() == false)
continue;
- for (pkgCache::VerIterator V = I.VersionList(); V.end() == false; V++)
- {
- for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
+ // get the recommends/suggests for the candidate ver
+ pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
+ for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
+ {
+ pkgCache::DepIterator Start;
+ pkgCache::DepIterator End;
+ D.GlobOr(Start,End); // advances D
+
+ // FIXME: we really should display a or-group as a or-group to the user
+ // the problem is that ShowList is incapable of doing this
+ string RecommendsOrList,RecommendsOrVersions;
+ string SuggestsOrList,SuggestsOrVersions;
+ bool foundInstalledInOrGroup = false;
+ for(;;)
+ {
+ /* Skip if package is installed already, or is about to be */
+ string target = string(Start.TargetPkg().Name()) + " ";
+
+ if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install
+ || Cache[Start.TargetPkg()].Install())
{
- pkgCache::DepIterator Start;
- pkgCache::DepIterator End;
- D.GlobOr(Start,End);
-
- /*
- * If this is a virtual package, we need to check the list of
- * packages that provide it and see if any of those are
- * installed
- */
- pkgCache::PrvIterator Prv = Start.TargetPkg().ProvidesList();
- bool providedBySomething = false;
- for (; Prv.end() != true; Prv++)
- if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false) {
- providedBySomething = true;
- break;
- }
-
- if (providedBySomething) continue;
-
- do
- {
- if (Start->Type == pkgCache::Dep::Suggests) {
-
- /* A suggests relations, let's see if we have it
- installed already */
-
- string target = string(Start.TargetPkg().Name()) + " ";
- if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install || Cache[Start.TargetPkg()].Install())
- break;
- /* Does another package suggest it as well? If so,
- don't print it twice */
- if (int(SuggestsList.find(target)) > -1)
- break;
- SuggestsList += target;
- SuggestsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
- }
-
- if (Start->Type == pkgCache::Dep::Recommends) {
-
- /* A recommends relation, let's see if we have it
- installed already */
-
- string target = string(Start.TargetPkg().Name()) + " ";
- if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install || Cache[Start.TargetPkg()].Install())
- break;
-
- /* Does another package recommend it as well? If so,
- don't print it twice */
-
- if (int(RecommendsList.find(target)) > -1)
- break;
- RecommendsList += target;
- SuggestsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
- }
- if (Start == End)
- break;
- Start++;
- } while (1);
+ foundInstalledInOrGroup=true;
+ break;
+ }
+
+ /* Skip if we already saw it */
+ if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
+ {
+ foundInstalledInOrGroup=true;
+ break;
+ }
+
+ // this is a dep on a virtual pkg, check if any package that provides it
+ // should be installed
+ if(Start.TargetPkg().ProvidesList() != 0)
+ {
+ pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
+ for (; I.end() == false; I++)
+ {
+ pkgCache::PkgIterator Pkg = I.OwnerPkg();
+ if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
+ Pkg.CurrentVer() != 0)
+ foundInstalledInOrGroup=true;
+ }
+ }
+
+ if (Start->Type == pkgCache::Dep::Suggests)
+ {
+ SuggestsOrList += target;
+ SuggestsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
}
- }
+
+ if (Start->Type == pkgCache::Dep::Recommends)
+ {
+ RecommendsOrList += target;
+ RecommendsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
+ }
+
+ if (Start >= End)
+ break;
+ Start++;
+ }
+
+ if(foundInstalledInOrGroup == false)
+ {
+ RecommendsList += RecommendsOrList;
+ RecommendsVersions += RecommendsOrVersions;
+ SuggestsList += SuggestsOrList;
+ SuggestsVersions += SuggestsOrVersions;
+ }
+
+ }
}
+
ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
// See if we need to prompt
if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0)
return InstallPackages(Cache,false,false);
-
+
return InstallPackages(Cache,false);
}
/*}}}*/
if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
return false;
- c0out << _("Calculating Upgrade... ") << flush;
+ c0out << _("Calculating upgrade... ") << flush;
if (pkgDistUpgrade(*Cache) == false)
{
c0out << _("Failed") << endl;
if (Fix.Resolve() == false)
{
ShowBroken(c1out,Cache,false);
- return _error->Error("Internal Error, problem resolver broke stuff");
+ return _error->Error(_("Internal error, problem resolver broke stuff"));
}
}
if (pkgAllUpgrade(Cache) == false)
{
ShowBroken(c1out,Cache,false);
- return _error->Error("Internal Error, problem resolver broke stuff");
+ return _error->Error(_("Internal error, problem resolver broke stuff"));
}
return InstallPackages(Cache,false);
DscFile *Dsc = new DscFile[CmdL.FileSize()];
+ // insert all downloaded uris into this set to avoid downloading them
+ // twice
+ set<string> queued;
// Load the requestd sources into the fetcher
unsigned J = 0;
for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
if (_config->FindB("APT::Get::Tar-Only",false) == true &&
I->Type != "tar")
continue;
-
+
+ // don't download the same uri twice (should this be moved to
+ // the fetcher interface itself?)
+ if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
+ continue;
+ queued.insert(Last->Index().ArchiveURI(I->Path));
+
+ // check if we have a file with that md5 sum already localy
+ if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
+ {
+ FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
+ MD5Summation sum;
+ sum.AddFD(Fd.Fd(), Fd.Size());
+ Fd.Close();
+ if((string)sum.Result() == I->MD5Hash)
+ {
+ ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
+ flNotDir(I->Path).c_str());
+ continue;
+ }
+ }
+
new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
I->MD5Hash,I->Size,
Last->Index().SourceInfo(*Last,*I),Src);
struct statvfs Buf;
string OutputDir = ".";
if (statvfs(OutputDir.c_str(),&Buf) != 0)
- return _error->Errno("statvfs","Couldn't determine free space in %s",
+ return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
OutputDir.c_str());
if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
return _error->Error(_("You don't have enough free space in %s"),
if (_config->FindB("APT::Get::Simulate",false) == true)
{
for (unsigned I = 0; I != J; I++)
- ioprintf(cout,_("Fetch Source %s\n"),Dsc[I].Package.c_str());
+ ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
return true;
}
if (system(S) != 0)
{
fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
+ fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
_exit(1);
}
}
rec.Package = Opts->Value;
rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
rec.Op = 0;
- BuildDeps.insert(BuildDeps.begin(), rec);
+ BuildDeps.push_back(rec);
}
if (BuildDeps.size() == 0)
unsigned int ExpectedInst = 0;
vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
pkgProblemResolver Fix(Cache);
+ bool skipAlternatives = false; // skip remaining alternatives in an or group
for (D = BuildDeps.begin(); D != BuildDeps.end(); D++)
{
+ bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
+
+ if (skipAlternatives == true)
+ {
+ if (!hasAlternatives)
+ skipAlternatives = false; // end of or group
+ continue;
+ }
+
if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
(*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
{
else // BuildDep || BuildDepIndep
{
pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << "Looking for " << (*D).Package << "...\n";
+
if (Pkg.end() == true)
{
- // Check if there are any alternatives
- if (((*D).Op & pkgCache::Dep::Or) != pkgCache::Dep::Or)
- return _error->Error(_("%s dependency for %s cannot be satisfied "
- "because the package %s cannot be found"),
- Last->BuildDepType((*D).Type),Src.c_str(),
- (*D).Package.c_str());
- // Try the next alternative
- continue;
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << " (not found)" << (*D).Package << endl;
+
+ if (hasAlternatives)
+ continue;
+
+ return _error->Error(_("%s dependency for %s cannot be satisfied "
+ "because the package %s cannot be found"),
+ Last->BuildDepType((*D).Type),Src.c_str(),
+ (*D).Package.c_str());
}
/*
* this would require we do a Resolve cycle for each package we
* add to the install list. Ugh
*/
- while (D != BuildDeps.end() &&
- (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or))
- D++;
/*
* If this is a virtual package, we need to check the list of
* installed
*/
pkgCache::PrvIterator Prv = Pkg.ProvidesList();
- bool providedBySomething = !Prv.end();
for (; Prv.end() != true; Prv++)
{
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << " Checking provider " << Prv.OwnerPkg().Name() << endl;
+
if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
break;
}
// Get installed version and version we are going to install
pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
- if (!providedBySomething || (*D).Version[0] != '\0') {
- /* We either have a versioned dependency (so a provides won't do)
- or nothing is providing this package */
+ if ((*D).Version[0] != '\0') {
+ // Versioned dependency
pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
break;
}
if (CV.end() == true)
+ if (hasAlternatives)
+ {
+ continue;
+ }
+ else
+ {
return _error->Error(_("%s dependency for %s cannot be satisfied "
"because no available versions of package %s "
"can satisfy version requirements"),
Last->BuildDepType((*D).Type),Src.c_str(),
(*D).Package.c_str());
+ }
+ }
+ else
+ {
+ // Only consider virtual packages if there is no versioned dependency
+ if (Prv.end() == false)
+ {
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << " Is provided by installed package " << Prv.OwnerPkg().Name() << endl;
+ skipAlternatives = hasAlternatives;
+ continue;
+ }
}
- /*
- * TODO: if we depend on a version lower than what we already have
- * installed it is not clear what should be done; in practice
- * this case should be rare, and right now nothing is
- * done about it :-(
- */
- if (Prv.end() == true && // Nothing provides it; and
- (IV.end() == true || // It is not installed, or
- Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == false))
- // the version installed doesn't
- // satisfy constraints
- TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst);
+ if (IV.end() == false)
+ {
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << " Is installed\n";
+
+ if (Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
+ {
+ skipAlternatives = hasAlternatives;
+ continue;
+ }
+
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << " ...but the installed version doesn't meet the version requirement\n";
+
+ if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
+ {
+ return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
+ Last->BuildDepType((*D).Type),
+ Src.c_str(),
+ Pkg.Name());
+ }
+ }
+
+
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << " Trying to install " << (*D).Package << endl;
+
+ if (TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst) == true)
+ {
+ // We successfully installed something; skip remaining alternatives
+ skipAlternatives = hasAlternatives;
+ continue;
+ }
+ else if (hasAlternatives)
+ {
+ if (_config->FindB("Debug::BuildDeps",false) == true)
+ cout << " Unsatisfiable, trying alternatives\n";
+ continue;
+ }
+ else
+ {
+ return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
+ Last->BuildDepType((*D).Type),
+ Src.c_str(),
+ (*D).Package.c_str());
+ }
}
}
// Now we check the state of the packages,
if (Cache->BrokenCount() != 0)
- return _error->Error(_("Some broken packages were found while trying to process build-dependencies.\n"
- "You might want to run `apt-get -f install' to correct these."));
+ return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
}
if (InstallPackages(Cache, false, true) == false)
if (_config->FindB("version") == true)
{
- cout << _("Supported Modules:") << endl;
+ cout << _("Supported modules:") << endl;
for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
{
" -b Build the source package after fetching it\n"
" -V Show verbose version numbers\n"
" -c=? Read this configuration file\n"
- " -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp\n"
+ " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
"See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
"pages for more information and options.\n"
" This APT has Super Cow Powers.\n");
_config->Set("APT::Get::Assume-Yes",false);
_config->Set("APT::Get::Fix-Broken",false);
_config->Set("APT::Get::Force-Yes",false);
- _config->Set("APT::Get::APT::Get::No-List-Cleanup",true);
+ _config->Set("APT::Get::List-Cleanup",true);
}
/*}}}*/
// SigWinch - Window size change signal handler /*{{{*/
{0,"remove","APT::Get::Remove",0},
{0,"only-source","APT::Get::Only-Source",0},
{0,"arch-only","APT::Get::Arch-Only",0},
+ {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
{'c',"config-file",0,CommandLine::ConfigFile},
{'o',"option",0,CommandLine::ArbItem},
{0,0,0,0}};
}
// Deal with stdout not being a tty
- if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1)
+ if (!isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
_config->Set("quiet","1");
// Setup the output streams
projects / apt.git / blobdiff