[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 <apt-pkg/tagfile.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: %lu\n", Ver.Index());
	 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()+1);
   if (inst.empty() == false)
      fprintf(output, "Install: %s\n", inst.c_str()+1);
   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) == true)
      fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
   fprintf(output, "\n");

   return true;
}
									/*}}}*/
// EDSP::ReadResponse - from the given file descriptor			/*{{{*/
bool EDSP::ReadResponse(int const input, pkgDepCache &Cache) {
	FileFd in;
	in.OpenDescriptor(input, FileFd::ReadOnly);
	pkgTagFile response(&in);
	pkgTagSection section;
	while (response.Step(section) == true) {
		std::string type;
		if (section.Exists("Install") == true)
			type = "Install";
		else if (section.Exists("Remove") == true)
			type = "Remove";
		//FIXME: handle progress
		else
			continue;

		size_t const index = section.FindULL(type.c_str(), 0);
		if (index == 0) {
			_error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
			continue;
		}

		pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + index);
		Cache.SetCandidateVersion(Ver);
		if (type == "Install")
			Cache.MarkInstall(Ver.ParentPkg(), false, false);
		else if (type == "Remove")
			Cache.MarkDelete(Ver.ParentPkg(), false);
	}
	return true;
}
									/*}}}*/
// EDSP::ReadLine - first line from the given file descriptor		/*{{{*/
// ---------------------------------------------------------------------
/* Little helper method to read a complete line into a string. Similar to
   fgets but we need to use the low-level read() here as otherwise the
   listparser will be confused later on as mixing of fgets and read isn't
   a supported action according to the manpages and results are undefined */
bool EDSP::ReadLine(int const input, std::string &line) {
	char one;
	ssize_t data = 0;
	line.erase();
	line.reserve(100);
	while ((data = read(input, &one, sizeof(one))) != -1) {
		if (data != 1)
			continue;
		if (one == '\n')
			return true;
		if (one == '\r')
			continue;
		if (line.empty() == true && isblank(one) != 0)
			continue;
		line += one;
	}
	return false;
}
									/*}}}*/
// EDSP::StringToBool - convert yes/no to bool				/*{{{*/
// ---------------------------------------------------------------------
/* we are not as lazy as we are in the global StringToBool as we really
   only accept yes/no here - but we will ignore leading spaces */
bool EDSP::StringToBool(char const *answer, bool const defValue) {
   for (; isspace(*answer) != 0; ++answer);
   if (strncasecmp(answer, "yes", 3) == 0)
      return true;
   else if (strncasecmp(answer, "no", 2) == 0)
      return false;
   else
      _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer);
   return defValue;
}
									/*}}}*/
// EDSP::ReadRequest - first stanza from the given file descriptor	/*{{{*/
bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
			std::list<std::string> &remove, bool &upgrade,
			bool &distUpgrade, bool &autoRemove)
{
   install.clear();
   remove.clear();
   upgrade = false;
   distUpgrade = false;
   autoRemove = false;
   std::string line;
   while (ReadLine(input, line) == true)
   {
      // Skip empty lines before request
      if (line.empty() == true)
	 continue;
      // The first Tag must be a request, so search for it
      if (line.compare(0, 8, "Request:") != 0)
	 continue;

      while (ReadLine(input, line) == true)
      {
	 // empty lines are the end of the request
	 if (line.empty() == true)
	    return true;

	 std::list<std::string> *request = NULL;
	 if (line.compare(0, 8, "Install:") == 0)
	 {
	    line.erase(0, 8);
	    request = &install;
	 }
	 else if (line.compare(0, 7, "Remove:") == 0)
	 {
	    line.erase(0, 7);
	    request = &remove;
	 }
	 else if (line.compare(0, 8, "Upgrade:") == 0)
	    upgrade = EDSP::StringToBool(line.c_str() + 9, false);
	 else if (line.compare(0, 13, "Dist-Upgrade:") == 0)
	    distUpgrade = EDSP::StringToBool(line.c_str() + 14, false);
	 else if (line.compare(0, 11, "Autoremove:") == 0)
	    autoRemove = EDSP::StringToBool(line.c_str() + 12, false);
	 else
	    _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());

	 if (request == NULL)
	    continue;
	 size_t end = line.length();
	 do {
	    size_t begin = line.rfind(' ');
	    if (begin == std::string::npos)
	    {
	       request->push_back(line.substr(0, end));
	       break;
	    }
	    else if (begin < end)
	       request->push_back(line.substr(begin + 1, end));
	    line.erase(begin);
	    end = line.find_last_not_of(' ');
	 } while (end != std::string::npos);
      }
   }
   return false;
}
									/*}}}*/
