[apt.git] / apt-pkg / deb / debsystem.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: debsystem.cc,v 1.4 2004/01/26 17:01:53 mdz Exp $
/* ######################################################################

   System - Abstraction for running on different systems.

   Basic general structure..
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <config.h>

#include <apt-pkg/debsystem.h>
#include <apt-pkg/debversion.h>
#include <apt-pkg/debindexfile.h>
#include <apt-pkg/dpkgpm.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/error.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>

#include <algorithm>

#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>

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

using std::string;

debSystem debSys;

class APT_HIDDEN debSystemPrivate {
public:
   debSystemPrivate() : LockFD(-1), LockCount(0), StatusFile(0)
   {
   }
   // For locking support
   int LockFD;
   unsigned LockCount;
   
   debStatusIndex *StatusFile;
};

// System::debSystem - Constructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
debSystem::debSystem() : pkgSystem("Debian dpkg interface", &debVS), d(new debSystemPrivate())
{
}
									/*}}}*/
// System::~debSystem - Destructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
debSystem::~debSystem()
{
   delete d->StatusFile;
   delete d;
}
									/*}}}*/
// System::Lock - Get the lock						/*{{{*/
// ---------------------------------------------------------------------
/* This mirrors the operations dpkg does when it starts up. Note the
   checking of the updates directory. */
bool debSystem::Lock()
{
   // Disable file locking
   if (_config->FindB("Debug::NoLocking",false) == true || d->LockCount > 1)
   {
      d->LockCount++;
      return true;
   }

   // Create the lockfile
   string AdminDir = flNotFile(_config->Find("Dir::State::status"));
   d->LockFD = GetLock(AdminDir + "lock");
   if (d->LockFD == -1)
   {
      if (errno == EACCES || errno == EAGAIN)
	 return _error->Error(_("Unable to lock the administration directory (%s), "
	                        "is another process using it?"),AdminDir.c_str());
      else
	 return _error->Error(_("Unable to lock the administration directory (%s), "
	                        "are you root?"),AdminDir.c_str());
   }
   
   // See if we need to abort with a dirty journal
   if (CheckUpdates() == true)
   {
      close(d->LockFD);
      d->LockFD = -1;
      const char *cmd;
      if (getenv("SUDO_USER") != NULL)
	 cmd = "sudo dpkg --configure -a";
      else
	 cmd = "dpkg --configure -a";
      // TRANSLATORS: the %s contains the recovery command, usually
      //              dpkg --configure -a
      return _error->Error(_("dpkg was interrupted, you must manually "
                             "run '%s' to correct the problem. "), cmd);
   }

	 d->LockCount++;
      
   return true;
}
									/*}}}*/
// System::UnLock - Drop a lock						/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debSystem::UnLock(bool NoErrors)
{
   if (d->LockCount == 0 && NoErrors == true)
      return false;
   
   if (d->LockCount < 1)
      return _error->Error(_("Not locked"));
   if (--d->LockCount == 0)
   {
      close(d->LockFD);
      d->LockCount = 0;
   }
   
   return true;
}
									/*}}}*/
// System::CheckUpdates - Check if the updates dir is dirty		/*{{{*/
// ---------------------------------------------------------------------
/* This does a check of the updates directory (dpkg journal) to see if it has 
   any entries in it. */
bool debSystem::CheckUpdates()
{
   // Check for updates.. (dirty)
   string File = flNotFile(_config->Find("Dir::State::status")) + "updates/";
   DIR *DirP = opendir(File.c_str());
   if (DirP == 0)
      return false;
   
   /* We ignore any files that are not all digits, this skips .,.. and 
      some tmp files dpkg will leave behind.. */
   bool Damaged = false;
   for (struct dirent *Ent = readdir(DirP); Ent != 0; Ent = readdir(DirP))
   {
      Damaged = true;
      for (unsigned int I = 0; Ent->d_name[I] != 0; I++)
      {
	 // Check if its not a digit..
	 if (isdigit(Ent->d_name[I]) == 0)
	 {
	    Damaged = false;
	    break;
	 }
      }
      if (Damaged == true)
	 break;
   }
   closedir(DirP);

   return Damaged;
}
									/*}}}*/
