[apt.git] / apt-private / private-show.cc

// Includes								/*{{{*/
#include <config.h>

#include <apt-pkg/cachefile.h>
#include <apt-pkg/cacheset.h>
#include <apt-pkg/cmndline.h>
#include <apt-pkg/error.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/indexfile.h>
#include <apt-pkg/pkgrecords.h>
#include <apt-pkg/pkgsystem.h>
#include <apt-pkg/sourcelist.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/tagfile.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/depcache.h>
#include <apt-pkg/macros.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/policy.h>

#include <apt-private/private-cacheset.h>
#include <apt-private/private-output.h>
#include <apt-private/private-show.h>

#include <stdio.h>
#include <ostream>
#include <string>

#include <apti18n.h>
									/*}}}*/

static bool OpenPackagesFile(pkgCacheFile &CacheFile, pkgCache::VerIterator const &V,/*{{{*/
      FileFd &PkgF, pkgCache::VerFileIterator &Vf)
{
   pkgCache const * const Cache = CacheFile.GetPkgCache();
   if (unlikely(Cache == NULL))
      return false;

   // Find an appropriate file
   Vf = V.FileList();
   for (; Vf.end() == false; ++Vf)
      if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
	 break;
   if (Vf.end() == true)
      Vf = V.FileList();
      
   // Check and load the package list file
   pkgCache::PkgFileIterator I = Vf.File();
   if (I.IsOk() == false)
      return _error->Error(_("Package file %s is out of sync."),I.FileName());

   // Read the record
   return PkgF.Open(I.FileName(), FileFd::ReadOnly, FileFd::Extension);
}
									/*}}}*/
static APT_PURE unsigned char const* skipDescriptionFields(unsigned char const * DescP)/*{{{*/
{
   char const * const TagName = "\nDescription";
   size_t const TagLen = strlen(TagName);
   while ((DescP = (unsigned char*)strchr((char*)DescP, '\n')) != NULL)
   {
      if (DescP[1] == ' ')
	 DescP += 2;
      else if (strncmp((char*)DescP, TagName, TagLen) == 0)
	 DescP += TagLen;
      else
	 break;
   }
   if (DescP != NULL)
      ++DescP;
   return DescP;
}
									/*}}}*/
bool DisplayRecordV1(pkgCacheFile &CacheFile, pkgCache::VerIterator const &V,/*{{{*/
                   std::ostream &out)
{
   FileFd PkgF;
   pkgCache::VerFileIterator Vf;
   if (OpenPackagesFile(CacheFile, V, PkgF, Vf) == false)
      return false;

   pkgCache * const Cache = CacheFile.GetPkgCache();
   if (unlikely(Cache == NULL))
      return false;

   // Read the record (and ensure that it ends with a newline and NUL)
   unsigned char *Buffer = new unsigned char[Cache->HeaderP->MaxVerFileSize+2];
   Buffer[Vf->Size] = '\n';
   Buffer[Vf->Size+1] = '\0';
   if (PkgF.Seek(Vf->Offset) == false ||
       PkgF.Read(Buffer,Vf->Size) == false)
   {
      delete [] Buffer;
      return false;
   }

   // Get a pointer to start of Description field
   const unsigned char *DescP = (unsigned char*)strstr((char*)Buffer, "\nDescription");
   if (DescP != NULL)
      ++DescP;
   else
      DescP = Buffer + Vf->Size;

   // Write all but Description
   size_t const length = DescP - Buffer;
   if (length != 0 && FileFd::Write(STDOUT_FILENO, Buffer, length) == false)
   {
      delete [] Buffer;
      return false;
   }

   // Show the right description
   pkgRecords Recs(*Cache);
   pkgCache::DescIterator Desc = V.TranslatedDescription();
   if (Desc.end() == false)
   {
      pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
      out << "Description" << ( (strcmp(Desc.LanguageCode(),"") != 0) ? "-" : "" ) << Desc.LanguageCode() << ": " << P.LongDesc();
      out << std::endl << "Description-md5: " << Desc.md5() << std::endl;

      // Find the first field after the description (if there is any)
      DescP = skipDescriptionFields(DescP);
   }
   // else we have no translation, so we found a lonely Description-md5 -> don't skip it

   // write the rest of the buffer, but skip mixed in Descriptions* fields
   while (DescP != NULL)
   {
      const unsigned char * const Start = DescP;
      const unsigned char *End = (unsigned char*)strstr((char*)DescP, "\nDescription");
      if (End == NULL)
      {
	 End = &Buffer[Vf->Size];
	 DescP = NULL;
      }
      else
      {
	 ++End; // get the newline into the output
	 DescP = skipDescriptionFields(End + strlen("Description"));
      }
      size_t const length = End - Start;
      if (length != 0 && FileFd::Write(STDOUT_FILENO, Start, length) == false)
      {
	 delete [] Buffer;
	 return false;
      }
   }
   // write a final newline after the last field
   out << std::endl;

   delete [] Buffer;
   return true;
}
									/*}}}*/
