Browse Source

Sync

Author: jgg
Date: 1998-10-02 04:39:42 GMT
Sync
debian/1.8.y
Arch Librarian 18 years ago
parent
commit
0a8e3465cb
  1. 270
      apt-pkg/algorithms.cc
  2. 20
      apt-pkg/algorithms.h
  3. 5
      apt-pkg/cacheiterators.h
  4. 13
      apt-pkg/contrib/configuration.cc
  5. 6
      apt-pkg/contrib/fileutl.cc
  6. 4
      apt-pkg/contrib/fileutl.h
  7. 32
      apt-pkg/contrib/progress.cc
  8. 8
      apt-pkg/contrib/progress.h
  9. 4
      apt-pkg/depcache.h
  10. 14
      apt-pkg/pkgcache.cc
  11. 8
      apt-pkg/pkgcachegen.cc
  12. 13
      apt-pkg/tagfile.cc
  13. 27
      cmdline/apt-cache.cc
  14. 764
      cmdline/apt-get.cc
  15. 4
      cmdline/makefile
  16. 47
      doc/examples/apt.conf
  17. 4
      doc/examples/sources.list
  18. 170
      doc/files.sgml

270
apt-pkg/algorithms.cc

@ -1,10 +1,16 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: algorithms.cc,v 1.3 1998/07/12 23:58:20 jgg Exp $
// $Id: algorithms.cc,v 1.4 1998/10/02 04:39:42 jgg Exp $
/* ######################################################################
Algorithms - A set of misc algorithms
The pkgProblemResolver class has become insanely complex and
very sophisticated, it handles every test case I have thrown at it
to my satisfaction. Understanding exactly why all the steps the class
does are required is difficult and changing though not very risky
may result in other cases not working.
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
@ -13,6 +19,7 @@
#endif
#include <apt-pkg/algorithms.h>
#include <apt-pkg/error.h>
#include <apt-pkg/configuration.h>
#include <iostream.h>
/*}}}*/
@ -37,7 +44,7 @@ bool pkgSimulate::Install(PkgIterator iPkg,string /*File*/)
PkgIterator Pkg = Sim.FindPkg(iPkg.Name());
Flags[Pkg->ID] = 1;
cout << "Inst " << Pkg.Name();
clog << "Inst " << Pkg.Name();
Sim.MarkInstall(Pkg,false);
// Look for broken conflicts+predepends.
@ -51,7 +58,7 @@ bool pkgSimulate::Install(PkgIterator iPkg,string /*File*/)
{
if ((Sim[D] & pkgDepCache::DepInstall) == 0)
{
cout << " [" << I.Name() << " on " << D.TargetPkg().Name() << ']';
clog << " [" << I.Name() << " on " << D.TargetPkg().Name() << ']';
if (D->Type == pkgCache::Dep::Conflicts)
_error->Error("Fatal, conflicts violated %s",I.Name());
}
@ -61,7 +68,7 @@ bool pkgSimulate::Install(PkgIterator iPkg,string /*File*/)
if (Sim.BrokenCount() != 0)
ShortBreaks();
else
cout << endl;
clog << endl;
return true;
}
/*}}}*/
@ -79,7 +86,7 @@ bool pkgSimulate::Configure(PkgIterator iPkg)
// Sim.MarkInstall(Pkg,false);
if (Sim[Pkg].InstBroken() == true)
{
cout << "Conf " << Pkg.Name() << " broken" << endl;
clog << "Conf " << Pkg.Name() << " broken" << endl;
Sim.Update();
@ -91,21 +98,21 @@ bool pkgSimulate::Configure(PkgIterator iPkg)
continue;
if (D->Type == pkgCache::Dep::Conflicts)
cout << " Conflicts:" << D.TargetPkg().Name();
clog << " Conflicts:" << D.TargetPkg().Name();
else
cout << " Depends:" << D.TargetPkg().Name();
clog << " Depends:" << D.TargetPkg().Name();
}
cout << endl;
clog << endl;
_error->Error("Conf Broken %s",Pkg.Name());
}
else
cout << "Conf " << Pkg.Name();
clog << "Conf " << Pkg.Name();
if (Sim.BrokenCount() != 0)
ShortBreaks();
else
cout << endl;
clog << endl;
return true;
}
@ -120,12 +127,12 @@ bool pkgSimulate::Remove(PkgIterator iPkg)
Flags[Pkg->ID] = 3;
Sim.MarkDelete(Pkg);
cout << "Remv " << Pkg.Name();
clog << "Remv " << Pkg.Name();
if (Sim.BrokenCount() != 0)
ShortBreaks();
else
cout << endl;
clog << endl;
return true;
}
@ -135,18 +142,18 @@ bool pkgSimulate::Remove(PkgIterator iPkg)
/* */
void pkgSimulate::ShortBreaks()
{
cout << " [";
clog << " [";
for (PkgIterator I = Sim.PkgBegin(); I.end() == false; I++)
{
if (Sim[I].InstBroken() == true)
{
if (Flags[I->ID] == 0)
cout << I.Name() << ' ';
clog << I.Name() << ' ';
/* else
cout << I.Name() << "! ";*/
clog << I.Name() << "! ";*/
}
}
cout << ']' << endl;
clog << ']' << endl;
}
/*}}}*/
// ApplyStatus - Adjust for non-ok packages /*{{{*/
@ -182,8 +189,8 @@ bool pkgApplyStatus(pkgDepCache &Cache)
/*}}}*/
// FixBroken - Fix broken packages /*{{{*/
// ---------------------------------------------------------------------
/* This autoinstalls every broken package and then runs ScoredFix on the
result. */
/* This autoinstalls every broken package and then runs the problem resolver
on the result. */
bool pkgFixBroken(pkgDepCache &Cache)
{
// Auto upgrade all broken packages
@ -215,7 +222,7 @@ bool pkgFixBroken(pkgDepCache &Cache)
pre-existing package. This creates the initial set of conditions which
most likely contain problems because too many things were installed.
ScoredFix is used to resolve the problems.
The problem resolver is used to resolve the problems.
*/
bool pkgDistUpgrade(pkgDepCache &Cache)
{
@ -252,6 +259,34 @@ bool pkgDistUpgrade(pkgDepCache &Cache)
return Fix.Resolve();
}
/*}}}*/
// AllUpgrade - Upgrade as many packages as possible /*{{{*/
// ---------------------------------------------------------------------
/* Right now the system must be consistent before this can be called.
It also will not change packages marked for install, it only tries
to install packages not marked for install */
bool pkgAllUpgrade(pkgDepCache &Cache)
{
pkgProblemResolver Fix(Cache);
if (Cache.BrokenCount() != 0)
return false;
// Upgrade all installed packages
for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
{
if (Cache[I].Install() == true)
Fix.Protect(I);
if (I->SelectedState == pkgCache::State::Hold)
continue;
if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
Cache.MarkInstall(I,false);
}
return Fix.ResolveByKeep();
}
/*}}}*/
// ProblemResolver::pkgProblemResolver - Constructor /*{{{*/
// ---------------------------------------------------------------------
@ -265,7 +300,7 @@ pkgProblemResolver::pkgProblemResolver(pkgDepCache &Cache) : Cache(Cache)
memset(Flags,0,sizeof(*Flags)*Size);
// Set debug to true to see its decision logic
Debug = false;
Debug = _config->FindB("Debug::pkgProblemResolver",false);
}
/*}}}*/
// ProblemResolver::ScoreSort - Sort the list by score /*{{{*/
@ -383,11 +418,16 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
{
if ((Flags[Pkg->ID] & Upgradable) == 0 || Cache[Pkg].Upgradable() == false)
return false;
Flags[Pkg->ID] &= ~Upgradable;
bool WasKept = Cache[Pkg].Keep();
Cache.MarkInstall(Pkg,false);
// This must be a virtual package or something like that.
if (Cache[Pkg].InstVerIter(Cache).end() == true)
return false;
// Isolate the problem dependency
bool Fail = false;
for (pkgCache::DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
@ -415,19 +455,28 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
// Hm, the group is broken.. I have no idea how to handle this
if (Start != End)
{
cout << "Note, a broken or group was found in " << Pkg.Name() << "." << endl;
clog << "Note, a broken or group was found in " << Pkg.Name() << "." << endl;
Fail = true;
break;
}
// Do not change protected packages
PkgIterator P = Start.SmartTargetPkg();
if ((Flags[P->ID] & Protected) == Protected)
{
if (Debug == true)
clog << " Reinet Failed because of protected " << P.Name() << endl;
Fail = true;
break;
}
// Upgrade the package if the candidate version will fix the problem.
if ((Cache[Start] & pkgDepCache::DepCVer) == pkgDepCache::DepCVer)
{
PkgIterator P = Start.SmartTargetPkg();
if (DoUpgrade(P) == false)
{
if (Debug == true)
cout << " Reinst Failed because of " << P.Name() << endl;
clog << " Reinst Failed because of " << P.Name() << endl;
Fail = true;
break;
}
@ -440,7 +489,7 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
continue;
if (Debug == true)
cout << " Reinst Failed early because of " << Start.TargetPkg().Name() << endl;
clog << " Reinst Failed early because of " << Start.TargetPkg().Name() << endl;
Fail = true;
break;
}
@ -457,7 +506,7 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
}
if (Debug == true)
cout << " Re-Instated " << Pkg.Name() << endl;
clog << " Re-Instated " << Pkg.Name() << endl;
return true;
}
/*}}}*/
@ -477,7 +526,7 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
upgrade packages to advoid problems. */
bool pkgProblemResolver::Resolve(bool BrokenFix)
{
unsigned long Size = Cache.HeaderP->PackageCount;
unsigned long Size = Cache.HeaderP->PackageCount;
// Record which packages are marked for install
bool Again = false;
@ -505,7 +554,7 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
while (Again == true);
if (Debug == true)
cout << "Starting" << endl;
clog << "Starting" << endl;
MakeScores();
@ -524,13 +573,13 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
if (Scores[(*K)->ID] != 0)
{
pkgCache::PkgIterator Pkg(Cache,*K);
cout << Scores[(*K)->ID] << ' ' << Pkg.Name() <<
clog << Scores[(*K)->ID] << ' ' << Pkg.Name() <<
' ' << (pkgCache::Version *)Pkg.CurrentVer() << ' ' <<
Cache[Pkg].InstallVer << ' ' << Cache[Pkg].CandidateVer << endl;
} */
if (Debug == true)
cout << "Starting 2" << endl;
clog << "Starting 2" << endl;
/* Now consider all broken packages. For each broken package we either
remove the package or fix it's problem. We do this once, it should
@ -549,13 +598,15 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
if (Cache[I].CandidateVer != Cache[I].InstallVer &&
I->CurrentVer != 0 && Cache[I].InstallVer != 0 &&
(Flags[I->ID] & PreInstalled) != 0 &&
(Flags[I->ID] & Protected) == 0)
(Flags[I->ID] & Protected) == 0 &&
(Flags[I->ID] & ReInstateTried) == 0)
{
if (Debug == true)
cout << " Try to Re-Instate " << I.Name() << endl;
clog << " Try to Re-Instate " << I.Name() << endl;
int OldBreaks = Cache.BrokenCount();
pkgCache::Version *OldVer = Cache[I].InstallVer;
Flags[I->ID] &= ReInstateTried;
Cache.MarkInstall(I,false);
if (Cache[I].InstBroken() == true ||
OldBreaks < Cache.BrokenCount())
@ -567,7 +618,7 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
}
else
if (Debug == true)
cout << "Re-Instated " << I.Name() << endl;
clog << "Re-Instated " << I.Name() << " (" << OldBreaks << " vs " << Cache.BrokenCount() << ')' << endl;
}
if (Cache[I].InstallVer == 0 || Cache[I].InstBroken() == false)
@ -601,13 +652,13 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
// Hm, the group is broken.. I have no idea how to handle this
if (Start != End)
{
cout << "Note, a broken or group was found in " << I.Name() << "." << endl;
clog << "Note, a broken or group was found in " << I.Name() << "." << endl;
Cache.MarkDelete(I);
break;
}
if (Debug == true)
cout << "Package " << I.Name() << " has broken dep on " << End.TargetPkg().Name() << endl;
clog << "Package " << I.Name() << " has broken dep on " << End.TargetPkg().Name() << endl;
/* Conflicts is simple, decide if we should remove this package
or the conflicted one */
@ -619,7 +670,7 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
pkgCache::PkgIterator Pkg = Ver.ParentPkg();
if (Debug == true)
cout << " Considering " << Pkg.Name() << ' ' << (int)Scores[Pkg->ID] <<
clog << " Considering " << Pkg.Name() << ' ' << (int)Scores[Pkg->ID] <<
" as a solution to " << I.Name() << ' ' << (int)Scores[I->ID] << endl;
if (Scores[I->ID] <= Scores[Pkg->ID] ||
((Cache[End] & pkgDepCache::DepGNow) == 0 &&
@ -627,24 +678,24 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
{
if ((Flags[I->ID] & Protected) != 0)
continue;
// See if a keep will do
Cache.MarkKeep(I);
if (Cache[I].InstBroken() == false)
{
if (Debug == true)
cout << " Holding Back " << I.Name() << " rather than change " << End.TargetPkg().Name() << endl;
clog << " Holding Back " << I.Name() << " rather than change " << End.TargetPkg().Name() << endl;
}
else
{
if (BrokenFix == false || DoUpgrade(I) == false)
{
if (Debug == true)
cout << " Removing " << I.Name() << " rather than change " << End.TargetPkg().Name() << endl;
clog << " Removing " << I.Name() << " rather than change " << End.TargetPkg().Name() << endl;
Cache.MarkDelete(I);
if (Counter > 1)
Scores[I->ID] = Scores[Pkg->ID];
}
}
}
Change = true;
@ -660,6 +711,7 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
LEnd->Pkg = Pkg;
LEnd->Dep = End;
LEnd++;
if (End->Type != pkgCache::Dep::Conflicts)
break;
}
@ -672,12 +724,12 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
if (Cache[I].InstBroken() == false)
{
if (Debug == true)
cout << " Holding Back " << I.Name() << " because I can't find " << End.TargetPkg().Name() << endl;
clog << " Holding Back " << I.Name() << " because I can't find " << End.TargetPkg().Name() << endl;
}
else
{
if (Debug == true)
cout << " Removing " << I.Name() << " because I can't find " << End.TargetPkg().Name() << endl;
clog << " Removing " << I.Name() << " because I can't find " << End.TargetPkg().Name() << endl;
Cache.MarkDelete(I);
}
@ -700,14 +752,14 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
if (J->Dep->Type == pkgCache::Dep::Conflicts)
{
if (Debug == true)
cout << " Fixing " << I.Name() << " via remove of " << J->Pkg.Name() << endl;
clog << " Fixing " << I.Name() << " via remove of " << J->Pkg.Name() << endl;
Cache.MarkDelete(J->Pkg);
}
}
else
{
if (Debug == true)
cout << " Fixing " << I.Name() << " via keep of " << J->Pkg.Name() << endl;
clog << " Fixing " << I.Name() << " via keep of " << J->Pkg.Name() << endl;
Cache.MarkKeep(J->Pkg);
}
@ -718,13 +770,137 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
}
if (Debug == true)
cout << "Done" << endl;
clog << "Done" << endl;
delete [] Scores;
delete [] PList;
if (Cache.BrokenCount() != 0)
return _error->Error("Internal error, ScoredFix generated breaks.");
return _error->Error("Internal error, pkgProblemResolver::Resolve generated breaks.");
return true;
}
/*}}}*/
// ProblemResolver::ResolveByKeep - Resolve problems using keep /*{{{*/
// ---------------------------------------------------------------------
/* This is the work horse of the soft upgrade routine. It is very gental
in that it does not install or remove any packages. It is assumed that the
system was non-broken previously. */
bool pkgProblemResolver::ResolveByKeep()
{
unsigned long Size = Cache.HeaderP->PackageCount;
if (Debug == true)
clog << "Entering ResolveByKeep" << endl;
MakeScores();
/* We have to order the packages so that the broken fixing pass
operates from highest score to lowest. This prevents problems when
high score packages cause the removal of lower score packages that
would cause the removal of even lower score packages. */
pkgCache::Package **PList = new pkgCache::Package *[Size];
pkgCache::Package **PEnd = PList;
for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
*PEnd++ = I;
This = this;
qsort(PList,PEnd - PList,sizeof(*PList),&ScoreSort);
// Consider each broken package
pkgCache::Package **LastStop = 0;
for (pkgCache::Package **K = PList; K != PEnd; K++)
{
pkgCache::PkgIterator I(Cache,*K);
if (Cache[I].InstallVer == 0 || Cache[I].InstBroken() == false)
continue;
/* Keep the package. If this works then great, otherwise we have
to be significantly more agressive and manipulate its dependencies */
if ((Flags[I->ID] & Protected) == 0)
{
if (Debug == true)
clog << "Keeping package " << I.Name() << endl;
Cache.MarkKeep(I);
if (Cache[I].InstBroken() == false)
{
K = PList;
continue;
}
}
// Isolate the problem dependencies
for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false;)
{
// Compute a single dependency element (glob or)
pkgCache::DepIterator Start = D;
pkgCache::DepIterator End = D;
unsigned char State = 0;
for (bool LastOR = true; D.end() == false && LastOR == true; D++)
{
State |= Cache[D];
LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
if (LastOR == true)
End = D;
}
// We only worry about critical deps.
if (End.IsCritical() != true)
continue;
// Dep is ok
if ((Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall)
continue;
// Hm, the group is broken.. I have no idea how to handle this
if (Start != End)
{
clog << "Note, a broken or group was found in " << I.Name() << "." << endl;
if ((Flags[I->ID] & Protected) == 0)
Cache.MarkKeep(I);
break;
}
if (Debug == true)
clog << "Package " << I.Name() << " has broken dep on " << End.TargetPkg().Name() << endl;
// Look at all the possible provides on this package
pkgCache::Version **VList = End.AllTargets();
bool Done = false;
for (pkgCache::Version **V = VList; *V != 0; V++)
{
pkgCache::VerIterator Ver(Cache,*V);
pkgCache::PkgIterator Pkg = Ver.ParentPkg();
// It is not keepable
if (Cache[Pkg].InstallVer == 0 ||
Pkg->CurrentVer == 0)
continue;
if ((Flags[I->ID] & Protected) == 0)
{
if (Debug == true)
clog << " Keeping Package " << Pkg.Name() << " due to dep" << endl;
Cache.MarkKeep(Pkg);
}
if (Cache[I].InstBroken() == false)
break;
}
if (Cache[I].InstBroken() == false)
break;
}
if (Cache[I].InstBroken() == true)
continue;
// Restart again.
if (K == LastStop)
return _error->Error("Internal Error, pkgProblemResolver::ResolveByKeep is looping on package %s.",I.Name());
LastStop = K;
K = PList;
}
return true;
}