// System::CreatePM - Create the underlying package manager		/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgPackageManager *debSystem::CreatePM(pkgDepCache *Cache) const
{
   return new pkgDPkgPM(Cache);
}
									/*}}}*/
// System::Initialize - Setup the configuration space..			/*{{{*/
// ---------------------------------------------------------------------
/* These are the Debian specific configuration variables.. */
bool debSystem::Initialize(Configuration &Cnf)
{
   /* These really should be jammed into a generic 'Local Database' engine
      which is yet to be determined. The functions in pkgcachegen should
      be the only users of these */
   Cnf.CndSet("Dir::State::extended_states", "extended_states");
   Cnf.CndSet("Dir::State::status","/var/lib/dpkg/status");
   Cnf.CndSet("Dir::Bin::dpkg","/usr/bin/dpkg");

   if (d->StatusFile) {
     delete d->StatusFile;
     d->StatusFile = 0;
   }

   return true;
}
									/*}}}*/
// System::ArchiveSupported - Is a file format supported		/*{{{*/
// ---------------------------------------------------------------------
/* The standard name for a deb is 'deb'.. There are no separate versions
   of .deb to worry about.. */
APT_PURE bool debSystem::ArchiveSupported(const char *Type)
{
   if (strcmp(Type,"deb") == 0)
      return true;
   return false;
}
									/*}}}*/
// System::Score - Determine how 'Debiany' this sys is..		/*{{{*/
// ---------------------------------------------------------------------
/* We check some files that are sure tell signs of this being a Debian
   System.. */
signed debSystem::Score(Configuration const &Cnf)
{
   signed Score = 0;
   if (FileExists(Cnf.FindFile("Dir::State::status","/var/lib/dpkg/status")) == true)
       Score += 10;
   if (FileExists(Cnf.FindFile("Dir::Bin::dpkg","/usr/bin/dpkg")) == true)
      Score += 10;
   if (FileExists("/etc/debian_version") == true)
      Score += 10;
   return Score;
}
									/*}}}*/
// System::AddStatusFiles - Register the status files			/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debSystem::AddStatusFiles(std::vector<pkgIndexFile *> &List)
{
   if (d->StatusFile == 0)
      d->StatusFile = new debStatusIndex(_config->FindFile("Dir::State::status"));
   List.push_back(d->StatusFile);
   return true;
}
									/*}}}*/
// System::FindIndex - Get an index file for status files		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool debSystem::FindIndex(pkgCache::PkgFileIterator File,
			  pkgIndexFile *&Found) const
{
   if (d->StatusFile == 0)
      return false;
   if (d->StatusFile->FindInCache(*File.Cache()) == File)
   {
      Found = d->StatusFile;
      return true;
   }
   
   return false;
}
									/*}}}*/

std::string debSystem::GetDpkgExecutable()				/*{{{*/
{
   string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
   string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
   size_t dpkgChrootLen = dpkgChrootDir.length();
   if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
   {
      if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
         --dpkgChrootLen;
      Tmp = Tmp.substr(dpkgChrootLen);
   }
   return Tmp;
}
									/*}}}*/
std::vector<std::string> debSystem::GetDpkgBaseCommand()		/*{{{*/
{
   // Generate the base argument list for dpkg
   std::vector<std::string> Args = { GetDpkgExecutable() };
   // Stick in any custom dpkg options
   Configuration::Item const *Opts = _config->Tree("DPkg::Options");
   if (Opts != 0)
   {
      Opts = Opts->Child;
      for (; Opts != 0; Opts = Opts->Next)
      {
	 if (Opts->Value.empty() == true)
	    continue;
	 Args.push_back(Opts->Value);
      }
   }
   return Args;
}
									/*}}}*/
void debSystem::DpkgChrootDirectory()					/*{{{*/
{
   std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
   if (chrootDir == "/")
      return;
   std::cerr << "Chrooting into " << chrootDir << std::endl;
   if (chroot(chrootDir.c_str()) != 0)
      _exit(100);
   if (chdir("/") != 0)
      _exit(100);
}
									/*}}}*/
