[apt.git] / cmdline / apt-cache.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: apt-cache.cc,v 1.24 1999/02/08 07:54:58 jgg Exp $
/* ######################################################################
   
   apt-cache - Manages the cache files
   
   apt-cache provides some functions fo manipulating the cache files.
   It uses the command line interface common to all the APT tools. The
   only really usefull function right now is dumpavail which is used
   by the dselect method. Everything else is ment as a debug aide.
   
   Returns 100 on failure, 0 on success.
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/error.h>
#include <apt-pkg/pkgcachegen.h>
#include <apt-pkg/deblistparser.h>
#include <apt-pkg/init.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/sourcelist.h>
#include <apt-pkg/cmndline.h>
#include <apt-pkg/strutl.h>
#include <config.h>

#include <iostream.h>
#include <errno.h>
									/*}}}*/

pkgCache *GCache = 0;

// UnMet - Show unmet dependencies					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool UnMet(CommandLine &CmdL)
{
   pkgCache &Cache = *GCache;
   bool Important = _config->FindB("APT::Cache::Important",false);
   
   for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
   {
      for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
      {
	 bool Header = false;
	 for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
	 {
	    // Collect or groups
	    pkgCache::DepIterator Start;
	    pkgCache::DepIterator End;
	    D.GlobOr(Start,End);
	    
/*	    cout << "s: Check " << Start.TargetPkg().Name() << ',' <<
	       End.TargetPkg().Name() << endl;*/
	       
	    // Skip conflicts and replaces
	    if (End->Type != pkgCache::Dep::PreDepends &&
		End->Type != pkgCache::Dep::Depends && 
		End->Type != pkgCache::Dep::Suggests &&
		End->Type != pkgCache::Dep::Recommends)
	       continue;

	    // Important deps only
	    if (Important == true)
	       if (End->Type != pkgCache::Dep::PreDepends &&
		   End->Type != pkgCache::Dep::Depends)
		  continue;
	    
	    // Verify the or group
	    bool OK = false;
	    pkgCache::DepIterator RealStart = Start;
	    do
	    {
	       // See if this dep is Ok
	       pkgCache::Version **VList = Start.AllTargets();
	       if (*VList != 0)
	       {
		  OK = true;
		  delete [] VList;
		  break;
	       }
	       delete [] VList;
	       
	       if (Start == End)
		  break;
	       Start++;
	    }
	    while (1);

	    // The group is OK
	    if (OK == true)
	       continue;
	    
	    // Oops, it failed..
	    if (Header == false)
		  cout << "Package " << P.Name() << " version " << 
	       V.VerStr() << " has an unmet dep:" << endl;
	    Header = true;
	    
	    // Print out the dep type
	    cout << " " << End.DepType() << ": ";

	    // Show the group
	    Start = RealStart;
	    do
	    {
	       cout << Start.TargetPkg().Name();
	       if (Start.TargetVer() != 0)
		  cout << " (" << Start.CompType() << " " << Start.TargetVer() <<
		  ")";
	       if (Start == End)
		  break;
	       cout << " | ";
	       Start++;
	    }
	    while (1);
	    
	    cout << endl;
	 }	 
      }
   }   
   return true;
}
									/*}}}*/
// DumpPackage - Show a dump of a package record			/*{{{*/
// ---------------------------------------------------------------------
/* */
bool DumpPackage(CommandLine &CmdL)
{   
   pkgCache &Cache = *GCache;
   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
   {
      pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
      if (Pkg.end() == true)
      {
	 _error->Warning("Unable to locate package %s",*I);
	 continue;
      }

      cout << "Package: " << Pkg.Name() << endl;
      cout << "Versions: ";
      for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
      {
	 cout << Cur.VerStr();
	 for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; Vf++)
	    cout << "(" << Vf.File().FileName() << ")";
	 cout << ',';
      }
      
      cout << endl;
      
      cout << "Reverse Depends: " << endl;
      for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() != true; D++)
	 cout << "  " << D.ParentPkg().Name() << ',' << D.TargetPkg().Name() << endl;

      cout << "Dependencies: " << endl;
      for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
      {
	 cout << Cur.VerStr() << " - ";
	 for (pkgCache::DepIterator Dep = Cur.DependsList(); Dep.end() != true; Dep++)
	    cout << Dep.TargetPkg().Name() << " (" << (int)Dep->CompareOp << " " << Dep.TargetVer() << ") ";
	 cout << endl;
      }      

      cout << "Provides: " << endl;
      for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
      {
	 cout << Cur.VerStr() << " - ";
	 for (pkgCache::PrvIterator Prv = Cur.ProvidesList(); Prv.end() != true; Prv++)
	    cout << Prv.ParentPkg().Name() << " ";
	 cout << endl;
      }
      cout << "Reverse Provides: " << endl;
      for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
	 cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr();
      cout << endl;
            
   }

   return true;
}
									/*}}}*/