static bool DisplayRecordV2(pkgCacheFile &CacheFile, pkgCache::VerIterator const &V,/*{{{*/
                   std::ostream &out)
{
   FileFd PkgF;
   pkgCache::VerFileIterator Vf;
   if (OpenPackagesFile(CacheFile, V, PkgF, Vf) == false)
      return false;

   // Check and load the package list file
   pkgCache::PkgFileIterator I = Vf.File();
   if (I.IsOk() == false)
      return _error->Error(_("Package file %s is out of sync."),I.FileName());

   // find matching sources.list metaindex
   pkgSourceList *SrcList = CacheFile.GetSourceList();
   pkgIndexFile *Index;
   if (SrcList->FindIndex(I, Index) == false &&
       _system->FindIndex(I, Index) == false)
      return _error->Error("Can not find indexfile for Package %s (%s)", 
                           V.ParentPkg().Name(), V.VerStr());
   std::string source_index_file = Index->Describe(true);

   // Read the record
   pkgTagSection Tags;
   pkgTagFile TagF(&PkgF);

   if (TagF.Jump(Tags, V.FileList()->Offset) == false)
      return _error->Error("Internal Error, Unable to parse a package record");

   // make size nice
   std::string installed_size;
   if (Tags.FindI("Installed-Size") > 0)
      strprintf(installed_size, "%sB", SizeToStr(Tags.FindI("Installed-Size")*1024).c_str());
   else
      installed_size = _("unknown");
   std::string package_size;
   if (Tags.FindI("Size") > 0)
      strprintf(package_size, "%sB", SizeToStr(Tags.FindI("Size")).c_str());
   else
      package_size = _("unknown");

   const char *manual_installed = nullptr;
   if (V.ParentPkg().CurrentVer() == V)
   {
      pkgDepCache *depCache = CacheFile.GetDepCache();
      if (unlikely(depCache == nullptr))
	 return false;
      pkgDepCache::StateCache &state = (*depCache)[V.ParentPkg()];
      manual_installed = !(state.Flags & pkgCache::Flag::Auto) ? "yes" : "no";
   }

   // FIXME: add verbose that does not do the removal of the tags?
   std::vector<pkgTagSection::Tag> RW;
   // delete, apt-cache show has this info and most users do not care
   RW.push_back(pkgTagSection::Tag::Remove("MD5sum"));
   RW.push_back(pkgTagSection::Tag::Remove("SHA1"));
   RW.push_back(pkgTagSection::Tag::Remove("SHA256"));
   RW.push_back(pkgTagSection::Tag::Remove("SHA512"));
   RW.push_back(pkgTagSection::Tag::Remove("Filename"));
   RW.push_back(pkgTagSection::Tag::Remove("Multi-Arch"));
   RW.push_back(pkgTagSection::Tag::Remove("Architecture"));
   RW.push_back(pkgTagSection::Tag::Remove("Conffiles"));
   // we use the translated description
   RW.push_back(pkgTagSection::Tag::Remove("Description"));
   RW.push_back(pkgTagSection::Tag::Remove("Description-md5"));
   // improve
   RW.push_back(pkgTagSection::Tag::Rewrite("Package", V.ParentPkg().FullName(true)));
   RW.push_back(pkgTagSection::Tag::Rewrite("Installed-Size", installed_size));
   RW.push_back(pkgTagSection::Tag::Remove("Size"));
   RW.push_back(pkgTagSection::Tag::Rewrite("Download-Size", package_size));
   // add
   if (manual_installed != nullptr)
      RW.push_back(pkgTagSection::Tag::Rewrite("APT-Manual-Installed", manual_installed));
   RW.push_back(pkgTagSection::Tag::Rewrite("APT-Sources", source_index_file));

   FileFd stdoutfd;
   if (stdoutfd.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly, false) == false ||
	 Tags.Write(stdoutfd, TFRewritePackageOrder, RW) == false || stdoutfd.Close() == false)
      return _error->Error("Internal Error, Unable to parse a package record");

   // write the description
   pkgCache * const Cache = CacheFile.GetPkgCache();
   if (unlikely(Cache == NULL))
      return false;
   pkgRecords Recs(*Cache);
   // FIXME: show (optionally) all available translations(?)
   pkgCache::DescIterator Desc = V.TranslatedDescription();
   if (Desc.end() == false)
   {
      pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
      out << "Description: " << P.LongDesc();
   }
   
   // write a final newline (after the description)
   out << std::endl << std::endl;

   return true;
}
									/*}}}*/
