[apt.git] / apt-pkg / edsp.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/* ######################################################################
   Set of methods to help writing and reading everything needed for EDSP
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/edsp.h>
#include <apt-pkg/error.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/version.h>
#include <apt-pkg/policy.h>

#include <apti18n.h>
#include <limits>

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

// EDSP::WriteScenario - to the given file descriptor			/*{{{*/
bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output)
{
   // we could use pkgCache::DepType and ::Priority, but these would be lokalized strings…
   const char * const PrioMap[] = {0, "important", "required", "standard",
				   "optional", "extra"};
   const char * const DepMap[] = {"", "Depends", "PreDepends", "Suggests",
				  "Recommends" , "Conflicts", "Replaces",
				  "Obsoletes", "Breaks", "Enhances"};

   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
   {
      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
      {
	 fprintf(output, "Package: %s\n", Pkg.Name());
	 fprintf(output, "Architecture: %s\n", Ver.Arch());
	 fprintf(output, "Version: %s\n", Ver.VerStr());
	 if (Pkg.CurrentVer() == Ver)
	    fprintf(output, "Installed: yes\n");
	 if (Pkg->SelectedState == pkgCache::State::Hold)
	    fprintf(output, "Hold: yes\n");
	 fprintf(output, "APT-ID: %u\n", Ver->ID);
	 fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
	 if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
	    fprintf(output, "Essential: yes\n");
	 fprintf(output, "Section: %s\n", Ver.Section());
	 if (Ver->MultiArch == pkgCache::Version::Allowed || Ver->MultiArch == pkgCache::Version::AllAllowed)
	    fprintf(output, "Multi-Arch: allowed\n");
	 else if (Ver->MultiArch == pkgCache::Version::Foreign || Ver->MultiArch == pkgCache::Version::AllForeign)
	    fprintf(output, "Multi-Arch: foreign\n");
	 else if (Ver->MultiArch == pkgCache::Version::Same)
	    fprintf(output, "Multi-Arch: same\n");
	 signed short Pin = std::numeric_limits<signed short>::min();
	 for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {
	    signed short const p = Cache.GetPolicy().GetPriority(File.File());
	    if (Pin < p)
	       Pin = p;
	 }
	 fprintf(output, "APT-Pin: %d\n", Pin);
	 if (Cache.GetCandidateVer(Pkg) == Ver)
	    fprintf(output, "APT-Candidate: yes\n");
	 if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
	    fprintf(output, "APT-Automatic: yes\n");
	 std::string dependencies[pkgCache::Dep::Enhances + 1];
	 bool orGroup = false;
	 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
	 {
	    // Ignore implicit dependencies for multiarch here
	    if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0)
	       continue;
	    if (orGroup == false)
	       dependencies[Dep->Type].append(", ");
	    dependencies[Dep->Type].append(Dep.TargetPkg().Name());
	    if (Dep->Version != 0)
	       dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
	    if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
	    {
	       dependencies[Dep->Type].append(" | ");
	       orGroup = true;
	    }
	    else
	       orGroup = false;
	 }
	 for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
	    if (dependencies[i].empty() == false)
	       fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
	 string provides;
	 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
	 {
	    // Ignore implicit provides for multiarch here
	    if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 || strcmp(Pkg.Name(),Prv.Name()) == 0)
	       continue;
	    provides.append(", ").append(Prv.Name());
	 }
	 if (provides.empty() == false)
	    fprintf(output, "Provides: %s\n", provides.c_str()+2);


	 fprintf(output, "\n");
      }
   }
   return true;
}
									/*}}}*/
// EDSP::WriteRequest - to the given file descriptor			/*{{{*/
bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
			bool const DistUpgrade, bool const AutoRemove)
{
   string del, inst;
   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
   {
      string* req;
      if (Cache[Pkg].Delete() == true)
	 req = &del;
      else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
	 req = &inst;
      else
	 continue;
      req->append(", ").append(Pkg.FullName());
   }
   fprintf(output, "Request: EDSP 0.2\n");
   if (del.empty() == false)
      fprintf(output, "Remove: %s\n", del.c_str()+2);
   if (inst.empty() == false)
      fprintf(output, "Install: %s\n", inst.c_str()+2);
   if (Upgrade == true)
      fprintf(output, "Upgrade: yes\n");
   if (DistUpgrade == true)
      fprintf(output, "Dist-Upgrade: yes\n");
   if (AutoRemove == true)
      fprintf(output, "Autoremove: yes\n");
   if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
      fprintf(output, "Strict-Pinning: no\n");
   string solverpref("APT::Solver::");
   solverpref.append(_config->Find("APT::Solver::Name", "internal")).append("::Preferences");
   if (_config->Exists(solverpref) == false)
      fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());

   return true;
}
									/*}}}*/