// Stats - Dump some nice statistics					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool Stats(CommandLine &Cmd)
{
   pkgCache &Cache = *GCache;
   cout << "Total Package Names : " << Cache.Head().PackageCount << " (" <<
      SizeToStr(Cache.Head().PackageCount*Cache.Head().PackageSz) << ')' << endl;
   pkgCache::PkgIterator I = Cache.PkgBegin();
   
   int Normal = 0;
   int Virtual = 0;
   int NVirt = 0;
   int DVirt = 0;
   int Missing = 0;
   for (;I.end() != true; I++)
   {
      if (I->VersionList != 0 && I->ProvidesList == 0)
      {
	 Normal++;
	 continue;
      }

      if (I->VersionList != 0 && I->ProvidesList != 0)
      {
	 NVirt++;
	 continue;
      }
      
      if (I->VersionList == 0 && I->ProvidesList != 0)
      {
	 // Only 1 provides
	 if (I.ProvidesList()->NextProvides == 0)
	 {
	    DVirt++;
	 }
	 else
	    Virtual++;
	 continue;
      }
      if (I->VersionList == 0 && I->ProvidesList == 0)
      {
	 Missing++;
	 continue;
      }
   }
   cout << "  Normal Packages: " << Normal << endl;
   cout << "  Pure Virtual Packages: " << Virtual << endl;
   cout << "  Single Virtual Packages: " << DVirt << endl;
   cout << "  Mixed Virtual Packages: " << NVirt << endl;
   cout << "  Missing: " << Missing << endl;
   
   cout << "Total Distinct Versions: " << Cache.Head().VersionCount << " (" <<
      SizeToStr(Cache.Head().VersionCount*Cache.Head().VersionSz) << ')' << endl;
   cout << "Total Dependencies: " << Cache.Head().DependsCount << " (" << 
      SizeToStr(Cache.Head().DependsCount*Cache.Head().DependencySz) << ')' << endl;
   
   cout << "Total Ver/File relations: " << Cache.Head().VerFileCount << " (" <<
      SizeToStr(Cache.Head().VerFileCount*Cache.Head().VerFileSz) << ')' << endl;
   cout << "Total Provides Mappings: " << Cache.Head().ProvidesCount << " (" <<
      SizeToStr(Cache.Head().ProvidesCount*Cache.Head().ProvidesSz) << ')' << endl;
   
   // String list stats
   unsigned long Size = 0;
   unsigned long Count = 0;
   for (pkgCache::StringItem *I = Cache.StringItemP + Cache.Head().StringList;
        I!= Cache.StringItemP; I = Cache.StringItemP + I->NextItem)
   {
      Count++;
      Size += strlen(Cache.StrP + I->String);
   }
   cout << "Total Globbed Strings: " << Count << " (" << SizeToStr(Size) << ')' << endl;
      
   unsigned long Slack = 0;
   for (int I = 0; I != 7; I++)
      Slack += Cache.Head().Pools[I].ItemSize*Cache.Head().Pools[I].Count;
   cout << "Total Slack space: " << SizeToStr(Slack) << endl;
   
   unsigned long Total = 0;
   Total = Slack + Size + Cache.Head().DependsCount*Cache.Head().DependencySz + 
           Cache.Head().VersionCount*Cache.Head().VersionSz +
           Cache.Head().PackageCount*Cache.Head().PackageSz + 
           Cache.Head().VerFileCount*Cache.Head().VerFileSz +
           Cache.Head().ProvidesCount*Cache.Head().ProvidesSz;
   cout << "Total Space Accounted for: " << SizeToStr(Total) << endl;
   
   return true;
}
									/*}}}*/
// Check - Check some things about the cache				/*{{{*/
// ---------------------------------------------------------------------
/* Debug aide mostly */
bool Check(CommandLine &Cmd)
{
   pkgCache &Cache = *GCache;
   pkgCache::PkgIterator Pkg = Cache.PkgBegin();
   for (;Pkg.end() != true; Pkg++)
   {
      if (Pkg.Section() == 0 && Pkg->VersionList != 0)
	 cout << "Bad section " << Pkg.Name() << endl;
      
      for (pkgCache::VerIterator Cur = Pkg.VersionList(); 
	   Cur.end() != true; Cur++)
      {
	 if (Cur->Priority < 1 || Cur->Priority > 5)
	    cout << "Bad prio " << Pkg.Name() << ',' << Cur.VerStr() << " == " << (int)Cur->Priority << endl;
      }
   }
   return true;
}
									/*}}}*/
// Dump - show everything						/*{{{*/
// ---------------------------------------------------------------------
/* */
bool Dump(CommandLine &Cmd)
{
   pkgCache &Cache = *GCache;
   for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
   {
      cout << "Package: " << P.Name() << endl;
      for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
      {
	 cout << " Version: " << V.VerStr() << endl;
	 cout << "     File: " << V.FileList().File().FileName() << endl;
	 for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
	    cout << "  Depends: " << D.TargetPkg().Name() << ' ' << D.TargetVer() << endl;
      }      
   }

   for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++)
   {
      cout << "File: " << F.FileName() << endl;
      cout << " Size: " << F->Size << endl;
      cout << " ID: " << F->ID << endl;
      cout << " Flags: " << F->Flags << endl;
      cout << " Time: " << TimeRFC1123(F->mtime) << endl;
      cout << " Archive: " << F.Archive() << endl;
      cout << " Component: " << F.Component() << endl;
      cout << " Version: " << F.Version() << endl;
      cout << " Origin: " << F.Origin() << endl;
      cout << " Label: " << F.Label() << endl;
      cout << " Architecture: " << F.Architecture() << endl;
   }

   return true;
}
									/*}}}*/