bool ShowPackage(CommandLine &CmdL)					/*{{{*/
{
   pkgCacheFile CacheFile;
   CacheSetHelperVirtuals helper(true, GlobalError::NOTICE);
   APT::CacheSetHelper::VerSelector const select = _config->FindB("APT::Cache::AllVersions", true) ?
			APT::CacheSetHelper::ALL : APT::CacheSetHelper::CANDIDATE;
   APT::VersionList const verset = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1, select, helper);
   int const ShowVersion = _config->FindI("APT::Cache::Show::Version", 1);
   for (APT::VersionList::const_iterator Ver = verset.begin(); Ver != verset.end(); ++Ver)
      if (ShowVersion <= 1)
      {
	 if (DisplayRecordV1(CacheFile, Ver, std::cout) == false)
	    return false;
      }
      else
	 if (DisplayRecordV2(CacheFile, Ver, c1out) == false)
	    return false;

   if (select == APT::CacheSetHelper::CANDIDATE)
   {
      APT::VersionList const verset_all = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1, APT::CacheSetHelper::ALL, helper);
      int const records = verset_all.size() - verset.size();
      if (records > 0)
         _error->Notice(P_("There is %i additional record. Please use the '-a' switch to see it", "There are %i additional records. Please use the '-a' switch to see them.", records), records);
   }

   if (_config->FindB("APT::Cache::ShowVirtuals", false) == true)
      for (APT::PackageSet::const_iterator Pkg = helper.virtualPkgs.begin();
	    Pkg != helper.virtualPkgs.end(); ++Pkg)
      {
	 c1out << "Package: " << Pkg.FullName(true) << std::endl;
	 c1out << "State: " << _("not a real package (virtual)") << std::endl;
	 // FIXME: show providers, see private-cacheset.h
	 //        CacheSetHelperAPTGet::showVirtualPackageErrors()
      }

   if (verset.empty() == true)
   {
      if (helper.virtualPkgs.empty() == true)
        return _error->Error(_("No packages found"));
      else
        _error->Notice(_("No packages found"));
   }

   return true;
}
									/*}}}*/
static std::string Sha1FromString(std::string const &input)		/*{{{*/
{
   // XXX: move to hashes.h: HashString::FromString() ?
   SHA1Summation sha1;
   sha1.Add(input.c_str(), input.length());
   return sha1.Result().Value();
}
									/*}}}*/
bool ShowSrcPackage(CommandLine &CmdL)					/*{{{*/
{
   pkgCacheFile CacheFile;
   pkgSourceList *List = CacheFile.GetSourceList();
   if (unlikely(List == NULL))
      return false;

   // Create the text record parsers
   pkgSrcRecords SrcRecs(*List);
   if (_error->PendingError() == true)
      return false;

   bool found = false;
   // avoid showing identical records
   std::set<std::string> seen;
   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
   {
      SrcRecs.Restart();

      pkgSrcRecords::Parser *Parse;
      bool found_this = false;
      while ((Parse = SrcRecs.Find(*I,false)) != 0) {
	 // SrcRecs.Find() will find both binary and source names
	 if (_config->FindB("APT::Cache::Only-Source", false) == true)
	    if (Parse->Package() != *I)
	       continue;
         std::string sha1str = Sha1FromString(Parse->AsStr());
         if (std::find(seen.begin(), seen.end(), sha1str) == seen.end())
         {
            std::cout << Parse->AsStr() << std::endl;;
            found = true;
            found_this = true;
            seen.insert(sha1str);
         }
      }
      if (found_this == false) {
	 _error->Warning(_("Unable to locate package %s"),*I);
	 continue;
      }
   }
   if (found == false)
      _error->Notice(_("No packages found"));
   return true;
}
									/*}}}*/