bool EDSP::ReadResponse(FILE* input, pkgDepCache &Cache) { return false; }

bool EDSP::ReadRequest(FILE* input, std::list<std::string> &install,
			std::list<std::string> &remove)
{ return false; }
bool EDSP::ApplyRequest(std::list<std::string> const &install,
			 std::list<std::string> const &remove,
			 pkgDepCache &Cache)
{ return false; }
// EDSP::WriteSolution - to the given file descriptor			/*{{{*/
bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
{
   bool const Debug = _config->FindB("Debug::EDSPWriter::WriteSolution", false);
   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
   {
      if (Cache[Pkg].Delete() == true)
	 fprintf(output, "Remove: %d\n", Cache.GetCandidateVer(Pkg)->ID);
      else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
	 fprintf(output, "Install: %d\n", Cache.GetCandidateVer(Pkg)->ID);
      else
	 continue;
      if (Debug == true)
	 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Cache.GetCandidateVer(Pkg).VerStr());
      fprintf(output, "\n");
   }

   return true;
}
									/*}}}*/
bool EDSP::WriteError(std::string const &message, FILE* output) { return false; }
Commit	Line	Data
6d38011b DK	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	/* ######################################################################
	4	Set of methods to help writing and reading everything needed for EDSP
	5	##################################################################### */
	6	/}}}/
	7	// Include Files /{{{/
c3b85126	8	#include <apt-pkg/edsp.h>
6d38011b DK	9	#include <apt-pkg/error.h>
	10	#include <apt-pkg/configuration.h>
	11	#include <apt-pkg/version.h>
	12	#include <apt-pkg/policy.h>
	13
	14	#include <apti18n.h>
	15	#include <limits>
	16
	17	#include <stdio.h>
	18	/}}}/
	19