// DumpAvail - Print out the available list				/*{{{*/
// ---------------------------------------------------------------------
/* This is needed to make dpkg --merge happy */
bool DumpAvail(CommandLine &Cmd)
{
   pkgCache &Cache = *GCache;
   unsigned char *Buffer = new unsigned char[Cache.HeaderP->MaxVerFileSize];

   for (pkgCache::PkgFileIterator I = Cache.FileBegin(); I.end() == false; I++)
   {
      if ((I->Flags & pkgCache::Flag::NotSource) != 0)
	 continue;
      
      if (I.IsOk() == false)
      {
	 delete [] Buffer;
	 return _error->Error("Package file %s is out of sync.",I.FileName());
      }
      
      FileFd PkgF(I.FileName(),FileFd::ReadOnly);
      if (_error->PendingError() == true)
      {
	 delete [] Buffer;
	 return false;
      }

      /* Write all of the records from this package file, we search the entire
         structure to find them */
      for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
      {
	 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
	 {
	    if (V->FileList == 0)
	       continue;
	    if (V.FileList().File() != I)
	       continue;
	    
	    // Read the record and then write it out again.
	    if (PkgF.Seek(V.FileList()->Offset) == false ||
		PkgF.Read(Buffer,V.FileList()->Size) == false ||
		write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
	    {
	       delete [] Buffer;
	       return false;
	    }	    
	 }
      }
   }
   
   return true;
}
									/*}}}*/
// DoAdd - Perform an adding operation					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool DoAdd(CommandLine &CmdL)
{
   // Make sure there is at least one argument
   if (CmdL.FileSize() <= 1)
      return _error->Error("You must give at least one file name");
   
   // Open the cache
   FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
   if (_error->PendingError() == true)
      return false;
   
   DynamicMMap Map(CacheF,MMap::Public);
   if (_error->PendingError() == true)
      return false;

   OpTextProgress Progress(*_config);
   pkgCacheGenerator Gen(Map,Progress);
   if (_error->PendingError() == true)
      return false;

   unsigned long Length = CmdL.FileSize() - 1;
   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
   {
      Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
      Progress.SubProgress(Length);

      // Do the merge
      FileFd TagF(*I,FileFd::ReadOnly);
      debListParser Parser(TagF);
      if (_error->PendingError() == true)
	 return _error->Error("Problem opening %s",*I);
      
      if (Gen.SelectFile(*I) == false)
	 return _error->Error("Problem with SelectFile");
	 
      if (Gen.MergeList(Parser) == false)
	 return _error->Error("Problem with MergeList");
   }

   Progress.Done();
   GCache = &Gen.GetCache();
   Stats(CmdL);
   
   return true;
}
									/*}}}*/
// GenCaches - Call the main cache generator				/*{{{*/
// ---------------------------------------------------------------------
/* */
bool GenCaches(CommandLine &Cmd)
{
   OpTextProgress Progress(*_config);
   
   pkgSourceList List;
   List.ReadMainList();
   return pkgMakeStatusCache(List,Progress);
}
									/*}}}*/
// ShowHelp - Show a help screen					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool ShowHelp(CommandLine &Cmd)
{
   cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
       " compiled on " << __DATE__ << "  " << __TIME__ << endl;
   if (_config->FindB("version") == true)
      return 100;
   
   cout << "Usage: apt-cache [options] command" << endl;
   cout << "       apt-cache [options] add file1 [file1 ...]" << 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->FindFile("Dir::Cache") << endl;
   cout << "It is not ment for ordinary use only as a debug aide." << endl;
   cout << endl;
   cout << "Commands:" << endl;
   cout << "   add - Add an package file to the source cache" << endl;
   cout << "   gencaches - Build both the package and source cache" << endl;
   cout << "   showpkg - Show some general information for a single package" << endl;
   cout << "   stats - Show some basic statistics" << endl;
   cout << "   dump - Show the entire file in a terse form" << endl;
   cout << "   dumpavail - Print an available file to stdout" << endl;
   cout << "   unmet - Show unmet dependencies" << endl;
   cout << "   check - Check the cache a bit" << endl;
   cout << endl;
   cout << "Options:" << endl;
   cout << "  -h   This help text." << endl;
   cout << "  -p=? The package cache. [" << _config->FindFile("Dir::Cache::pkgcache") << ']' << endl;
   cout << "  -s=? The source cache. [" << _config->FindFile("Dir::Cache::srcpkgcache") << ']' << endl;
   cout << "  -q   Disable progress indicator." << endl;
   cout << "  -i   Show only important deps for the unmet command." << endl;
   cout << "  -c=? Read this configuration file" << endl;
   cout << "  -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
   cout << "See the apt-cache(8) and apt.conf(5) manual pages for more information." << endl;
   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[])
{
   CommandLine::Args Args[] = {
      {'h',"help","help",0},
      {'v',"version","version",0},
      {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
      {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
      {'q',"quiet","quiet",CommandLine::IntLevel},
      {'i',"important","APT::Cache::Important",0},
      {'c',"config-file",0,CommandLine::ConfigFile},
      {'o',"option",0,CommandLine::ArbItem},
      {0,0,0,0}};
   CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
                                    {"add",&DoAdd},
                                    {"gencaches",&GenCaches},
                                    {0,0}};
   CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
                                    {"stats",&Stats},
                                    {"dump",&Dump},
                                    {"dumpavail",&DumpAvail},
                                    {"unmet",&UnMet},
                                    {"check",&Check},
                                    {0,0}};

   CacheInitialize();
   
   // Parse the command line and initialize the package library
   CommandLine CmdL(Args,_config);
   if (pkgInitialize(*_config) == false ||
       CmdL.Parse(argc,argv) == false)
   {
      _error->DumpErrors();
      return 100;
   }

   // See if the help should be shown
   if (_config->FindB("help") == true ||
       CmdL.FileSize() == 0)
      return ShowHelp(CmdL);

   if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
   {      
      // Open the cache file
      FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::ReadOnly);
      MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
      if (_error->PendingError() == false)
      {
	 pkgCache Cache(Map);   
	 GCache = &Cache;
	 if (_error->PendingError() == false)
	    CmdL.DispatchArg(CmdsB);
      }      
   }
   
   // Print any errors or warnings found during parsing
   if (_error->empty() == false)
   {
      bool Errors = _error->PendingError();
      _error->DumpErrors();
      return Errors == true?100:0;
   }
          
   return 0;
}
Commit	Line	Data
1164783d AL	1	// -- mode: cpp; mode: fold --
1164783d AL	2	// Description /{{{/
43981212	3	// $Id: apt-cache.cc,v 1.24 1999/02/08 07:54:58 jgg Exp $
1164783d AL	4	/* ######################################################################
1164783d AL	5
e1b74f61	6	apt-cache - Manages the cache files
1164783d	7
e1b74f61 AL	8	apt-cache provides some functions fo manipulating the cache files.
	9	It uses the command line interface common to all the APT tools. The
	10	only really usefull function right now is dumpavail which is used
	11	by the dselect method. Everything else is ment as a debug aide.
1164783d AL	12
	13	Returns 100 on failure, 0 on success.
	14
	15	##################################################################### */
	16	/}}}/
	17	// Include Files /{{{/
	18	#include <apt-pkg/error.h>
	19	#include <apt-pkg/pkgcachegen.h>
	20	#include <apt-pkg/deblistparser.h>