// Policy - Show the results of the preferences file			/*{{{*/
bool Policy(CommandLine &CmdL)
{
   pkgCacheFile CacheFile;
   pkgCache *Cache = CacheFile.GetPkgCache();
   pkgPolicy *Plcy = CacheFile.GetPolicy();
   pkgSourceList *SrcList = CacheFile.GetSourceList();
   if (unlikely(Cache == NULL || Plcy == NULL || SrcList == NULL))
      return false;

   // Print out all of the package files
   if (CmdL.FileList[1] == 0)
   {
      std::cout << _("Package files:") << std::endl;
      for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F.end() == false; ++F)
      {
	 if (F.Flagged(pkgCache::Flag::NoPackages))
	    continue;
	 // Locate the associated index files so we can derive a description
	 pkgIndexFile *Indx;
	 if (SrcList->FindIndex(F,Indx) == false &&
	       _system->FindIndex(F,Indx) == false)
	    return _error->Error(_("Cache is out of sync, can't x-ref a package file"));

	 printf("%4i %s\n",
	       Plcy->GetPriority(F),Indx->Describe(true).c_str());

	 // Print the reference information for the package
	 std::string Str = F.RelStr();
	 if (Str.empty() == false)
	    printf("     release %s\n",F.RelStr().c_str());
	 if (F.Site() != 0 && F.Site()[0] != 0)
	    printf("     origin %s\n",F.Site());
      }

      // Show any packages have explicit pins
      std::cout << _("Pinned packages:") << std::endl;
      pkgCache::PkgIterator I = Cache->PkgBegin();
      for (;I.end() != true; ++I)
      {
	 for (pkgCache::VerIterator V = I.VersionList(); !V.end(); ++V) {
	    auto Prio = Plcy->GetPriority(V, false);
	    if (Prio == 0)
	       continue;

	    std::cout << "     ";
	    // Print the package name and the version we are forcing to
	    ioprintf(std::cout, _("%s -> %s with priority %d\n"), I.FullName(true).c_str(), V.VerStr(), Prio);
	 }
      }
      return true;
   }

   char const * const msgInstalled = _("  Installed: ");
   char const * const msgCandidate = _("  Candidate: ");
   short const InstalledLessCandidate =
      mbstowcs(NULL, msgInstalled, 0) - mbstowcs(NULL, msgCandidate, 0);
   short const deepInstalled =
      (InstalledLessCandidate < 0 ? (InstalledLessCandidate*-1) : 0) - 1;
   short const deepCandidate =
      (InstalledLessCandidate > 0 ? (InstalledLessCandidate) : 0) - 1;

   // Print out detailed information for each package
   APT::CacheSetHelper helper(true, GlobalError::NOTICE);
   APT::PackageList pkgset = APT::PackageList::FromCommandLine(CacheFile, CmdL.FileList + 1, helper);
   for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
   {
      std::cout << Pkg.FullName(true) << ":" << std::endl;

      // Installed version
      std::cout << msgInstalled << OutputInDepth(deepInstalled, " ");
      if (Pkg->CurrentVer == 0)
	 std::cout << _("(none)") << std::endl;
      else
	 std::cout << Pkg.CurrentVer().VerStr() << std::endl;

      // Candidate Version 
      std::cout << msgCandidate << OutputInDepth(deepCandidate, " ");
      pkgCache::VerIterator V = Plcy->GetCandidateVer(Pkg);
      if (V.end() == true)
	 std::cout << _("(none)") << std::endl;
      else
	 std::cout << V.VerStr() << std::endl;

      // Show the priority tables
      std::cout << _("  Version table:") << std::endl;
      for (V = Pkg.VersionList(); V.end() == false; ++V)
      {
	 if (Pkg.CurrentVer() == V)
	    std::cout << " *** " << V.VerStr();
	 else
	    std::cout << "     " << V.VerStr();

	 std::cout << " " << Plcy->GetPriority(V) << std::endl;
	 for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; ++VF)
	 {
	    // Locate the associated index files so we can derive a description
	    pkgIndexFile *Indx;
	    if (SrcList->FindIndex(VF.File(),Indx) == false &&
		  _system->FindIndex(VF.File(),Indx) == false)
	       return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
	    printf("       %4i %s\n",Plcy->GetPriority(VF.File()),
		  Indx->Describe(true).c_str());
	 }
      }
   }
   return true;
}
									/*}}}*/
Commit	Line	Data
ee0167c4	1	// Includes /{{{/
453b82a3 DK	2	#include <config.h>
453b82a3 DK	3
b9179170	4	#include <apt-pkg/cachefile.h>
b9179170	5	#include <apt-pkg/cacheset.h>
b9179170	6	#include <apt-pkg/cmndline.h>
453b82a3	7	#include <apt-pkg/error.h>
b9179170	8	#include <apt-pkg/fileutl.h>
453b82a3	9	#include <apt-pkg/indexfile.h>
b9179170	10	#include <apt-pkg/pkgrecords.h>
b9179170	11	#include <apt-pkg/pkgsystem.h>
453b82a3 DK	12	#include <apt-pkg/sourcelist.h>
	13	#include <apt-pkg/strutl.h>
	14	#include <apt-pkg/tagfile.h>
	15	#include <apt-pkg/cacheiterators.h>
	16	#include <apt-pkg/configuration.h>
	17	#include <apt-pkg/depcache.h>
	18	#include <apt-pkg/macros.h>
	19	#include <apt-pkg/pkgcache.h>
9055d5e6	20	#include <apt-pkg/policy.h>
b9179170	21
453b82a3 DK	22	#include <apt-private/private-cacheset.h>
	23	#include <apt-private/private-output.h>
	24	#include <apt-private/private-show.h>
	25
	26	#include <stdio.h>
	27	#include <ostream>
	28	#include <string>