20
apt-pkg/algorithms.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: algorithms.h,v 1.3 1998/07/19 21:24:11 jgg Exp $
// $Id: algorithms.h,v 1.4 1998/10/02 04:39:43 jgg Exp $
/* ######################################################################
Algorithms - A set of misc algorithms
@ -16,7 +16,15 @@
field in the status file. It is important to get proper crash recovery.
pkgFixBroken corrects a broken system so that it is in a sane state.
pkgAllUpgrade attempts to upgade as many packages as possible but
without installing new packages.
The problem resolver class contains a number of complex algorithms
to try to best-guess an upgrade state. It solves the problem of
maximizing the number of install state packages while having no broken
packages.
##################################################################### */
/*}}}*/
// Header section: pkglib
@ -60,7 +68,7 @@ class pkgProblemResolver
typedef pkgCache::Package Package;
enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1),
Upgradable = (1 << 2)};
Upgradable = (1 << 2), ReInstateTried = (1 << 3)};
signed short *Scores;
unsigned char *Flags;
bool Debug;
@ -81,13 +89,19 @@ class pkgProblemResolver
public:
inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected;};
// Try to intelligently resolve problems by installing and removing packages
bool Resolve(bool BrokenFix = false);
// Try to resolve problems only by using keep
bool ResolveByKeep();
pkgProblemResolver(pkgDepCache &Cache);
};
bool pkgDistUpgrade(pkgDepCache &Cache);
bool pkgApplyStatus(pkgDepCache &Cache);
bool pkgFixBroken(pkgDepCache &Cache);
bool pkgAllUpgrade(pkgDepCache &Cache);
#endif