8efa2a3b	21	#include <apt-pkg/init.h>
404ec98e	22	#include <apt-pkg/progress.h>
880e9be4	23	#include <apt-pkg/sourcelist.h>
08e8f724	24	#include <apt-pkg/cmndline.h>
cdcc6d34	25	#include <apt-pkg/strutl.h>
43981212	26	#include <config.h>
1164783d AL	27
1164783d AL	28	#include <iostream.h>
43981212	29	#include <errno.h>
1164783d AL	30	/}}}/
1164783d AL	31
b0b4efb9 AL	32	pkgCache *GCache = 0;
b0b4efb9 AL	33
cc718e9a AL	34	// UnMet - Show unmet dependencies /{{{/
	35	// ---------------------------------------------------------------------
	36	/* */
b0b4efb9	37	bool UnMet(CommandLine &CmdL)
cc718e9a	38	{
b0b4efb9	39	pkgCache &Cache = *GCache;
76fbce56	40	bool Important = _config->FindB("APT::Cache::Important",false);
018f1533	41
cc718e9a AL	42	for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
	43	{
	44	for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
	45	{
	46	bool Header = false;
018f1533	47	for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
cc718e9a AL	48	{
	49	// Collect or groups
	50	pkgCache::DepIterator Start;
	51	pkgCache::DepIterator End;
	52	D.GlobOr(Start,End);
	53
018f1533 AL	54	/* cout << "s: Check " << Start.TargetPkg().Name() << ',' <<
	55	End.TargetPkg().Name() << endl;*/
	56
	57	// Skip conflicts and replaces
cc718e9a AL	58	if (End->Type != pkgCache::Dep::PreDepends &&
	59	End->Type != pkgCache::Dep::Depends &&
	60	End->Type != pkgCache::Dep::Suggests &&
	61	End->Type != pkgCache::Dep::Recommends)
	62	continue;
	63
018f1533 AL	64	// Important deps only
	65	if (Important == true)
	66	if (End->Type != pkgCache::Dep::PreDepends &&
	67	End->Type != pkgCache::Dep::Depends)
	68	continue;
	69
cc718e9a AL	70	// Verify the or group
	71	bool OK = false;
	72	pkgCache::DepIterator RealStart = Start;
	73	do
	74	{
	75	// See if this dep is Ok
	76	pkgCache::Version **VList = Start.AllTargets();
	77	if (*VList != 0)
	78	{
	79	OK = true;
	80	delete [] VList;
	81	break;
	82	}
	83	delete [] VList;
	84
	85	if (Start == End)
	86	break;
	87	Start++;
	88	}
	89	while (1);
	90
	91	// The group is OK
	92	if (OK == true)
	93	continue;
	94
	95	// Oops, it failed..
	96	if (Header == false)
	97	cout << "Package " << P.Name() << " version " <<
	98	V.VerStr() << " has an unmet dep:" << endl;
	99	Header = true;
	100
	101	// Print out the dep type
	102	cout << " " << End.DepType() << ": ";
	103
	104	// Show the group
	105	Start = RealStart;
	106	do
	107	{
	108	cout << Start.TargetPkg().Name();
	109	if (Start.TargetVer() != 0)
	110	cout << " (" << Start.CompType() << " " << Start.TargetVer() <<
	111	")";
	112	if (Start == End)
	113	break;
	114	cout << " \| ";
	115	Start++;
	116	}
	117	while (1);
	118
	119	cout << endl;
	120	}
	121	}
	122	}
	123	return true;
	124	}
	125	/}}}/