c3b85126 DK	20	// EDSP::WriteScenario - to the given file descriptor /{{{/
c3b85126 DK	21	bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output)
6d38011b DK	22	{
	23	// we could use pkgCache::DepType and ::Priority, but these would be lokalized strings…
	24	const char * const PrioMap[] = {0, "important", "required", "standard",
	25	"optional", "extra"};
	26	const char * const DepMap[] = {"", "Depends", "PreDepends", "Suggests",
	27	"Recommends" , "Conflicts", "Replaces",
	28	"Obsoletes", "Breaks", "Enhances"};
	29
	30	for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
	31	{
	32	for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
	33	{
	34	fprintf(output, "Package: %s\n", Pkg.Name());
	35	fprintf(output, "Architecture: %s\n", Ver.Arch());
	36	fprintf(output, "Version: %s\n", Ver.VerStr());
	37	if (Pkg.CurrentVer() == Ver)
	38	fprintf(output, "Installed: yes\n");
	39	if (Pkg->SelectedState == pkgCache::State::Hold)
	40	fprintf(output, "Hold: yes\n");
	41	fprintf(output, "APT-ID: %u\n", Ver->ID);
	42	fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
	43	if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
	44	fprintf(output, "Essential: yes\n");
	45	fprintf(output, "Section: %s\n", Ver.Section());
	46	if (Ver->MultiArch == pkgCache::Version::Allowed \|\| Ver->MultiArch == pkgCache::Version::AllAllowed)
	47	fprintf(output, "Multi-Arch: allowed\n");
	48	else if (Ver->MultiArch == pkgCache::Version::Foreign \|\| Ver->MultiArch == pkgCache::Version::AllForeign)
	49	fprintf(output, "Multi-Arch: foreign\n");
	50	else if (Ver->MultiArch == pkgCache::Version::Same)
	51	fprintf(output, "Multi-Arch: same\n");
	52	signed short Pin = std::numeric_limits<signed short>::min();
	53	for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {
	54	signed short const p = Cache.GetPolicy().GetPriority(File.File());
	55	if (Pin < p)
	56	Pin = p;
	57	}
	58	fprintf(output, "APT-Pin: %d\n", Pin);
	59	if (Cache.GetCandidateVer(Pkg) == Ver)
	60	fprintf(output, "APT-Candidate: yes\n");
	61	if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
	62	fprintf(output, "APT-Automatic: yes\n");
	63	std::string dependencies[pkgCache::Dep::Enhances + 1];
	64	bool orGroup = false;
	65	for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
	66	{
	67	// Ignore implicit dependencies for multiarch here
	68	if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0)
	69	continue;
	70	if (orGroup == false)
	71	dependencies[Dep->Type].append(", ");
	72	dependencies[Dep->Type].append(Dep.TargetPkg().Name());
	73	if (Dep->Version != 0)
	74	dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
	75	if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
	76	{
	77	dependencies[Dep->Type].append(" \| ");
	78	orGroup = true;
	79	}
	80	else
	81	orGroup = false;
	82	}
	83	for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
	84	if (dependencies[i].empty() == false)
	85	fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
86	string provides;
87	for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
88	{
89	// Ignore implicit provides for multiarch here
90	if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 \|\| strcmp(Pkg.Name(),Prv.Name()) == 0)
91	continue;
92	provides.append(", ").append(Prv.Name());
93	}
94	if (provides.empty() == false)
95	fprintf(output, "Provides: %s\n", provides.c_str()+2);
96
97
98	fprintf(output, "\n");
99	}
100	}
101	return true;
102	}
103	/}}}/
c3b85126	104	// EDSP::WriteRequest - to the given file descriptor /{{{/
93794bc9 DK	105	bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
93794bc9 DK	106	bool const DistUpgrade, bool const AutoRemove)
6d38011b	107	{
93794bc9	108	string del, inst;
6d38011b DK	109	for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
	110	{
	111	string* req;
	112	if (Cache[Pkg].Delete() == true)
	113	req = &del;
93794bc9	114	else if (Cache[Pkg].NewInstall() == true \|\| Cache[Pkg].Upgrade() == true)
6d38011b	115	req = &inst;
6d38011b DK	116	else
	117	continue;
	118	req->append(", ").append(Pkg.FullName());
	119	}
93794bc9	120	fprintf(output, "Request: EDSP 0.2\n");
6d38011b DK	121	if (del.empty() == false)
	122	fprintf(output, "Remove: %s\n", del.c_str()+2);
	123	if (inst.empty() == false)
	124	fprintf(output, "Install: %s\n", inst.c_str()+2);
93794bc9 DK	125	if (Upgrade == true)
	126	fprintf(output, "Upgrade: yes\n");
	127	if (DistUpgrade == true)
	128	fprintf(output, "Dist-Upgrade: yes\n");
	129	if (AutoRemove == true)
	130	fprintf(output, "Autoremove: yes\n");
	131	if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
	132	fprintf(output, "Strict-Pinning: no\n");
	133	string solverpref("APT::Solver::");
	134	solverpref.append(_config->Find("APT::Solver::Name", "internal")).append("::Preferences");
	135	if (_config->Exists(solverpref) == false)
	136	fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
6d38011b	137
e3674d91 DK	138	return true;
	139	}
	140	/}}}/
c3b85126	141	bool EDSP::ReadResponse(FILE* input, pkgDepCache &Cache) { return false; }
29099cb6	142
c3b85126	143	bool EDSP::ReadRequest(FILE* input, std::list<std::string> &install,
29099cb6 DK	144	std::list<std::string> &remove)
29099cb6 DK	145	{ return false; }
c3b85126	146	bool EDSP::ApplyRequest(std::list<std::string> const &install,
29099cb6 DK	147	std::list<std::string> const &remove,
	148	pkgDepCache &Cache)
	149	{ return false; }
c3b85126 DK	150	// EDSP::WriteSolution - to the given file descriptor /{{{/
c3b85126 DK	151	bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
e3674d91 DK	152	{
	153	bool const Debug = _config->FindB("Debug::EDSPWriter::WriteSolution", false);
	154	for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
	155	{
	156	if (Cache[Pkg].Delete() == true)
	157	fprintf(output, "Remove: %d\n", Cache.GetCandidateVer(Pkg)->ID);
	158	else if (Cache[Pkg].NewInstall() == true \|\| Cache[Pkg].Upgrade() == true)
	159	fprintf(output, "Install: %d\n", Cache.GetCandidateVer(Pkg)->ID);
	160	else
	161	continue;
	162	if (Debug == true)
	163	fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Cache.GetCandidateVer(Pkg).VerStr());
	164	fprintf(output, "\n");
	165	}
	166
6d38011b DK	167	return true;
	168	}
	169	/}}}/
c3b85126	170	bool EDSP::WriteError(std::string const &message, FILE* output) { return false; }