5
apt-pkg/cacheiterators.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: cacheiterators.h,v 1.6 1998/07/12 23:58:23 jgg Exp $
// $Id: cacheiterators.h,v 1.7 1998/10/02 04:39:44 jgg Exp $
/* ######################################################################
Cache Iterators - Iterators for navigating the cache structure
@ -173,7 +173,8 @@ class pkgCache::DepIterator
bool IsCritical();
Version **AllTargets();
bool SmartTargetPkg(PkgIterator &Result);
const char *CompType();
inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
Dep(Trg), Type(DepVer), Owner(&Owner)
{

13
apt-pkg/contrib/configuration.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: configuration.cc,v 1.5 1998/09/26 05:34:26 jgg Exp $
// $Id: configuration.cc,v 1.6 1998/10/02 04:39:49 jgg Exp $
/* ######################################################################
Configuration Class
@ -105,6 +105,7 @@ string Configuration::Find(const char *Name,const char *Default)
// Configuration::FindDir - Find a directory /*{{{*/
// ---------------------------------------------------------------------
/* Directories are stored as the base dir in the Parent node and the
sub directory in sub nodes
*/
string Configuration::FindDir(const char *Name,const char *Default = 0)
{
@ -117,8 +118,16 @@ string Configuration::FindDir(const char *Name,const char *Default = 0)
return Default;
}
// Absolute path
if (Itm->Value[0] == '/' || Itm->Parent == 0)
return Itm->Value;
// ./ is also considered absolute as is anything with ~ in it
if (Itm->Value[0] != 0 &&
((Itm->Value[0] == '.' && Itm->Value[1] == '/') ||
(Itm->Value[0] == '~' && Itm->Value[1] == '/')))
return Itm->Value;
if (Itm->Parent->Value.end()[-1] == '/')
return Itm->Parent->Value + Itm->Value;
else
@ -167,7 +176,7 @@ bool Configuration::FindB(const char *Name,bool Default)
strcasecmp(Itm->Value.c_str(),"true") == 0 ||
strcasecmp(Itm->Value.c_str(),"with") == 0 ||
strcasecmp(Itm->Value.c_str(),"enable") == 0)
return false;
return true;
return Default;
}