1164783d AL	126	// DumpPackage - Show a dump of a package record /{{{/
	127	// ---------------------------------------------------------------------
	128	/* */
b0b4efb9	129	bool DumpPackage(CommandLine &CmdL)
ad00ae81	130	{
b0b4efb9	131	pkgCache &Cache = *GCache;
e1b74f61	132	for (const char *I = CmdL.FileList + 1; I != 0; I++)
1164783d	133	{
e1b74f61	134	pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
1164783d AL	135	if (Pkg.end() == true)
1164783d AL	136	{
e1b74f61	137	_error->Warning("Unable to locate package %s",*I);
1164783d AL	138	continue;
	139	}
	140
	141	cout << "Package: " << Pkg.Name() << endl;
	142	cout << "Versions: ";
	143	for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
03e39e59 AL	144	{
	145	cout << Cur.VerStr();
	146	for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; Vf++)
	147	cout << "(" << Vf.File().FileName() << ")";
	148	cout << ',';
	149	}
	150
1164783d AL	151	cout << endl;
	152
	153	cout << "Reverse Depends: " << endl;
	154	for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() != true; D++)
	155	cout << " " << D.ParentPkg().Name() << ',' << D.TargetPkg().Name() << endl;
	156
	157	cout << "Dependencies: " << endl;
	158	for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
	159	{
	160	cout << Cur.VerStr() << " - ";
	161	for (pkgCache::DepIterator Dep = Cur.DependsList(); Dep.end() != true; Dep++)
	162	cout << Dep.TargetPkg().Name() << " (" << (int)Dep->CompareOp << " " << Dep.TargetVer() << ") ";
	163	cout << endl;
	164	}
	165
	166	cout << "Provides: " << endl;
	167	for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
	168	{
	169	cout << Cur.VerStr() << " - ";
	170	for (pkgCache::PrvIterator Prv = Cur.ProvidesList(); Prv.end() != true; Prv++)
	171	cout << Prv.ParentPkg().Name() << " ";
	172	cout << endl;
8efa2a3b AL	173	}
	174	cout << "Reverse Provides: " << endl;
	175	for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
	176	cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr();
	177	cout << endl;
03e39e59	178
1164783d AL	179	}
	180
	181	return true;
	182	}
	183	/}}}/
	184	// Stats - Dump some nice statistics /{{{/
	185	// ---------------------------------------------------------------------
	186	/* */