b9179170	29
453b82a3	30	#include <apti18n.h>
ee0167c4	31	/}}}/
b9179170	32
501cd23e DK	33	static bool OpenPackagesFile(pkgCacheFile &CacheFile, pkgCache::VerIterator const &V,/{{{/
501cd23e DK	34	FileFd &PkgF, pkgCache::VerFileIterator &Vf)
b9179170	35	{
501cd23e	36	pkgCache const * const Cache = CacheFile.GetPkgCache();
b9179170 MV	37	if (unlikely(Cache == NULL))
	38	return false;
	39
	40	// Find an appropriate file
501cd23e	41	Vf = V.FileList();
b9179170 MV	42	for (; Vf.end() == false; ++Vf)
	43	if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
	44	break;
	45	if (Vf.end() == true)
	46	Vf = V.FileList();
	47
	48	// Check and load the package list file
	49	pkgCache::PkgFileIterator I = Vf.File();
	50	if (I.IsOk() == false)
	51	return _error->Error(_("Package file %s is out of sync."),I.FileName());
	52
501cd23e DK	53	// Read the record
	54	return PkgF.Open(I.FileName(), FileFd::ReadOnly, FileFd::Extension);
	55	}
	56	/}}}/
	57	static APT_PURE unsigned char const* skipDescriptionFields(unsigned char const * DescP)/{{{/
	58	{
	59	char const * const TagName = "\nDescription";
	60	size_t const TagLen = strlen(TagName);
	61	while ((DescP = (unsigned char)strchr((char)DescP, '\n')) != NULL)
	62	{
	63	if (DescP[1] == ' ')
	64	DescP += 2;
	65	else if (strncmp((char*)DescP, TagName, TagLen) == 0)
	66	DescP += TagLen;
	67	else
	68	break;
	69	}
	70	if (DescP != NULL)
	71	++DescP;
	72	return DescP;
	73	}
	74	/}}}/
	75	bool DisplayRecordV1(pkgCacheFile &CacheFile, pkgCache::VerIterator const &V,/{{{/
	76	std::ostream &out)
	77	{
	78	FileFd PkgF;
	79	pkgCache::VerFileIterator Vf;
	80	if (OpenPackagesFile(CacheFile, V, PkgF, Vf) == false)
	81	return false;
	82
	83	pkgCache * const Cache = CacheFile.GetPkgCache();
	84	if (unlikely(Cache == NULL))
	85	return false;
	86
	87	// Read the record (and ensure that it ends with a newline and NUL)
	88	unsigned char *Buffer = new unsigned char[Cache->HeaderP->MaxVerFileSize+2];
	89	Buffer[Vf->Size] = '\n';
	90	Buffer[Vf->Size+1] = '\0';
	91	if (PkgF.Seek(Vf->Offset) == false \|\|
	92	PkgF.Read(Buffer,Vf->Size) == false)
	93	{
	94	delete [] Buffer;
	95	return false;
	96	}
	97
	98	// Get a pointer to start of Description field
	99	const unsigned char DescP = (unsigned char)strstr((char*)Buffer, "\nDescription");
	100	if (DescP != NULL)
	101	++DescP;
	102	else
	103	DescP = Buffer + Vf->Size;
	104
	105	// Write all but Description
	106	size_t const length = DescP - Buffer;
	107	if (length != 0 && FileFd::Write(STDOUT_FILENO, Buffer, length) == false)
	108	{
	109	delete [] Buffer;
	110	return false;
	111	}
	112
	113	// Show the right description
	114	pkgRecords Recs(*Cache);
	115	pkgCache::DescIterator Desc = V.TranslatedDescription();
	116	if (Desc.end() == false)
117	{
118	pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
119	out << "Description" << ( (strcmp(Desc.LanguageCode(),"") != 0) ? "-" : "" ) << Desc.LanguageCode() << ": " << P.LongDesc();
120	out << std::endl << "Description-md5: " << Desc.md5() << std::endl;
121
122	// Find the first field after the description (if there is any)
123	DescP = skipDescriptionFields(DescP);
124	}
125	// else we have no translation, so we found a lonely Description-md5 -> don't skip it
126
127	// write the rest of the buffer, but skip mixed in Descriptions* fields
128	while (DescP != NULL)
129	{
130	const unsigned char * const Start = DescP;
131	const unsigned char End = (unsigned char)strstr((char*)DescP, "\nDescription");
132	if (End == NULL)
133	{
134	End = &Buffer[Vf->Size];
135	DescP = NULL;
136	}
137	else
138	{
139	++End; // get the newline into the output
140	DescP = skipDescriptionFields(End + strlen("Description"));
141	}
142	size_t const length = End - Start;
143	if (length != 0 && FileFd::Write(STDOUT_FILENO, Start, length) == false)
144	{
145	delete [] Buffer;
146	return false;
147	}
148	}
149	// write a final newline after the last field
150	out << std::endl;
151
152	delete [] Buffer;
153	return true;
154	}
155	/}}}/
156	static bool DisplayRecordV2(pkgCacheFile &CacheFile, pkgCache::VerIterator const &V,/{{{/
157	std::ostream &out)
158	{
159	FileFd PkgF;
160	pkgCache::VerFileIterator Vf;
161	if (OpenPackagesFile(CacheFile, V, PkgF, Vf) == false)
162	return false;
163
164	// Check and load the package list file
165	pkgCache::PkgFileIterator I = Vf.File();
166	if (I.IsOk() == false)
167	return _error->Error(_("Package file %s is out of sync."),I.FileName());
168
1179953a MV	169	// find matching sources.list metaindex
	170	pkgSourceList *SrcList = CacheFile.GetSourceList();
	171	pkgIndexFile *Index;
	172	if (SrcList->FindIndex(I, Index) == false &&
	173	_system->FindIndex(I, Index) == false)
	174	return _error->Error("Can not find indexfile for Package %s (%s)",
	175	V.ParentPkg().Name(), V.VerStr());
	176	std::string source_index_file = Index->Describe(true);
	177
b9179170	178	// Read the record
b9179170 MV	179	pkgTagSection Tags;
b9179170 MV	180	pkgTagFile TagF(&PkgF);
9e51c0b6 MV	181
	182	if (TagF.Jump(Tags, V.FileList()->Offset) == false)
	183	return _error->Error("Internal Error, Unable to parse a package record");
	184
	185	// make size nice
	186	std::string installed_size;
	187	if (Tags.FindI("Installed-Size") > 0)
17622532	188	strprintf(installed_size, "%sB", SizeToStr(Tags.FindI("Installed-Size")*1024).c_str());
9e51c0b6 MV	189	else
	190	installed_size = _("unknown");
	191	std::string package_size;
	192	if (Tags.FindI("Size") > 0)
17622532	193	strprintf(package_size, "%sB", SizeToStr(Tags.FindI("Size")).c_str());
9e51c0b6 MV	194	else
	195	package_size = _("unknown");
	196
501cd23e DK	197	const char *manual_installed = nullptr;
	198	if (V.ParentPkg().CurrentVer() == V)
	199	{
	200	pkgDepCache *depCache = CacheFile.GetDepCache();
	201	if (unlikely(depCache == nullptr))
	202	return false;
	203	pkgDepCache::StateCache &state = (*depCache)[V.ParentPkg()];
85d7c0eb	204	manual_installed = !(state.Flags & pkgCache::Flag::Auto) ? "yes" : "no";
501cd23e	205	}
17622532 MV	206
17622532 MV	207	// FIXME: add verbose that does not do the removal of the tags?
88593886 DK	208	std::vector<pkgTagSection::Tag> RW;
	209	// delete, apt-cache show has this info and most users do not care
	210	RW.push_back(pkgTagSection::Tag::Remove("MD5sum"));
	211	RW.push_back(pkgTagSection::Tag::Remove("SHA1"));
	212	RW.push_back(pkgTagSection::Tag::Remove("SHA256"));
	213	RW.push_back(pkgTagSection::Tag::Remove("SHA512"));
	214	RW.push_back(pkgTagSection::Tag::Remove("Filename"));
	215	RW.push_back(pkgTagSection::Tag::Remove("Multi-Arch"));
	216	RW.push_back(pkgTagSection::Tag::Remove("Architecture"));
	217	RW.push_back(pkgTagSection::Tag::Remove("Conffiles"));
	218	// we use the translated description
	219	RW.push_back(pkgTagSection::Tag::Remove("Description"));
	220	RW.push_back(pkgTagSection::Tag::Remove("Description-md5"));
	221	// improve
90139c70	222	RW.push_back(pkgTagSection::Tag::Rewrite("Package", V.ParentPkg().FullName(true)));
88593886 DK	223	RW.push_back(pkgTagSection::Tag::Rewrite("Installed-Size", installed_size));
	224	RW.push_back(pkgTagSection::Tag::Remove("Size"));
	225	RW.push_back(pkgTagSection::Tag::Rewrite("Download-Size", package_size));
	226	// add
501cd23e DK	227	if (manual_installed != nullptr)
501cd23e DK	228	RW.push_back(pkgTagSection::Tag::Rewrite("APT-Manual-Installed", manual_installed));
88593886	229	RW.push_back(pkgTagSection::Tag::Rewrite("APT-Sources", source_index_file));
85d7c0eb	230
88593886 DK	231	FileFd stdoutfd;
	232	if (stdoutfd.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly, false) == false \|\|
	233	Tags.Write(stdoutfd, TFRewritePackageOrder, RW) == false \|\| stdoutfd.Close() == false)
9e51c0b6	234	return _error->Error("Internal Error, Unable to parse a package record");
b9179170 MV	235
b9179170 MV	236	// write the description
501cd23e DK	237	pkgCache * const Cache = CacheFile.GetPkgCache();
	238	if (unlikely(Cache == NULL))
	239	return false;
b9179170	240	pkgRecords Recs(*Cache);
2a79257e	241	// FIXME: show (optionally) all available translations(?)
b9179170 MV	242	pkgCache::DescIterator Desc = V.TranslatedDescription();
	243	if (Desc.end() == false)
	244	{
	245	pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
2a79257e	246	out << "Description: " << P.LongDesc();
b9179170 MV	247	}
	248
	249	// write a final newline (after the description)
	250	out << std::endl << std::endl;
	251
	252	return true;
	253	}
	254	/}}}/