// EDSP::ApplyRequest - first stanza from the given file descriptor	/*{{{*/
bool EDSP::ApplyRequest(std::list<std::string> const &install,
			 std::list<std::string> const &remove,
			 pkgDepCache &Cache)
{
	for (std::list<std::string>::const_iterator i = install.begin();
	     i != install.end(); ++i)
		Cache.MarkInstall(Cache.FindPkg(*i), false);

	for (std::list<std::string>::const_iterator i = remove.begin();
	     i != remove.end(); ++i)
		Cache.MarkDelete(Cache.FindPkg(*i));
	return true;
}
									/*}}}*/
// EDSP::WriteSolution - to the given file descriptor			/*{{{*/
bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
{
   bool const Debug = _config->FindB("Debug::EDSP::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>
2029276f	13	#include <apt-pkg/tagfile.h>
6d38011b DK	14
	15	#include <apti18n.h>
	16	#include <limits>
	17
	18	#include <stdio.h>
	19	/}}}/
	20
c3b85126 DK	21	// EDSP::WriteScenario - to the given file descriptor /{{{/
c3b85126 DK	22	bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output)
6d38011b DK	23	{
	24	// we could use pkgCache::DepType and ::Priority, but these would be lokalized strings…
	25	const char * const PrioMap[] = {0, "important", "required", "standard",
	26	"optional", "extra"};
	27	const char * const DepMap[] = {"", "Depends", "PreDepends", "Suggests",
	28	"Recommends" , "Conflicts", "Replaces",
	29	"Obsoletes", "Breaks", "Enhances"};
	30
	31	for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
	32	{
	33	for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
	34	{
	35	fprintf(output, "Package: %s\n", Pkg.Name());
	36	fprintf(output, "Architecture: %s\n", Ver.Arch());
	37	fprintf(output, "Version: %s\n", Ver.VerStr());
	38	if (Pkg.CurrentVer() == Ver)
	39	fprintf(output, "Installed: yes\n");
	40	if (Pkg->SelectedState == pkgCache::State::Hold)
	41	fprintf(output, "Hold: yes\n");
69a78835	42	fprintf(output, "APT-ID: %lu\n", Ver.Index());
6d38011b DK	43	fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
	44	if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
	45	fprintf(output, "Essential: yes\n");
	46	fprintf(output, "Section: %s\n", Ver.Section());
	47	if (Ver->MultiArch == pkgCache::Version::Allowed \|\| Ver->MultiArch == pkgCache::Version::AllAllowed)
	48	fprintf(output, "Multi-Arch: allowed\n");
	49	else if (Ver->MultiArch == pkgCache::Version::Foreign \|\| Ver->MultiArch == pkgCache::Version::AllForeign)
	50	fprintf(output, "Multi-Arch: foreign\n");
	51	else if (Ver->MultiArch == pkgCache::Version::Same)
	52	fprintf(output, "Multi-Arch: same\n");
	53	signed short Pin = std::numeric_limits<signed short>::min();
	54	for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {
	55	signed short const p = Cache.GetPolicy().GetPriority(File.File());
	56	if (Pin < p)
	57	Pin = p;
	58	}
	59	fprintf(output, "APT-Pin: %d\n", Pin);
	60	if (Cache.GetCandidateVer(Pkg) == Ver)
	61	fprintf(output, "APT-Candidate: yes\n");
	62	if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
	63	fprintf(output, "APT-Automatic: yes\n");
	64	std::string dependencies[pkgCache::Dep::Enhances + 1];
	65	bool orGroup = false;
	66	for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
	67	{
	68	// Ignore implicit dependencies for multiarch here
	69	if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0)
	70	continue;
	71	if (orGroup == false)
	72	dependencies[Dep->Type].append(", ");
	73	dependencies[Dep->Type].append(Dep.TargetPkg().Name());
	74	if (Dep->Version != 0)
	75	dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
	76	if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
	77	{
	78	dependencies[Dep->Type].append(" \| ");
	79	orGroup = true;
	80	}
	81	else
	82	orGroup = false;
	83	}
	84	for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
	85	if (dependencies[i].empty() == false)
	86	fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
	87	string provides;
	88	for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
	89	{
	90	// Ignore implicit provides for multiarch here
	91	if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 \|\| strcmp(Pkg.Name(),Prv.Name()) == 0)
	92	continue;
	93	provides.append(", ").append(Prv.Name());
	94	}
	95	if (provides.empty() == false)
	96	fprintf(output, "Provides: %s\n", provides.c_str()+2);
	97
	98
	99	fprintf(output, "\n");
	100	}
	101	}
	102	return true;
	103	}
	104	/}}}/