pid_t debSystem::ExecDpkg(std::vector<std::string> const &sArgs, int * const inputFd, int * const outputFd, bool const DiscardOutput)/*{{{*/
{
   std::vector<const char *> Args(sArgs.size(), NULL);
   std::transform(sArgs.begin(), sArgs.end(), Args.begin(), [](std::string const &s) { return s.c_str(); });
   Args.push_back(NULL);

   int external[2] = {-1, -1};
   if (inputFd != nullptr || outputFd != nullptr)
      if (pipe(external) != 0)
      {
	 _error->WarningE("dpkg", "Can't create IPC pipe for dpkg call");
	 return -1;
      }

   pid_t const dpkg = ExecFork();
   if (dpkg == 0) {
      int const nullfd = open("/dev/null", O_RDONLY);
      if (inputFd == nullptr)
	 dup2(nullfd, STDIN_FILENO);
      else
      {
	 close(external[1]);
	 dup2(external[0], STDIN_FILENO);
      }
      if (outputFd == nullptr)
	 dup2(nullfd, STDOUT_FILENO);
      else
      {
	 close(external[0]);
	 dup2(external[1], STDOUT_FILENO);
      }
      if (DiscardOutput == true)
	 dup2(nullfd, STDERR_FILENO);
      debSystem::DpkgChrootDirectory();
      execvp(Args[0], (char**) &Args[0]);
      _error->WarningE("dpkg", "Can't execute dpkg!");
      _exit(100);
   }
   if (outputFd != nullptr)
   {
      close(external[1]);
      *outputFd = external[0];
   }
   else if (inputFd != nullptr)
   {
      close(external[0]);
      *inputFd = external[1];
   }
   return dpkg;
}
									/*}}}*/
bool debSystem::SupportsMultiArch()					/*{{{*/
{
   std::vector<std::string> Args = GetDpkgBaseCommand();
   Args.push_back("--assert-multi-arch");
   pid_t const dpkgAssertMultiArch = ExecDpkg(Args, nullptr, nullptr, true);
   if (dpkgAssertMultiArch > 0)
   {
      int Status = 0;
      while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
      {
	 if (errno == EINTR)
	    continue;
	 _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
	 break;
      }
      if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
	 return true;
   }
   return false;
}
									/*}}}*/
std::vector<std::string> debSystem::SupportedArchitectures()		/*{{{*/
{
   std::vector<std::string> archs;
   {
      string const arch = _config->Find("APT::Architecture");
      if (arch.empty() == false)
	 archs.push_back(std::move(arch));
   }

   std::vector<std::string> sArgs = GetDpkgBaseCommand();
   sArgs.push_back("--print-foreign-architectures");
   int outputFd = -1;
   pid_t const dpkgMultiArch = ExecDpkg(sArgs, nullptr, &outputFd, true);
   if (dpkgMultiArch == -1)
      return archs;

   FILE *dpkg = fdopen(outputFd, "r");
   if(dpkg != NULL) {
      char* buf = NULL;
      size_t bufsize = 0;
      while (getline(&buf, &bufsize, dpkg) != -1)
      {
	 char* tok_saveptr;
	 char* arch = strtok_r(buf, " ", &tok_saveptr);
	 while (arch != NULL) {
	    for (; isspace(*arch) != 0; ++arch);
	    if (arch[0] != '\0') {
	       char const* archend = arch;
	       for (; isspace(*archend) == 0 && *archend != '\0'; ++archend);
	       string a(arch, (archend - arch));
	       if (std::find(archs.begin(), archs.end(), a) == archs.end())
		  archs.push_back(a);
	    }
	    arch = strtok_r(NULL, " ", &tok_saveptr);
	 }
      }
      free(buf);
      fclose(dpkg);
   }
   ExecWait(dpkgMultiArch, "dpkg --print-foreign-architectures", true);
   return archs;
}
									/*}}}*/
Commit	Line	Data
b2e465d6 AL	1	// -- mode: cpp; mode: fold --
b2e465d6 AL	2	// Description /{{{/
efef4fd3	3	// $Id: debsystem.cc,v 1.4 2004/01/26 17:01:53 mdz Exp $
b2e465d6 AL	4	/* ######################################################################
	5
	6	System - Abstraction for running on different systems.
	7
	8	Basic general structure..
	9
	10	##################################################################### */
	11	/}}}/
	12	// Include Files /{{{/