6
apt-pkg/contrib/fileutl.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: fileutl.cc,v 1.7 1998/08/26 04:52:26 jgg Exp $
// $Id: fileutl.cc,v 1.8 1998/10/02 04:39:50 jgg Exp $
/* ######################################################################
File Utilities
@ -140,6 +140,10 @@ FileFd::FileFd(string FileName,OpenMode Mode, unsigned long Perms)
case WriteExists:
iFd = open(FileName.c_str(),O_RDWR);
break;
case WriteAny:
iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
break;
// Dont use this in public directories
case LockEmpty:

4
apt-pkg/contrib/fileutl.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: fileutl.h,v 1.5 1998/08/26 04:52:27 jgg Exp $
// $Id: fileutl.h,v 1.6 1998/10/02 04:39:52 jgg Exp $
/* ######################################################################
File Utilities
@ -38,7 +38,7 @@ class FileFd
string FileName;
public:
enum OpenMode {ReadOnly,WriteEmpty,WriteExists,LockEmpty};
enum OpenMode {ReadOnly,WriteEmpty,WriteExists,WriteAny,LockEmpty};
bool Read(void *To,unsigned long Size);
bool Write(void *From,unsigned long Size);

32
apt-pkg/contrib/progress.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: progress.cc,v 1.7 1998/09/07 05:28:38 jgg Exp $
// $Id: progress.cc,v 1.8 1998/10/02 04:39:53 jgg Exp $
/* ######################################################################
OpProgress - Operation Progress
@ -13,6 +13,7 @@
#endif
#include <apt-pkg/progress.h>
#include <apt-pkg/error.h>
#include <apt-pkg/configuration.h>
#include <stdio.h>
/*}}}*/
@ -108,6 +109,18 @@ bool OpProgress::CheckChange(float Interval)
return true;
}
/*}}}*/
// OpTextProgress::OpTextProgress - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
OpTextProgress::OpTextProgress(Configuration &Config) :
NoUpdate(false), NoDisplay(false), LastLen(0)
{
if (Config.FindI("quiet",0) >= 1)
NoUpdate = true;
if (Config.FindI("quiet",0) >= 2)
NoDisplay = true;
};
/*}}}*/
// OpTextProgress::Done - Clean up the display /*{{{*/
// ---------------------------------------------------------------------
/* */
@ -123,7 +136,13 @@ void OpTextProgress::Done()
Write(S);
cout << endl;
OldOp = string();
}
}
if (NoUpdate == true && NoDisplay == false && OldOp.empty() == false)
{
OldOp = string();
cout << endl;
}
}
/*}}}*/
// OpTextProgress::Update - Simple text spinner /*{{{*/
@ -139,7 +158,14 @@ void OpTextProgress::Update()
{
if (MajorChange == false)
return;
cout << Op << endl;
if (NoDisplay == false)
{
if (OldOp.empty() == false)
cout << endl;
OldOp = "a";
cout << Op << "..." << flush;
}
return;
}