c3b85126	105	// EDSP::WriteRequest - to the given file descriptor /{{{/
93794bc9 DK	106	bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
93794bc9 DK	107	bool const DistUpgrade, bool const AutoRemove)
6d38011b	108	{
93794bc9	109	string del, inst;
6d38011b DK	110	for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
	111	{
	112	string* req;
	113	if (Cache[Pkg].Delete() == true)
	114	req = &del;
93794bc9	115	else if (Cache[Pkg].NewInstall() == true \|\| Cache[Pkg].Upgrade() == true)
6d38011b	116	req = &inst;
6d38011b DK	117	else
6d38011b DK	118	continue;
6d5bd614	119	req->append(" ").append(Pkg.FullName());
6d38011b	120	}
93794bc9	121	fprintf(output, "Request: EDSP 0.2\n");
6d38011b	122	if (del.empty() == false)
6d5bd614	123	fprintf(output, "Remove: %s\n", del.c_str()+1);
6d38011b	124	if (inst.empty() == false)
6d5bd614	125	fprintf(output, "Install: %s\n", inst.c_str()+1);
93794bc9 DK	126	if (Upgrade == true)
	127	fprintf(output, "Upgrade: yes\n");
	128	if (DistUpgrade == true)
	129	fprintf(output, "Dist-Upgrade: yes\n");
	130	if (AutoRemove == true)
	131	fprintf(output, "Autoremove: yes\n");
	132	if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
	133	fprintf(output, "Strict-Pinning: no\n");
	134	string solverpref("APT::Solver::");
	135	solverpref.append(_config->Find("APT::Solver::Name", "internal")).append("::Preferences");
6d5bd614	136	if (_config->Exists(solverpref) == true)
93794bc9	137	fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
6d5bd614	138	fprintf(output, "\n");
6d38011b	139
e3674d91 DK	140	return true;
	141	}
	142	/}}}/
2029276f DK	143	// EDSP::ReadResponse - from the given file descriptor /{{{/
	144	bool EDSP::ReadResponse(int const input, pkgDepCache &Cache) {
	145	FileFd in;
	146	in.OpenDescriptor(input, FileFd::ReadOnly);
	147	pkgTagFile response(&in);
	148	pkgTagSection section;
	149	while (response.Step(section) == true) {
	150	std::string type;
	151	if (section.Exists("Install") == true)
	152	type = "Install";
	153	else if (section.Exists("Remove") == true)
	154	type = "Remove";
	155	//FIXME: handle progress
	156	else
	157	continue;
29099cb6	158
69a78835 DK	159	size_t const index = section.FindULL(type.c_str(), 0);
	160	if (index == 0) {
	161	_error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
	162	continue;
	163	}
2029276f	164
69a78835 DK	165	pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + index);
	166	Cache.SetCandidateVersion(Ver);
	167	if (type == "Install")
	168	Cache.MarkInstall(Ver.ParentPkg(), false, false);
	169	else if (type == "Remove")
	170	Cache.MarkDelete(Ver.ParentPkg(), false);
2029276f DK	171	}
	172	return true;
	173	}
	174	/}}}/
6d5bd614 DK	175	// EDSP::ReadLine - first line from the given file descriptor /{{{/
	176	// ---------------------------------------------------------------------
	177	/* Little helper method to read a complete line into a string. Similar to
	178	fgets but we need to use the low-level read() here as otherwise the
	179	listparser will be confused later on as mixing of fgets and read isn't
2029276f	180	a supported action according to the manpages and results are undefined */
6d5bd614 DK	181	bool EDSP::ReadLine(int const input, std::string &line) {
	182	char one;
	183	ssize_t data = 0;
	184	line.erase();
	185	line.reserve(100);
	186	while ((data = read(input, &one, sizeof(one))) != -1) {
	187	if (data != 1)
	188	continue;
	189	if (one == '\n')
	190	return true;
	191	if (one == '\r')
	192	continue;
	193	if (line.empty() == true && isblank(one) != 0)
	194	continue;
	195	line += one;
	196	}
	197	return false;
	198	}
	199	/}}}/
40795fca DK	200	// EDSP::StringToBool - convert yes/no to bool /{{{/
	201	// ---------------------------------------------------------------------
	202	/* we are not as lazy as we are in the global StringToBool as we really
	203	only accept yes/no here - but we will ignore leading spaces */
	204	bool EDSP::StringToBool(char const *answer, bool const defValue) {
	205	for (; isspace(*answer) != 0; ++answer);
	206	if (strncasecmp(answer, "yes", 3) == 0)
	207	return true;
	208	else if (strncasecmp(answer, "no", 2) == 0)
	209	return false;
	210	else
	211	_error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer);
	212	return defValue;
	213	}
	214	/}}}/