ea542140 DK	13	#include <config.h>
ea542140 DK	14
b2e465d6 AL	15	#include <apt-pkg/debsystem.h>
	16	#include <apt-pkg/debversion.h>
	17	#include <apt-pkg/debindexfile.h>
	18	#include <apt-pkg/dpkgpm.h>
	19	#include <apt-pkg/configuration.h>
	20	#include <apt-pkg/error.h>
	21	#include <apt-pkg/fileutl.h>
453b82a3 DK	22	#include <apt-pkg/pkgcache.h>
	23	#include <apt-pkg/cacheiterators.h>
	24
8d6d3f00 DK	25	#include <algorithm>
8d6d3f00 DK	26
453b82a3 DK	27	#include <ctype.h>
	28	#include <stdlib.h>
	29	#include <string.h>
	30	#include <string>
	31	#include <vector>
b2e465d6 AL	32	#include <unistd.h>
	33	#include <dirent.h>
	34	#include <errno.h>
8d6d3f00 DK	35	#include <sys/types.h>
	36	#include <sys/stat.h>
	37	#include <sys/wait.h>
	38	#include <fcntl.h>
ea542140 DK	39
ea542140 DK	40	#include <apti18n.h>
b2e465d6 AL	41	/}}}/
b2e465d6 AL	42
8f3ba4e8 DK	43	using std::string;
8f3ba4e8 DK	44
b2e465d6 AL	45	debSystem debSys;
b2e465d6 AL	46
dce45dbe	47	class APT_HIDDEN debSystemPrivate {
b8f90d97 MV	48	public:
	49	debSystemPrivate() : LockFD(-1), LockCount(0), StatusFile(0)
	50	{
	51	}
	52	// For locking support
	53	int LockFD;
	54	unsigned LockCount;
	55
	56	debStatusIndex *StatusFile;
	57	};
	58
b2e465d6 AL	59	// System::debSystem - Constructor /{{{/
	60	// ---------------------------------------------------------------------
	61	/* */