8
apt-pkg/contrib/progress.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: progress.h,v 1.3 1998/08/26 04:52:29 jgg Exp $
// $Id: progress.h,v 1.4 1998/10/02 04:39:54 jgg Exp $
/* ######################################################################
OpProgress - Operation Progress
@ -29,6 +29,7 @@
#include <string>
#include <sys/time.h>
class Configuration;
class OpProgress
{
unsigned long Current;
@ -72,6 +73,7 @@ class OpTextProgress : public OpProgress
string OldOp;
bool NoUpdate;
bool NoDisplay;
unsigned long LastLen;
virtual void Update();
void Write(const char *S);
@ -80,7 +82,9 @@ class OpTextProgress : public OpProgress
virtual void Done();
OpTextProgress(bool NoUpdate = false) : NoUpdate(NoUpdate), LastLen(0) {};
OpTextProgress(bool NoUpdate = false) : NoUpdate(NoUpdate),
NoDisplay(false), LastLen(0) {};
OpTextProgress(Configuration &Config);
virtual ~OpTextProgress() {Done();};
};

4
apt-pkg/depcache.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: depcache.h,v 1.4 1998/09/07 05:28:35 jgg Exp $
// $Id: depcache.h,v 1.5 1998/10/02 04:39:45 jgg Exp $
/* ######################################################################
DepCache - Dependency Extension data for the cache
@ -94,7 +94,7 @@ class pkgDepCache : public pkgCache
inline bool Delete() const {return Mode == ModeDelete;};
inline bool Keep() const {return Mode == ModeKeep;};
inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
inline bool Upgradable() const {return Status == 1;};
inline bool Upgradable() const {return Status >= 1;};
inline bool Downgrade() const {return Status < 0;};
inline bool Held() const {return Status != 0 && Keep();};
inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;};

14
apt-pkg/pkgcache.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgcache.cc,v 1.8 1998/07/19 04:22:00 jgg Exp $
// $Id: pkgcache.cc,v 1.9 1998/10/02 04:39:46 jgg Exp $
/* ######################################################################
Package Cache - Accessor code for the cache
@ -336,6 +336,18 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
return Res;
}
/*}}}*/
// DepIterator::CompType - Return a string describing the compare type /*{{{*/
// ---------------------------------------------------------------------
/* This returns a string representation of the dependency compare
type */
const char *pkgCache::DepIterator::CompType()
{
const char *Ops[] = {"","<=",">=","<",">","=","!="};
if ((Dep->CompareOp & 0xF) < sizeof(Ops))
return Ops[Dep->CompareOp & 0xF];
return "";
}
/*}}}*/
// VerIterator::CompareVer - Fast version compare for same pkgs /*{{{*/
// ---------------------------------------------------------------------
/* This just looks over the version list to see if B is listed before A. In

8
apt-pkg/pkgcachegen.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgcachegen.cc,v 1.17 1998/09/26 05:34:23 jgg Exp $
// $Id: pkgcachegen.cc,v 1.18 1998/10/02 04:39:47 jgg Exp $
/* ######################################################################
Package Cache Generator - Generator for the cache structure.
@ -413,7 +413,7 @@ bool pkgSrcCacheCheck(pkgSourceList &List)
}
MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
if (_error->PendingError() == true)
if (_error->PendingError() == true || Map.Size() == 0)
{
_error->Discard();
return false;
@ -474,7 +474,7 @@ bool pkgPkgCacheCheck(string CacheFile)
}
MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
if (_error->PendingError() == true)
if (_error->PendingError() == true || Map.Size() == 0)
{
_error->Discard();
return false;
@ -565,7 +565,7 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress)
string CacheFile = _config->FindDir("Dir::Cache::pkgcache");
bool SrcOk = pkgSrcCacheCheck(List);
bool PkgOk = pkgPkgCacheCheck(CacheFile);
bool PkgOk = SrcOk && pkgPkgCacheCheck(CacheFile);
// Rebuild the source and package caches
if (SrcOk == false)

13
apt-pkg/tagfile.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: tagfile.cc,v 1.10 1998/07/19 04:42:10 jgg Exp $
// $Id: tagfile.cc,v 1.11 1998/10/02 04:39:48 jgg Exp $
/* ######################################################################
Fast scanner for RFC-822 type header information
@ -45,7 +45,10 @@ bool pkgTagFile::Step(pkgTagSection &Tag)
return false;
if (Tag.Scan(Start,End - Start) == false)
{
cout << string(Start,End-Start) << endl;
return _error->Error("Unable to parse package file");
}
}
Start += Tag.size();
iOffset += Tag.size();
@ -125,13 +128,16 @@ bool pkgTagSection::Scan(const char *Start,unsigned long MaxLength)
{
if (Stop[-1] != '\n')
continue;
// Skip line feeds
for (; Stop[0] == '\r' && Stop < End; Stop++);
if (Stop[0] == '\n')
{
// Extra one at the end to simplify find
Indexes[TagCount] = Stop - Section;
for (; Stop[0] == '\n' && Stop < End; Stop++);
for (; (Stop[0] == '\n' || Stop[0] == '\r') && Stop < End; Stop++);
return true;
break;
}
if (isspace(Stop[0]) == 0)
@ -167,6 +173,7 @@ bool pkgTagSection::Find(const char *Tag,const char *&Start,
End = Section + Indexes[I+1];
for (; (isspace(*Start) != 0 || *Start == ':') && Start < End; Start++);
for (; isspace(End[-1]) != 0 && End > Start; End--);
return true;
}
Start = End = 0;

27
cmdline/apt-cache.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: apt-cache.cc,v 1.8 1998/09/26 05:34:29 jgg Exp $
// $Id: apt-cache.cc,v 1.9 1998/10/02 04:39:55 jgg Exp $
/* ######################################################################
apt-cache - Manages the cache files
@ -222,7 +222,7 @@ bool DoAdd(CommandLine &CmdL)
return _error->Error("You must give at least one file name");
// Open the cache
FileFd CacheF(_config->FindDir("Dir::Cache::srcpkgcache"),FileFd::ReadOnly);
FileFd CacheF(_config->FindDir("Dir::Cache::srcpkgcache"),FileFd::WriteAny);
if (_error->PendingError() == true)
return false;
@ -230,7 +230,7 @@ bool DoAdd(CommandLine &CmdL)
if (_error->PendingError() == true)
return false;
OpTextProgress Progress;
OpTextProgress Progress(*_config);
pkgCacheGenerator Gen(Map,Progress);
if (_error->PendingError() == true)
return false;
@ -264,10 +264,11 @@ bool DoAdd(CommandLine &CmdL)
/* */
bool GenCaches()
{
OpTextProgress Progress;
OpTextProgress Progress(*_config);
pkgSourceList List;
List.ReadMainList();
return pkgMakeStatusCache(List,Progress);
return pkgMakeStatusCache(List,Progress);
}
/*}}}*/
// ShowHelp - Show a help screen /*{{{*/
@ -280,7 +281,7 @@ int ShowHelp()
cout << "Usage: apt-cache [options] command" << endl;
cout << " apt-cache [options] add file1 [file1 ...]" << endl;
cout << " apt-cache [options] showpkg pkg2 [pkg2 ...]" << endl;
cout << " apt-cache [options] showpkg pkg1 [pkg2 ...]" << endl;
cout << endl;
cout << "apt-cache is a low-level tool used to manipulate APT's binary" << endl;
cout << "cache files stored in " << _config->FindDir("Dir::Cache") << endl;
@ -305,6 +306,15 @@ int ShowHelp()
return 100;
}
/*}}}*/
// CacheInitialize - Initialize things for apt-cache /*{{{*/
// ---------------------------------------------------------------------
/* */
void CacheInitialize()
{
_config->Set("quiet",0);
_config->Set("help",false);
}
/*}}}*/
int main(int argc,const char *argv[])
{
@ -316,6 +326,8 @@ int main(int argc,const char *argv[])
{'c',"config-file",0,CommandLine::ConfigFile},
{'o',"option",0,CommandLine::ArbItem},
{0,0,0,0}};
CacheInitialize();
// Parse the command line and initialize the package library
CommandLine CmdL(Args,_config);
@ -389,8 +401,9 @@ int main(int argc,const char *argv[])
// Print any errors or warnings found during parsing
if (_error->empty() == false)
{
bool Errors = _error->PendingError();
_error->DumpErrors();
return 100;
return Errors == true?100:0;
}
return 0;