ee0167c4	255	bool ShowPackage(CommandLine &CmdL) /{{{/
b9179170 MV	256	{
	257	pkgCacheFile CacheFile;
	258	CacheSetHelperVirtuals helper(true, GlobalError::NOTICE);
501cd23e	259	APT::CacheSetHelper::VerSelector const select = _config->FindB("APT::Cache::AllVersions", true) ?
e6f0c9bc	260	APT::CacheSetHelper::ALL : APT::CacheSetHelper::CANDIDATE;
b9179170	261	APT::VersionList const verset = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1, select, helper);
501cd23e	262	int const ShowVersion = _config->FindI("APT::Cache::Show::Version", 1);
b9179170	263	for (APT::VersionList::const_iterator Ver = verset.begin(); Ver != verset.end(); ++Ver)
501cd23e DK	264	if (ShowVersion <= 1)
	265	{
	266	if (DisplayRecordV1(CacheFile, Ver, std::cout) == false)
	267	return false;
	268	}
	269	else
	270	if (DisplayRecordV2(CacheFile, Ver, c1out) == false)
	271	return false;
b9179170	272
e6f0c9bc	273	if (select == APT::CacheSetHelper::CANDIDATE)
06293aa7	274	{
e6f0c9bc	275	APT::VersionList const verset_all = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1, APT::CacheSetHelper::ALL, helper);
6298ff8b DK	276	int const records = verset_all.size() - verset.size();
	277	if (records > 0)
	278	_error->Notice(P_("There is %i additional record. Please use the '-a' switch to see it", "There are %i additional records. Please use the '-a' switch to see them.", records), records);
06293aa7 MV	279	}
06293aa7 MV	280
501cd23e DK	281	if (_config->FindB("APT::Cache::ShowVirtuals", false) == true)
	282	for (APT::PackageSet::const_iterator Pkg = helper.virtualPkgs.begin();
	283	Pkg != helper.virtualPkgs.end(); ++Pkg)
	284	{
	285	c1out << "Package: " << Pkg.FullName(true) << std::endl;
	286	c1out << "State: " << _("not a real package (virtual)") << std::endl;
	287	// FIXME: show providers, see private-cacheset.h
	288	// CacheSetHelperAPTGet::showVirtualPackageErrors()
	289	}
b9179170 MV	290
	291	if (verset.empty() == true)
	292	{
	293	if (helper.virtualPkgs.empty() == true)
	294	return _error->Error(_("No packages found"));
	295	else
	296	_error->Notice(_("No packages found"));
	297	}
	298
	299	return true;
	300	}
	301	/}}}/