6c55f07a	62	debSystem::debSystem() : pkgSystem("Debian dpkg interface", &debVS), d(new debSystemPrivate())
b2e465d6	63	{
b2e465d6 AL	64	}
b2e465d6 AL	65	/}}}/
af87ab54 AL	66	// System::~debSystem - Destructor /{{{/
	67	// ---------------------------------------------------------------------
	68	/* */
	69	debSystem::~debSystem()
	70	{
b8f90d97 MV	71	delete d->StatusFile;
b8f90d97 MV	72	delete d;
af87ab54 AL	73	}
af87ab54 AL	74	/}}}/
b2e465d6 AL	75	// System::Lock - Get the lock /{{{/
	76	// ---------------------------------------------------------------------
	77	/* This mirrors the operations dpkg does when it starts up. Note the
	78	checking of the updates directory. */
	79	bool debSystem::Lock()
	80	{
	81	// Disable file locking
b8f90d97	82	if (_config->FindB("Debug::NoLocking",false) == true \|\| d->LockCount > 1)
b2e465d6	83	{
b8f90d97	84	d->LockCount++;
b2e465d6 AL	85	return true;
	86	}
	87
	88	// Create the lockfile
	89	string AdminDir = flNotFile(_config->Find("Dir::State::status"));
b8f90d97 MV	90	d->LockFD = GetLock(AdminDir + "lock");
b8f90d97 MV	91	if (d->LockFD == -1)
b2e465d6 AL	92	{
b2e465d6 AL	93	if (errno == EACCES \|\| errno == EAGAIN)
f23153d0 MV	94	return _error->Error(_("Unable to lock the administration directory (%s), "
f23153d0 MV	95	"is another process using it?"),AdminDir.c_str());
b2e465d6	96	else
f23153d0 MV	97	return _error->Error(_("Unable to lock the administration directory (%s), "
f23153d0 MV	98	"are you root?"),AdminDir.c_str());
b2e465d6 AL	99	}
	100
	101	// See if we need to abort with a dirty journal
	102	if (CheckUpdates() == true)
	103	{
b8f90d97 MV	104	close(d->LockFD);
b8f90d97 MV	105	d->LockFD = -1;
23c5897c MV	106	const char *cmd;
	107	if (getenv("SUDO_USER") != NULL)
	108	cmd = "sudo dpkg --configure -a";
	109	else
	110	cmd = "dpkg --configure -a";
	111	// TRANSLATORS: the %s contains the recovery command, usually
	112	// dpkg --configure -a
f23153d0	113	return _error->Error(_("dpkg was interrupted, you must manually "
23c5897c	114	"run '%s' to correct the problem. "), cmd);
b2e465d6 AL	115	}
b2e465d6 AL	116
b8f90d97	117	d->LockCount++;
b2e465d6 AL	118
	119	return true;
	120	}
	121	/}}}/
	122	// System::UnLock - Drop a lock /{{{/
	123	// ---------------------------------------------------------------------
	124	/* */
	125	bool debSystem::UnLock(bool NoErrors)
	126	{
b8f90d97	127	if (d->LockCount == 0 && NoErrors == true)
b2e465d6 AL	128	return false;
b2e465d6 AL	129
b8f90d97	130	if (d->LockCount < 1)
09fab244	131	return _error->Error(_("Not locked"));
b8f90d97	132	if (--d->LockCount == 0)
b2e465d6	133	{
b8f90d97 MV	134	close(d->LockFD);
b8f90d97 MV	135	d->LockCount = 0;
b2e465d6 AL	136	}
	137
	138	return true;
	139	}
	140	/}}}/
	141	// System::CheckUpdates - Check if the updates dir is dirty /{{{/
	142	// ---------------------------------------------------------------------
	143	/* This does a check of the updates directory (dpkg journal) to see if it has
	144	any entries in it. */
	145	bool debSystem::CheckUpdates()
	146	{
	147	// Check for updates.. (dirty)
	148	string File = flNotFile(_config->Find("Dir::State::status")) + "updates/";
	149	DIR *DirP = opendir(File.c_str());
	150	if (DirP == 0)
	151	return false;
	152
	153	/* We ignore any files that are not all digits, this skips .,.. and
	154	some tmp files dpkg will leave behind.. */
	155	bool Damaged = false;
	156	for (struct dirent *Ent = readdir(DirP); Ent != 0; Ent = readdir(DirP))
	157	{
	158	Damaged = true;
	159	for (unsigned int I = 0; Ent->d_name[I] != 0; I++)
	160	{
	161	// Check if its not a digit..
	162	if (isdigit(Ent->d_name[I]) == 0)
	163	{
	164	Damaged = false;
	165	break;
	166	}
	167	}
	168	if (Damaged == true)
	169	break;
	170	}
	171	closedir(DirP);
	172
	173	return Damaged;
	174	}
	175	/}}}/
	176	// System::CreatePM - Create the underlying package manager /{{{/
	177	// ---------------------------------------------------------------------
	178	/* */
	179	pkgPackageManager debSystem::CreatePM(pkgDepCache Cache) const
	180	{
	181	return new pkgDPkgPM(Cache);
	182	}
	183	/}}}/
	184	// System::Initialize - Setup the configuration space.. /{{{/
	185	// ---------------------------------------------------------------------
	186	/* These are the Debian specific configuration variables.. */
	187	bool debSystem::Initialize(Configuration &Cnf)
	188	{
	189	/* These really should be jammed into a generic 'Local Database' engine
	190	which is yet to be determined. The functions in pkgcachegen should
	191	be the only users of these */
940ff5d6	192	Cnf.CndSet("Dir::State::extended_states", "extended_states");
c988fe21	193	Cnf.CndSet("Dir::State::status","/var/lib/dpkg/status");
b2e465d6	194	Cnf.CndSet("Dir::Bin::dpkg","/usr/bin/dpkg");
13e8426f	195
b8f90d97 MV	196	if (d->StatusFile) {
	197	delete d->StatusFile;
	198	d->StatusFile = 0;
13e8426f MV	199	}
13e8426f MV	200
b2e465d6 AL	201	return true;
	202	}
	203	/}}}/
	204	// System::ArchiveSupported - Is a file format supported /{{{/
	205	// ---------------------------------------------------------------------