b0b4efb9	187	bool Stats(CommandLine &Cmd)
1164783d	188	{
b0b4efb9	189	pkgCache &Cache = *GCache;
f826cfaa AL	190	cout << "Total Package Names : " << Cache.Head().PackageCount << " (" <<
f826cfaa AL	191	SizeToStr(Cache.Head().PackageCount*Cache.Head().PackageSz) << ')' << endl;
1164783d AL	192	pkgCache::PkgIterator I = Cache.PkgBegin();
	193
	194	int Normal = 0;
	195	int Virtual = 0;
	196	int NVirt = 0;
	197	int DVirt = 0;
	198	int Missing = 0;
	199	for (;I.end() != true; I++)
	200	{
	201	if (I->VersionList != 0 && I->ProvidesList == 0)
	202	{
	203	Normal++;
	204	continue;
	205	}
	206
	207	if (I->VersionList != 0 && I->ProvidesList != 0)
	208	{
	209	NVirt++;
	210	continue;
	211	}
	212
	213	if (I->VersionList == 0 && I->ProvidesList != 0)
	214	{
	215	// Only 1 provides
	216	if (I.ProvidesList()->NextProvides == 0)
	217	{
	218	DVirt++;
	219	}
	220	else
	221	Virtual++;
	222	continue;
	223	}
	224	if (I->VersionList == 0 && I->ProvidesList == 0)
	225	{
	226	Missing++;
	227	continue;
	228	}
	229	}
	230	cout << " Normal Packages: " << Normal << endl;
	231	cout << " Pure Virtual Packages: " << Virtual << endl;
	232	cout << " Single Virtual Packages: " << DVirt << endl;
	233	cout << " Mixed Virtual Packages: " << NVirt << endl;
	234	cout << " Missing: " << Missing << endl;
	235
f826cfaa AL	236	cout << "Total Distinct Versions: " << Cache.Head().VersionCount << " (" <<
	237	SizeToStr(Cache.Head().VersionCount*Cache.Head().VersionSz) << ')' << endl;
	238	cout << "Total Dependencies: " << Cache.Head().DependsCount << " (" <<
	239	SizeToStr(Cache.Head().DependsCount*Cache.Head().DependencySz) << ')' << endl;
	240
a7e66b17 AL	241	cout << "Total Ver/File relations: " << Cache.Head().VerFileCount << " (" <<
	242	SizeToStr(Cache.Head().VerFileCount*Cache.Head().VerFileSz) << ')' << endl;
	243	cout << "Total Provides Mappings: " << Cache.Head().ProvidesCount << " (" <<
	244	SizeToStr(Cache.Head().ProvidesCount*Cache.Head().ProvidesSz) << ')' << endl;
f826cfaa AL	245
	246	// String list stats
	247	unsigned long Size = 0;
	248	unsigned long Count = 0;
	249	for (pkgCache::StringItem *I = Cache.StringItemP + Cache.Head().StringList;
	250	I!= Cache.StringItemP; I = Cache.StringItemP + I->NextItem)
	251	{
	252	Count++;
	253	Size += strlen(Cache.StrP + I->String);
	254	}
	255	cout << "Total Globbed Strings: " << Count << " (" << SizeToStr(Size) << ')' << endl;
	256
	257	unsigned long Slack = 0;
	258	for (int I = 0; I != 7; I++)
	259	Slack += Cache.Head().Pools[I].ItemSize*Cache.Head().Pools[I].Count;
	260	cout << "Total Slack space: " << SizeToStr(Slack) << endl;
	261
	262	unsigned long Total = 0;
	263	Total = Slack + Size + Cache.Head().DependsCount*Cache.Head().DependencySz +
	264	Cache.Head().VersionCount*Cache.Head().VersionSz +
a7e66b17 AL	265	Cache.Head().PackageCount*Cache.Head().PackageSz +
	266	Cache.Head().VerFileCount*Cache.Head().VerFileSz +
	267	Cache.Head().ProvidesCount*Cache.Head().ProvidesSz;
f826cfaa AL	268	cout << "Total Space Accounted for: " << SizeToStr(Total) << endl;
f826cfaa AL	269
1164783d AL	270	return true;
	271	}
	272	/}}}/
83d89a9f AL	273	// Check - Check some things about the cache /{{{/
	274	// ---------------------------------------------------------------------
	275	/* Debug aide mostly */
b0b4efb9	276	bool Check(CommandLine &Cmd)
83d89a9f	277	{
b0b4efb9	278	pkgCache &Cache = *GCache;
83d89a9f AL	279	pkgCache::PkgIterator Pkg = Cache.PkgBegin();
	280	for (;Pkg.end() != true; Pkg++)
	281	{
	282	if (Pkg.Section() == 0 && Pkg->VersionList != 0)
	283	cout << "Bad section " << Pkg.Name() << endl;
	284
	285	for (pkgCache::VerIterator Cur = Pkg.VersionList();
	286	Cur.end() != true; Cur++)
	287	{
	288	if (Cur->Priority < 1 \|\| Cur->Priority > 5)
	289	cout << "Bad prio " << Pkg.Name() << ',' << Cur.VerStr() << " == " << (int)Cur->Priority << endl;
	290	}
	291	}
	292	return true;
	293	}
	294	/}}}/
1164783d AL	295	// Dump - show everything /{{{/
	296	// ---------------------------------------------------------------------
	297	/* */
b0b4efb9	298	bool Dump(CommandLine &Cmd)
1164783d	299	{
b0b4efb9	300	pkgCache &Cache = *GCache;
1164783d AL	301	for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
	302	{
	303	cout << "Package: " << P.Name() << endl;
	304	for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
	305	{
	306	cout << " Version: " << V.VerStr() << endl;
	307	cout << " File: " << V.FileList().File().FileName() << endl;
	308	for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
	309	cout << " Depends: " << D.TargetPkg().Name() << ' ' << D.TargetVer() << endl;
	310	}
	311	}
	312
	313	for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++)
	314	{
	315	cout << "File: " << F.FileName() << endl;
	316	cout << " Size: " << F->Size << endl;
	317	cout << " ID: " << F->ID << endl;
	318	cout << " Flags: " << F->Flags << endl;
b0b4efb9 AL	319	cout << " Time: " << TimeRFC1123(F->mtime) << endl;
	320	cout << " Archive: " << F.Archive() << endl;
	321	cout << " Component: " << F.Component() << endl;
	322	cout << " Version: " << F.Version() << endl;
	323	cout << " Origin: " << F.Origin() << endl;
	324	cout << " Label: " << F.Label() << endl;
	325	cout << " Architecture: " << F.Architecture() << endl;
1164783d AL	326	}
	327
	328	return true;
	329	}
	330	/}}}/
	331	// DumpAvail - Print out the available list /{{{/
	332	// ---------------------------------------------------------------------
	333	/* This is needed to make dpkg --merge happy */