764
cmdline/apt-get.cc

@ -0,0 +1,764 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: apt-get.cc,v 1.1 1998/10/02 04:39:56 jgg Exp $
/* ######################################################################
apt-get - Cover for dpkg
This is an allout cover for dpkg implementing a safer front end. It is
based largely on libapt-pkg.
The syntax is different,
apt-get [opt] command [things]
Where command is:
update - Resyncronize the package files from their sources
upgrade - Smart-Download the newest versions of all packages
dselect-upgrade - Follows dselect's changes to the Status: field
and installes new and removes old packages
dist-upgrade - Powerfull upgrader designed to handle the issues with
a new distribution.
install - Download and install a given package (by name, not by .deb)
check - Update the package cache and check for broken packages
clean - Erase the .debs downloaded to /var/cache/apt/archives and
the partial dir too
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
#include <apt-pkg/error.h>
#include <apt-pkg/cmndline.h>
#include <apt-pkg/init.h>
#include <apt-pkg/depcache.h>
#include <apt-pkg/sourcelist.h>
#include <apt-pkg/pkgcachegen.h>
#include <apt-pkg/algorithms.h>
#include <config.h>
#include <fstream.h>
/*}}}*/
ostream c0out;
ostream c1out;
ostream c2out;
ofstream devnull("/dev/null");
unsigned int ScreenWidth = 80;
// ShowList - Show a list /*{{{*/
// ---------------------------------------------------------------------
/* This prints out a string of space seperated words with a title and
a two space indent line wraped to the current screen width. */
void ShowList(ostream &out,string Title,string List)
{
if (List.empty() == true)
return;
// Acount for the leading space
int ScreenWidth = ::ScreenWidth - 3;
out << Title << endl;
string::size_type Start = 0;
while (Start < List.size())
{
string::size_type End;
if (Start + ScreenWidth >= List.size())
End = List.size();
else
End = List.rfind(' ',Start+ScreenWidth);
if (End == string::npos || End < Start)
End = Start + ScreenWidth;
out << " " << string(List,Start,End - Start) << endl;
Start = End + 1;
}
}
/*}}}*/
// ShowBroken - Debugging aide /*{{{*/
// ---------------------------------------------------------------------
/* This prints out the names of all the packages that are broken along
with the name of each each broken dependency and a quite version
description. */
void ShowBroken(ostream &out,pkgDepCache &Cache)
{
out << "Sorry, but the following packages are broken - this means they have unmet" << endl;
out << "dependencies:" << endl;
pkgCache::PkgIterator I = Cache.PkgBegin();
for (;I.end() != true; I++)
{
if (Cache[I].InstBroken() == true)
{
// Print out each package and the failed dependencies
out <<" " << I.Name() << ":";
int Indent = strlen(I.Name()) + 3;
bool First = true;
for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false; D++)
{
if (Cache.IsImportantDep(D) == false || (Cache[D] &
pkgDepCache::DepInstall) != 0)
continue;
if (First == false)
for (int J = 0; J != Indent; J++)
out << ' ';
First = false;
if (D->Type == pkgCache::Dep::Conflicts)
out << " Conflicts:" << D.TargetPkg().Name();
else
out << " Depends:" << D.TargetPkg().Name();
// Show a quick summary of the version requirements
if (D.TargetVer() != 0)
out << " (" << D.CompType() << " " << D.TargetVer() <<
")" << endl;
else
out << endl;
}
}
}
}
/*}}}*/
// ShowNew - Show packages to newly install /*{{{*/
// ---------------------------------------------------------------------
/* */
void ShowNew(ostream &out,pkgDepCache &Dep)
{
/* Print out a list of packages that are going to be removed extra
to what the user asked */
pkgCache::PkgIterator I = Dep.PkgBegin();
string List;
for (;I.end() != true; I++)
if (Dep[I].NewInstall() == true)
List += string(I.Name()) + " ";
ShowList(out,"The following NEW packages will be installed:",List);
}
/*}}}*/
// ShowDel - Show packages to delete /*{{{*/
// ---------------------------------------------------------------------
/* */
void ShowDel(ostream &out,pkgDepCache &Dep)
{
/* Print out a list of packages that are going to be removed extra
to what the user asked */
pkgCache::PkgIterator I = Dep.PkgBegin();
string List;
for (;I.end() != true; I++)
if (Dep[I].Delete() == true)
List += string(I.Name()) + " ";
ShowList(out,"The following packages will be REMOVED:",List);
}
/*}}}*/
// ShowKept - Show kept packages /*{{{*/
// ---------------------------------------------------------------------
/* */
void ShowKept(ostream &out,pkgDepCache &Dep)
{
pkgCache::PkgIterator I = Dep.PkgBegin();
string List;
for (;I.end() != true; I++)
{
// Not interesting
if (Dep[I].Upgrade() == true || Dep[I].Upgradable() == false ||
I->CurrentVer == 0 || Dep[I].Delete() == true)
continue;
List += string(I.Name()) + " ";
}
ShowList(out,"The following packages have been kept back",List);
}
/*}}}*/
// ShowUpgraded - Show upgraded packages /*{{{*/
// ---------------------------------------------------------------------
/* */
void ShowUpgraded(ostream &out,pkgDepCache &Dep)
{
pkgCache::PkgIterator I = Dep.PkgBegin();
string List;
for (;I.end() != true; I++)
{
// Not interesting
if (Dep[I].Upgrade() == false || Dep[I].NewInstall() == true)
continue;
List += string(I.Name()) + " ";
}
ShowList(out,"The following packages will be upgraded",List);
}
/*}}}*/
// ShowHold - Show held but changed packages /*{{{*/
// ---------------------------------------------------------------------
/* */
void ShowHold(ostream &out,pkgDepCache &Dep)
{
pkgCache::PkgIterator I = Dep.PkgBegin();
string List;
for (;I.end() != true; I++)
{
if (Dep[I].InstallVer != (pkgCache::Version *)I.CurrentVer() &&
I->SelectedState == pkgCache::State::Hold)
List += string(I.Name()) + " ";
}
ShowList(out,"The following held packages will be changed:",List);
}
/*}}}*/
// ShowEssential - Show an essential package warning /*{{{*/
// ---------------------------------------------------------------------
/* This prints out a warning message that is not to be ignored. It shows
all essential packages and their dependents that are to be removed.
It is insanely risky to remove the dependents of an essential package! */
void ShowEssential(ostream &out,pkgDepCache &Dep)
{
pkgCache::PkgIterator I = Dep.PkgBegin();
string List;
bool *Added = new bool[Dep.HeaderP->PackageCount];
for (int I = 0; I != Dep.HeaderP->PackageCount; I++)
Added[I] = false;
for (;I.end() != true; I++)
{
if ((I->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential)
continue;
// The essential package is being removed
if (Dep[I].Delete() == true)
{
if (Added[I->ID] == false)
{
Added[I->ID] = true;
List += string(I.Name()) + " ";
}
}
if (I->CurrentVer == 0)
continue;
// Print out any essential package depenendents that are to be removed
for (pkgDepCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; D++)
{
pkgCache::PkgIterator P = D.SmartTargetPkg();
if (Dep[P].Delete() == true)
{
if (Added[P->ID] == true)
continue;
Added[P->ID] = true;
List += string(P.Name()) + " ";
}
}
}
if (List.empty() == false)
out << "WARNING: The following essential packages will be removed" << endl;
ShowList(out,"This should NOT be done unless you know exactly what you are doing!",List);
delete [] Added;
}
/*}}}*/
// Stats - Show some statistics /*{{{*/
// ---------------------------------------------------------------------
/* */
void Stats(ostream &out,pkgDepCache &Dep)
{
unsigned long Upgrade = 0;
unsigned long Install = 0;
for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; I++)
{
if (Dep[I].NewInstall() == true)
Install++;
else
if (Dep[I].Upgrade() == true)
Upgrade++;
}
out << Upgrade << " packages upgraded, " <<
Install << " newly installed, " <<
Dep.DelCount() << " to remove and " <<
Dep.KeepCount() << " not upgraded." << endl;
if (Dep.BadCount() != 0)
out << Dep.BadCount() << " packages not fully installed or removed." << endl;
}
/*}}}*/
// class CacheFile - Cover class for some dependency cache functions /*{{{*/
// ---------------------------------------------------------------------
/* */
class CacheFile
{
public:
FileFd *File;
MMap *Map;
pkgDepCache *Cache;
inline operator pkgDepCache &() {return *Cache;};
inline pkgDepCache *operator ->() {return Cache;};
inline pkgDepCache &operator *() {return *Cache;};
bool Open();
CacheFile() : File(0), Map(0), Cache(0) {};
~CacheFile()
{
delete Cache;
delete Map;
delete File;
}
};
/*}}}*/
// CacheFile::Open - Open the cache file /*{{{*/
// ---------------------------------------------------------------------
/* This routine generates the caches and then opens the dependency cache
and verifies that the system is OK. */
bool CacheFile::Open()
{
// Create a progress class
OpTextProgress Progress(*_config);
// Read the source list