1e3f4083	206	/* The standard name for a deb is 'deb'.. There are no separate versions
b2e465d6	207	of .deb to worry about.. */
a02db58f	208	APT_PURE bool debSystem::ArchiveSupported(const char *Type)
b2e465d6 AL	209	{
	210	if (strcmp(Type,"deb") == 0)
	211	return true;
	212	return false;
	213	}
	214	/}}}/
	215	// System::Score - Determine how 'Debiany' this sys is.. /{{{/
	216	// ---------------------------------------------------------------------
	217	/* We check some files that are sure tell signs of this being a Debian
	218	System.. */
	219	signed debSystem::Score(Configuration const &Cnf)
	220	{
	221	signed Score = 0;
	222	if (FileExists(Cnf.FindFile("Dir::State::status","/var/lib/dpkg/status")) == true)
	223	Score += 10;
	224	if (FileExists(Cnf.FindFile("Dir::Bin::dpkg","/usr/bin/dpkg")) == true)
	225	Score += 10;
	226	if (FileExists("/etc/debian_version") == true)
	227	Score += 10;
	228	return Score;
	229	}
	230	/}}}/
	231	// System::AddStatusFiles - Register the status files /{{{/
	232	// ---------------------------------------------------------------------
	233	/* */
8f3ba4e8	234	bool debSystem::AddStatusFiles(std::vector<pkgIndexFile *> &List)
b2e465d6	235	{
b8f90d97 MV	236	if (d->StatusFile == 0)
	237	d->StatusFile = new debStatusIndex(_config->FindFile("Dir::State::status"));
	238	List.push_back(d->StatusFile);
b2e465d6 AL	239	return true;
	240	}
	241	/}}}/
af87ab54 AL	242	// System::FindIndex - Get an index file for status files /{{{/
	243	// ---------------------------------------------------------------------
	244	/* */
	245	bool debSystem::FindIndex(pkgCache::PkgFileIterator File,
	246	pkgIndexFile *&Found) const
	247	{
b8f90d97	248	if (d->StatusFile == 0)
af87ab54	249	return false;
b8f90d97	250	if (d->StatusFile->FindInCache(*File.Cache()) == File)
af87ab54	251	{
b8f90d97	252	Found = d->StatusFile;
af87ab54 AL	253	return true;
	254	}
	255
	256	return false;
	257	}
	258	/}}}/
8d6d3f00 DK	259
	260	std::string debSystem::GetDpkgExecutable() /{{{/
	261	{
	262	string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
	263	string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
	264	size_t dpkgChrootLen = dpkgChrootDir.length();
	265	if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
	266	{
	267	if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
	268	--dpkgChrootLen;
	269	Tmp = Tmp.substr(dpkgChrootLen);
	270	}
	271	return Tmp;
	272	}
	273	/}}}/
	274	std::vector<std::string> debSystem::GetDpkgBaseCommand() /{{{/
	275	{
	276	// Generate the base argument list for dpkg
	277	std::vector<std::string> Args = { GetDpkgExecutable() };
	278	// Stick in any custom dpkg options
	279	Configuration::Item const *Opts = _config->Tree("DPkg::Options");
	280	if (Opts != 0)
	281	{
	282	Opts = Opts->Child;
	283	for (; Opts != 0; Opts = Opts->Next)
	284	{
	285	if (Opts->Value.empty() == true)
	286	continue;
	287	Args.push_back(Opts->Value);
	288	}
	289	}
	290	return Args;
	291	}
	292	/}}}/
	293	void debSystem::DpkgChrootDirectory() /{{{/
	294	{
	295	std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
	296	if (chrootDir == "/")
	297	return;
	298	std::cerr << "Chrooting into " << chrootDir << std::endl;
	299	if (chroot(chrootDir.c_str()) != 0)
	300	_exit(100);
	301	if (chdir("/") != 0)
	302	_exit(100);
	303	}
	304	/}}}/