b0b4efb9	334	bool DumpAvail(CommandLine &Cmd)
1164783d	335	{
b0b4efb9	336	pkgCache &Cache = *GCache;
ad00ae81	337	unsigned char *Buffer = new unsigned char[Cache.HeaderP->MaxVerFileSize];
1164783d	338
ad00ae81	339	for (pkgCache::PkgFileIterator I = Cache.FileBegin(); I.end() == false; I++)
1164783d	340	{
ad00ae81	341	if ((I->Flags & pkgCache::Flag::NotSource) != 0)
1164783d AL	342	continue;
1164783d AL	343
ad00ae81 AL	344	if (I.IsOk() == false)
	345	{
	346	delete [] Buffer;
	347	return _error->Error("Package file %s is out of sync.",I.FileName());
	348	}
1164783d	349
8e06abb2	350	FileFd PkgF(I.FileName(),FileFd::ReadOnly);
ad00ae81	351	if (_error->PendingError() == true)
1164783d	352	{
ad00ae81 AL	353	delete [] Buffer;
	354	return false;
	355	}
	356
	357	/* Write all of the records from this package file, we search the entire
	358	structure to find them */
	359	for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
	360	{
	361	for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
1164783d	362	{
ad00ae81 AL	363	if (V->FileList == 0)
	364	continue;
	365	if (V.FileList().File() != I)
	366	continue;
	367
	368	// Read the record and then write it out again.
	369	if (PkgF.Seek(V.FileList()->Offset) == false \|\|
	370	PkgF.Read(Buffer,V.FileList()->Size) == false \|\|
	371	write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
	372	{
	373	delete [] Buffer;
	374	return false;
	375	}
1164783d	376	}
1164783d	377	}
ad00ae81 AL	378	}
	379
	380	return true;
	381	}
	382	/}}}/
	383	// DoAdd - Perform an adding operation /{{{/
	384	// ---------------------------------------------------------------------
	385	/* */
e1b74f61	386	bool DoAdd(CommandLine &CmdL)
ad00ae81	387	{
e1b74f61 AL	388	// Make sure there is at least one argument
	389	if (CmdL.FileSize() <= 1)
	390	return _error->Error("You must give at least one file name");
ad00ae81 AL	391
ad00ae81 AL	392	// Open the cache
018f1533	393	FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
ad00ae81 AL	394	if (_error->PendingError() == true)
	395	return false;
	396
	397	DynamicMMap Map(CacheF,MMap::Public);
	398	if (_error->PendingError() == true)
	399	return false;
404ec98e	400
0a8e3465	401	OpTextProgress Progress(*_config);
404ec98e	402	pkgCacheGenerator Gen(Map,Progress);
ad00ae81 AL	403	if (_error->PendingError() == true)
	404	return false;
	405
e1b74f61 AL	406	unsigned long Length = CmdL.FileSize() - 1;
e1b74f61 AL	407	for (const char *I = CmdL.FileList + 1; I != 0; I++)
ad00ae81	408	{
e1b74f61	409	Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
018f1533 AL	410	Progress.SubProgress(Length);
018f1533 AL	411
ad00ae81	412	// Do the merge
e1b74f61	413	FileFd TagF(*I,FileFd::ReadOnly);
ad00ae81 AL	414	debListParser Parser(TagF);
ad00ae81 AL	415	if (_error->PendingError() == true)
e1b74f61	416	return _error->Error("Problem opening %s",*I);
ad00ae81	417
e1b74f61	418	if (Gen.SelectFile(*I) == false)
ad00ae81 AL	419	return _error->Error("Problem with SelectFile");
	420
	421	if (Gen.MergeList(Parser) == false)
	422	return _error->Error("Problem with MergeList");
1164783d	423	}
404ec98e AL	424
404ec98e AL	425	Progress.Done();
b0b4efb9 AL	426	GCache = &Gen.GetCache();
b0b4efb9 AL	427	Stats(CmdL);
ad00ae81	428
1164783d AL	429	return true;
	430	}
	431	/}}}/
880e9be4 AL	432	// GenCaches - Call the main cache generator /{{{/
	433	// ---------------------------------------------------------------------
	434	/* */
b0b4efb9	435	bool GenCaches(CommandLine &Cmd)
880e9be4	436	{
0a8e3465 AL	437	OpTextProgress Progress(*_config);
0a8e3465 AL	438
880e9be4 AL	439	pkgSourceList List;
880e9be4 AL	440	List.ReadMainList();
0a8e3465	441	return pkgMakeStatusCache(List,Progress);
880e9be4 AL	442	}
880e9be4 AL	443	/}}}/
e1b74f61 AL	444	// ShowHelp - Show a help screen /{{{/
	445	// ---------------------------------------------------------------------
	446	/* */