f19525d5	302	static std::string Sha1FromString(std::string const &input) /{{{/
b0ce7c65	303	{
f19525d5	304	// XXX: move to hashes.h: HashString::FromString() ?
b0ce7c65 MV	305	SHA1Summation sha1;
	306	sha1.Add(input.c_str(), input.length());
	307	return sha1.Result().Value();
	308	}
	309	/}}}/
9055d5e6 DK	310	bool ShowSrcPackage(CommandLine &CmdL) /{{{/
	311	{
	312	pkgCacheFile CacheFile;
	313	pkgSourceList *List = CacheFile.GetSourceList();
	314	if (unlikely(List == NULL))
	315	return false;
	316
	317	// Create the text record parsers
	318	pkgSrcRecords SrcRecs(*List);
	319	if (_error->PendingError() == true)
	320	return false;
	321
	322	bool found = false;
b0ce7c65 MV	323	// avoid showing identical records
b0ce7c65 MV	324	std::set<std::string> seen;
9055d5e6 DK	325	for (const char *I = CmdL.FileList + 1; I != 0; I++)
	326	{
	327	SrcRecs.Restart();
	328
	329	pkgSrcRecords::Parser *Parse;
	330	bool found_this = false;
	331	while ((Parse = SrcRecs.Find(*I,false)) != 0) {
	332	// SrcRecs.Find() will find both binary and source names
	333	if (_config->FindB("APT::Cache::Only-Source", false) == true)
	334	if (Parse->Package() != *I)
	335	continue;
b0ce7c65 MV	336	std::string sha1str = Sha1FromString(Parse->AsStr());
	337	if (std::find(seen.begin(), seen.end(), sha1str) == seen.end())
	338	{
	339	std::cout << Parse->AsStr() << std::endl;;
	340	found = true;
	341	found_this = true;
	342	seen.insert(sha1str);
	343	}
9055d5e6 DK	344	}
	345	if (found_this == false) {
	346	_error->Warning(_("Unable to locate package %s"),*I);
	347	continue;
	348	}
	349	}
	350	if (found == false)
	351	_error->Notice(_("No packages found"));
	352	return true;
	353	}
	354	/}}}/
	355	// Policy - Show the results of the preferences file /{{{/
	356	bool Policy(CommandLine &CmdL)
	357	{
	358	pkgCacheFile CacheFile;
	359	pkgCache *Cache = CacheFile.GetPkgCache();
	360	pkgPolicy *Plcy = CacheFile.GetPolicy();
	361	pkgSourceList *SrcList = CacheFile.GetSourceList();
	362	if (unlikely(Cache == NULL \|\| Plcy == NULL \|\| SrcList == NULL))
	363	return false;
	364
9055d5e6 DK	365	// Print out all of the package files
	366	if (CmdL.FileList[1] == 0)
	367	{
	368	std::cout << _("Package files:") << std::endl;
	369	for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F.end() == false; ++F)
	370	{
	371	if (F.Flagged(pkgCache::Flag::NoPackages))
	372	continue;
	373	// Locate the associated index files so we can derive a description
	374	pkgIndexFile *Indx;
	375	if (SrcList->FindIndex(F,Indx) == false &&
	376	_system->FindIndex(F,Indx) == false)
	377	return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
	378
	379	printf("%4i %s\n",
	380	Plcy->GetPriority(F),Indx->Describe(true).c_str());
	381
	382	// Print the reference information for the package
	383	std::string Str = F.RelStr();
	384	if (Str.empty() == false)
	385	printf(" release %s\n",F.RelStr().c_str());
	386	if (F.Site() != 0 && F.Site()[0] != 0)
	387	printf(" origin %s\n",F.Site());
	388	}
	389
	390	// Show any packages have explicit pins
	391	std::cout << _("Pinned packages:") << std::endl;
	392	pkgCache::PkgIterator I = Cache->PkgBegin();
	393	for (;I.end() != true; ++I)
	394	{
258b9e51	395	for (pkgCache::VerIterator V = I.VersionList(); !V.end(); ++V) {
9055d5e6 DK	396	auto Prio = Plcy->GetPriority(V, false);
	397	if (Prio == 0)
	398	continue;
	399
	400	std::cout << " ";
	401	// Print the package name and the version we are forcing to
	402	ioprintf(std::cout, _("%s -> %s with priority %d\n"), I.FullName(true).c_str(), V.VerStr(), Prio);
	403	}
	404	}
	405	return true;
	406	}
	407
	408	char const * const msgInstalled = _(" Installed: ");
	409	char const * const msgCandidate = _(" Candidate: ");
	410	short const InstalledLessCandidate =
	411	mbstowcs(NULL, msgInstalled, 0) - mbstowcs(NULL, msgCandidate, 0);
	412	short const deepInstalled =
	413	(InstalledLessCandidate < 0 ? (InstalledLessCandidate*-1) : 0) - 1;
	414	short const deepCandidate =
	415	(InstalledLessCandidate > 0 ? (InstalledLessCandidate) : 0) - 1;
	416
	417	// Print out detailed information for each package
	418	APT::CacheSetHelper helper(true, GlobalError::NOTICE);
	419	APT::PackageList pkgset = APT::PackageList::FromCommandLine(CacheFile, CmdL.FileList + 1, helper);
	420	for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
	421	{
	422	std::cout << Pkg.FullName(true) << ":" << std::endl;
	423
	424	// Installed version
	425	std::cout << msgInstalled << OutputInDepth(deepInstalled, " ");
	426	if (Pkg->CurrentVer == 0)
	427	std::cout << _("(none)") << std::endl;
	428	else
	429	std::cout << Pkg.CurrentVer().VerStr() << std::endl;
	430
	431	// Candidate Version
	432	std::cout << msgCandidate << OutputInDepth(deepCandidate, " ");
	433	pkgCache::VerIterator V = Plcy->GetCandidateVer(Pkg);
	434	if (V.end() == true)
	435	std::cout << _("(none)") << std::endl;
	436	else
	437	std::cout << V.VerStr() << std::endl;
	438
9055d5e6 DK	439	// Show the priority tables
	440	std::cout << _(" Version table:") << std::endl;
	441	for (V = Pkg.VersionList(); V.end() == false; ++V)
	442	{
	443	if (Pkg.CurrentVer() == V)
	444	std::cout << " *** " << V.VerStr();
	445	else
	446	std::cout << " " << V.VerStr();
03d6de04 JAK	447
03d6de04 JAK	448	std::cout << " " << Plcy->GetPriority(V) << std::endl;
9055d5e6 DK	449	for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; ++VF)
	450	{
	451	// Locate the associated index files so we can derive a description
	452	pkgIndexFile *Indx;
	453	if (SrcList->FindIndex(VF.File(),Indx) == false &&
	454	_system->FindIndex(VF.File(),Indx) == false)
	455	return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
	456	printf(" %4i %s\n",Plcy->GetPriority(VF.File()),
	457	Indx->Describe(true).c_str());
	458	}
	459	}
	460	}
	461	return true;
	462	}
	463	/}}}/