b49068c5	305	pid_t debSystem::ExecDpkg(std::vector<std::string> const &sArgs, int * const inputFd, int * const outputFd, bool const DiscardOutput)/{{{/
8d6d3f00	306	{
05ef357e DK	307	std::vector<const char *> Args(sArgs.size(), NULL);
	308	std::transform(sArgs.begin(), sArgs.end(), Args.begin(), [](std::string const &s) { return s.c_str(); });
	309	Args.push_back(NULL);
8d6d3f00	310
05ef357e DK	311	int external[2] = {-1, -1};
	312	if (inputFd != nullptr \|\| outputFd != nullptr)
	313	if (pipe(external) != 0)
	314	{
	315	_error->WarningE("dpkg", "Can't create IPC pipe for dpkg call");
	316	return -1;
	317	}
8d6d3f00	318
05ef357e DK	319	pid_t const dpkg = ExecFork();
05ef357e DK	320	if (dpkg == 0) {
8d6d3f00	321	int const nullfd = open("/dev/null", O_RDONLY);
05ef357e DK	322	if (inputFd == nullptr)
	323	dup2(nullfd, STDIN_FILENO);
	324	else
	325	{
	326	close(external[1]);
	327	dup2(external[0], STDIN_FILENO);
	328	}
	329	if (outputFd == nullptr)
	330	dup2(nullfd, STDOUT_FILENO);
	331	else
	332	{
	333	close(external[0]);
	334	dup2(external[1], STDOUT_FILENO);
	335	}
b49068c5	336	if (DiscardOutput == true)
05ef357e DK	337	dup2(nullfd, STDERR_FILENO);
	338	debSystem::DpkgChrootDirectory();
	339	execvp(Args[0], (char**) &Args[0]);
	340	_error->WarningE("dpkg", "Can't execute dpkg!");
	341	_exit(100);
8d6d3f00	342	}
05ef357e DK	343	if (outputFd != nullptr)
	344	{
	345	close(external[1]);
	346	*outputFd = external[0];
	347	}
	348	else if (inputFd != nullptr)
	349	{
	350	close(external[0]);
	351	*inputFd = external[1];
	352	}
	353	return dpkg;
	354	}
	355	/}}}/
	356	bool debSystem::SupportsMultiArch() /{{{/
	357	{
	358	std::vector<std::string> Args = GetDpkgBaseCommand();
	359	Args.push_back("--assert-multi-arch");
b49068c5	360	pid_t const dpkgAssertMultiArch = ExecDpkg(Args, nullptr, nullptr, true);
8d6d3f00 DK	361	if (dpkgAssertMultiArch > 0)
	362	{
	363	int Status = 0;
	364	while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
	365	{
	366	if (errno == EINTR)
	367	continue;
	368	_error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
	369	break;
	370	}
	371	if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
	372	return true;
	373	}
	374	return false;
	375	}
	376	/}}}/
825db890 DK	377	std::vector<std::string> debSystem::SupportedArchitectures() /{{{/
825db890 DK	378	{
825db890	379	std::vector<std::string> archs;
825db890	380	{
05ef357e DK	381	string const arch = _config->Find("APT::Architecture");
	382	if (arch.empty() == false)
	383	archs.push_back(std::move(arch));
825db890 DK	384	}
825db890 DK	385
05ef357e DK	386	std::vector<std::string> sArgs = GetDpkgBaseCommand();
	387	sArgs.push_back("--print-foreign-architectures");
	388	int outputFd = -1;
b49068c5	389	pid_t const dpkgMultiArch = ExecDpkg(sArgs, nullptr, &outputFd, true);
05ef357e DK	390	if (dpkgMultiArch == -1)
05ef357e DK	391	return archs;
825db890	392
05ef357e	393	FILE *dpkg = fdopen(outputFd, "r");
825db890 DK	394	if(dpkg != NULL) {
	395	char* buf = NULL;
	396	size_t bufsize = 0;
	397	while (getline(&buf, &bufsize, dpkg) != -1)
	398	{
	399	char* tok_saveptr;
	400	char* arch = strtok_r(buf, " ", &tok_saveptr);
	401	while (arch != NULL) {
	402	for (; isspace(*arch) != 0; ++arch);
	403	if (arch[0] != '\0') {
	404	char const* archend = arch;
	405	for (; isspace(archend) == 0 && archend != '\0'; ++archend);
	406	string a(arch, (archend - arch));
	407	if (std::find(archs.begin(), archs.end(), a) == archs.end())
	408	archs.push_back(a);
	409	}
	410	arch = strtok_r(NULL, " ", &tok_saveptr);
	411	}
	412	}
	413	free(buf);
	414	fclose(dpkg);
	415	}
	416	ExecWait(dpkgMultiArch, "dpkg --print-foreign-architectures", true);
	417	return archs;
	418	}
	419	/}}}/