b0b4efb9	447	bool ShowHelp(CommandLine &Cmd)
e1b74f61 AL	448	{
	449	cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
	450	" compiled on " << __DATE__ << " " << __TIME__ << endl;
04aa15a8 AL	451	if (_config->FindB("version") == true)
04aa15a8 AL	452	return 100;
e1b74f61 AL	453
	454	cout << "Usage: apt-cache [options] command" << endl;
	455	cout << " apt-cache [options] add file1 [file1 ...]" << endl;
0a8e3465	456	cout << " apt-cache [options] showpkg pkg1 [pkg2 ...]" << endl;
e1b74f61 AL	457	cout << endl;
e1b74f61 AL	458	cout << "apt-cache is a low-level tool used to manipulate APT's binary" << endl;
303a1703	459	cout << "cache files stored in " << _config->FindFile("Dir::Cache") << endl;
e1b74f61 AL	460	cout << "It is not ment for ordinary use only as a debug aide." << endl;
	461	cout << endl;
	462	cout << "Commands:" << endl;
	463	cout << " add - Add an package file to the source cache" << endl;
	464	cout << " gencaches - Build both the package and source cache" << endl;
	465	cout << " showpkg - Show some general information for a single package" << endl;
	466	cout << " stats - Show some basic statistics" << endl;
	467	cout << " dump - Show the entire file in a terse form" << endl;
	468	cout << " dumpavail - Print an available file to stdout" << endl;
cc718e9a	469	cout << " unmet - Show unmet dependencies" << endl;
83d89a9f	470	cout << " check - Check the cache a bit" << endl;
e1b74f61 AL	471	cout << endl;
	472	cout << "Options:" << endl;
	473	cout << " -h This help text." << endl;
303a1703 AL	474	cout << " -p=? The package cache. [" << _config->FindFile("Dir::Cache::pkgcache") << ']' << endl;
303a1703 AL	475	cout << " -s=? The source cache. [" << _config->FindFile("Dir::Cache::srcpkgcache") << ']' << endl;
85f72a56 AL	476	cout << " -q Disable progress indicator." << endl;
85f72a56 AL	477	cout << " -i Show only important deps for the unmet command." << endl;
e1b74f61 AL	478	cout << " -c=? Read this configuration file" << endl;
e1b74f61 AL	479	cout << " -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
21ae3cae	480	cout << "See the apt-cache(8) and apt.conf(5) manual pages for more information." << endl;
e1b74f61 AL	481	return 100;
	482	}
	483	/}}}/
0a8e3465 AL	484	// CacheInitialize - Initialize things for apt-cache /{{{/
	485	// ---------------------------------------------------------------------
	486	/* */
	487	void CacheInitialize()
	488	{
	489	_config->Set("quiet",0);
	490	_config->Set("help",false);
	491	}
	492	/}}}/
1164783d	493
08e8f724	494	int main(int argc,const char *argv[])
1164783d	495	{
08e8f724 AL	496	CommandLine::Args Args[] = {
08e8f724 AL	497	{'h',"help","help",0},
04aa15a8	498	{'v',"version","version",0},
e1b74f61 AL	499	{'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
	500	{'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
	501	{'q',"quiet","quiet",CommandLine::IntLevel},
76fbce56	502	{'i',"important","APT::Cache::Important",0},
e1b74f61 AL	503	{'c',"config-file",0,CommandLine::ConfigFile},
e1b74f61 AL	504	{'o',"option",0,CommandLine::ArbItem},
08e8f724	505	{0,0,0,0}};
b0b4efb9 AL	506	CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
	507	{"add",&DoAdd},
	508	{"gencaches",&GenCaches},
	509	{0,0}};
	510	CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
	511	{"stats",&Stats},
	512	{"dump",&Dump},
	513	{"dumpavail",&DumpAvail},
	514	{"unmet",&UnMet},
	515	{"check",&Check},
	516	{0,0}};
0a8e3465 AL	517
0a8e3465 AL	518	CacheInitialize();
e1b74f61 AL	519
	520	// Parse the command line and initialize the package library
	521	CommandLine CmdL(Args,_config);
08e8f724	522	if (pkgInitialize(*_config) == false \|\|
e1b74f61	523	CmdL.Parse(argc,argv) == false)
08e8f724 AL	524	{
	525	_error->DumpErrors();
	526	return 100;
1164783d	527	}
8efa2a3b	528
e1b74f61 AL	529	// See if the help should be shown
	530	if (_config->FindB("help") == true \|\|
	531	CmdL.FileSize() == 0)
b0b4efb9	532	return ShowHelp(CmdL);
880e9be4	533
b0b4efb9 AL	534	if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
b0b4efb9 AL	535	{
ad00ae81	536	// Open the cache file
303a1703	537	FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::ReadOnly);
ad00ae81	538	MMap Map(CacheF,MMap::Public \| MMap::ReadOnly);
b0b4efb9	539	if (_error->PendingError() == false)
1164783d	540	{
b0b4efb9 AL	541	pkgCache Cache(Map);
	542	GCache = &Cache;
	543	if (_error->PendingError() == false)
	544	CmdL.DispatchArg(CmdsB);
	545	}
1164783d AL	546	}
	547
	548	// Print any errors or warnings found during parsing
	549	if (_error->empty() == false)
	550	{
0a8e3465	551	bool Errors = _error->PendingError();
1164783d	552	_error->DumpErrors();
0a8e3465	553	return Errors == true?100:0;
1164783d AL	554	}
	555
	556	return 0;
	557	}