6d5bd614 DK	215	// EDSP::ReadRequest - first stanza from the given file descriptor /{{{/
6d5bd614 DK	216	bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
40795fca DK	217	std::list<std::string> &remove, bool &upgrade,
40795fca DK	218	bool &distUpgrade, bool &autoRemove)
6d5bd614	219	{
40795fca DK	220	install.clear();
	221	remove.clear();
	222	upgrade = false;
	223	distUpgrade = false;
	224	autoRemove = false;
6d5bd614 DK	225	std::string line;
	226	while (ReadLine(input, line) == true)
	227	{
	228	// Skip empty lines before request
	229	if (line.empty() == true)
	230	continue;
	231	// The first Tag must be a request, so search for it
40795fca	232	if (line.compare(0, 8, "Request:") != 0)
6d5bd614 DK	233	continue;
	234
	235	while (ReadLine(input, line) == true)
	236	{
	237	// empty lines are the end of the request
	238	if (line.empty() == true)
	239	return true;
	240
	241	std::list<std::string> *request = NULL;
40795fca	242	if (line.compare(0, 8, "Install:") == 0)
6d5bd614	243	{
40795fca	244	line.erase(0, 8);
6d5bd614 DK	245	request = &install;
6d5bd614 DK	246	}
40795fca	247	else if (line.compare(0, 7, "Remove:") == 0)
6d5bd614	248	{
40795fca	249	line.erase(0, 7);
6d5bd614 DK	250	request = &remove;
6d5bd614 DK	251	}
40795fca DK	252	else if (line.compare(0, 8, "Upgrade:") == 0)
	253	upgrade = EDSP::StringToBool(line.c_str() + 9, false);
	254	else if (line.compare(0, 13, "Dist-Upgrade:") == 0)
	255	distUpgrade = EDSP::StringToBool(line.c_str() + 14, false);
	256	else if (line.compare(0, 11, "Autoremove:") == 0)
	257	autoRemove = EDSP::StringToBool(line.c_str() + 12, false);
	258	else
	259	_error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
	260
6d5bd614 DK	261	if (request == NULL)
	262	continue;
	263	size_t end = line.length();
	264	do {
	265	size_t begin = line.rfind(' ');
	266	if (begin == std::string::npos)
	267	{
40795fca	268	request->push_back(line.substr(0, end));
6d5bd614 DK	269	break;
	270	}
	271	else if (begin < end)
	272	request->push_back(line.substr(begin + 1, end));
	273	line.erase(begin);
	274	end = line.find_last_not_of(' ');
	275	} while (end != std::string::npos);
	276	}
	277	}
	278	return false;
	279	}
	280	/}}}/
	281	// EDSP::ApplyRequest - first stanza from the given file descriptor /{{{/
c3b85126	282	bool EDSP::ApplyRequest(std::list<std::string> const &install,
29099cb6 DK	283	std::list<std::string> const &remove,
29099cb6 DK	284	pkgDepCache &Cache)
6d5bd614 DK	285	{
	286	for (std::list<std::string>::const_iterator i = install.begin();
	287	i != install.end(); ++i)
	288	Cache.MarkInstall(Cache.FindPkg(*i), false);
	289
	290	for (std::list<std::string>::const_iterator i = remove.begin();
	291	i != remove.end(); ++i)
	292	Cache.MarkDelete(Cache.FindPkg(*i));
	293	return true;
	294	}
	295	/}}}/
c3b85126 DK	296	// EDSP::WriteSolution - to the given file descriptor /{{{/
c3b85126 DK	297	bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
e3674d91	298	{
6d5bd614	299	bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
e3674d91 DK	300	for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
	301	{
	302	if (Cache[Pkg].Delete() == true)
	303	fprintf(output, "Remove: %d\n", Cache.GetCandidateVer(Pkg)->ID);
	304	else if (Cache[Pkg].NewInstall() == true \|\| Cache[Pkg].Upgrade() == true)
	305	fprintf(output, "Install: %d\n", Cache.GetCandidateVer(Pkg)->ID);
	306	else
	307	continue;
	308	if (Debug == true)
	309	fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Cache.GetCandidateVer(Pkg).VerStr());
	310	fprintf(output, "\n");
	311	}
	312
6d38011b DK	313	return true;
	314	}
	315	/}}}/
c3b85126	316	bool EDSP::WriteError(std::string const &message, FILE* output) { return false; }