[apt.git] / apt-pkg / contrib / fileutl.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: fileutl.cc,v 1.42 2002/09/14 05:29:22 jgg Exp $
/* ######################################################################
   
   File Utilities
   
   CopyFile - Buffered copy of a single file
   GetLock - dpkg compatible lock file manipulation (fcntl)
   
   Most of this source is placed in the Public Domain, do with it what 
   you will
   It was originally written by Jason Gunthorpe <jgg@debian.org>.
   
   The exception is RunScripts() it is under the GPLv2

   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/fileutl.h>
#include <apt-pkg/error.h>
#include <apt-pkg/sptr.h>
#include <apt-pkg/configuration.h>

#include <apti18n.h>

#include <cstdlib>
#include <cstring>

#include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <signal.h>
#include <errno.h>
#include <set>
									/*}}}*/

using namespace std;

// RunScripts - Run a set of scripts from a configuration subtree	/*{{{*/
// ---------------------------------------------------------------------
/* */
bool RunScripts(const char *Cnf)
{
   Configuration::Item const *Opts = _config->Tree(Cnf);
   if (Opts == 0 || Opts->Child == 0)
      return true;
   Opts = Opts->Child;

   // Fork for running the system calls
   pid_t Child = ExecFork();
   
   // This is the child
   if (Child == 0)
   {
      if (chdir("/tmp/") != 0)
	 _exit(100);
	 
      unsigned int Count = 1;
      for (; Opts != 0; Opts = Opts->Next, Count++)
      {
	 if (Opts->Value.empty() == true)
	    continue;
	 
	 if (system(Opts->Value.c_str()) != 0)
	    _exit(100+Count);
      }
      _exit(0);
   }      

   // Wait for the child
   int Status = 0;
   while (waitpid(Child,&Status,0) != Child)
   {
      if (errno == EINTR)
	 continue;
      return _error->Errno("waitpid","Couldn't wait for subprocess");
   }

   // Restore sig int/quit
   signal(SIGQUIT,SIG_DFL);
   signal(SIGINT,SIG_DFL);   

   // Check for an error code.
   if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
   {
      unsigned int Count = WEXITSTATUS(Status);
      if (Count > 100)
      {
	 Count -= 100;
	 for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
	 _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
      }
      
      return _error->Error("Sub-process returned an error code");
   }
   
   return true;
}
									/*}}}*/

// CopyFile - Buffered copy of a file					/*{{{*/
// ---------------------------------------------------------------------
/* The caller is expected to set things so that failure causes erasure */
bool CopyFile(FileFd &From,FileFd &To)
{
   if (From.IsOpen() == false || To.IsOpen() == false)
      return false;
   
   // Buffered copy between fds
   SPtrArray<unsigned char> Buf = new unsigned char[64000];
   unsigned long Size = From.Size();
   while (Size != 0)
   {
      unsigned long ToRead = Size;
      if (Size > 64000)
	 ToRead = 64000;
      
      if (From.Read(Buf,ToRead) == false || 
	  To.Write(Buf,ToRead) == false)
	 return false;
      
      Size -= ToRead;
   }

   return true;   
}
									/*}}}*/
// GetLock - Gets a lock file						/*{{{*/
// ---------------------------------------------------------------------
/* This will create an empty file of the given name and lock it. Once this
   is done all other calls to GetLock in any other process will fail with
   -1. The return result is the fd of the file, the call should call
   close at some time. */
int GetLock(string File,bool Errors)
{
   // GetLock() is used in aptitude on directories with public-write access
   // Use O_NOFOLLOW here to prevent symlink traversal attacks
   int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
   if (FD < 0)
   {
      // Read only .. cant have locking problems there.
      if (errno == EROFS)
      {
	 _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
	 return dup(0);       // Need something for the caller to close
      }
      
      if (Errors == true)
	 _error->Errno("open",_("Could not open lock file %s"),File.c_str());

      // Feh.. We do this to distinguish the lock vs open case..
      errno = EPERM;
      return -1;
   }
   SetCloseExec(FD,true);
      
   // Aquire a write lock
   struct flock fl;
   fl.l_type = F_WRLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = 0;
   fl.l_len = 0;
   if (fcntl(FD,F_SETLK,&fl) == -1)
   {
      if (errno == ENOLCK)
      {
	 _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
	 return dup(0);       // Need something for the caller to close	 
      }      
      if (Errors == true)
	 _error->Errno("open",_("Could not get lock %s"),File.c_str());
      
      int Tmp = errno;
      close(FD);
      errno = Tmp;
      return -1;
   }

   return FD;
}
									/*}}}*/
// FileExists - Check if a file exists					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool FileExists(string File)
{
   struct stat Buf;
   if (stat(File.c_str(),&Buf) != 0)
      return false;
   return true;
}
									/*}}}*/
// SafeGetCWD - This is a safer getcwd that returns a dynamic string	/*{{{*/
// ---------------------------------------------------------------------
/* We return / on failure. */
string SafeGetCWD()
{
   // Stash the current dir.
   char S[300];
   S[0] = 0;
   if (getcwd(S,sizeof(S)-2) == 0)
      return "/";
   unsigned int Len = strlen(S);
   S[Len] = '/';
   S[Len+1] = 0;
   return S;
}
									/*}}}*/
// flNotDir - Strip the directory from the filename			/*{{{*/
// ---------------------------------------------------------------------
/* */
string flNotDir(string File)
{
   string::size_type Res = File.rfind('/');
   if (Res == string::npos)
      return File;
   Res++;
   return string(File,Res,Res - File.length());
}
									/*}}}*/
// flNotFile - Strip the file from the directory name			/*{{{*/
// ---------------------------------------------------------------------
/* Result ends in a / */
string flNotFile(string File)
{
   string::size_type Res = File.rfind('/');
   if (Res == string::npos)
      return "./";
   Res++;
   return string(File,0,Res);
}
									/*}}}*/
// flExtension - Return the extension for the file			/*{{{*/
// ---------------------------------------------------------------------
/* */
string flExtension(string File)
{
   string::size_type Res = File.rfind('.');
   if (Res == string::npos)
      return File;
   Res++;
   return string(File,Res,Res - File.length());
}
									/*}}}*/
// flNoLink - If file is a symlink then deref it			/*{{{*/
// ---------------------------------------------------------------------
/* If the name is not a link then the returned path is the input. */
string flNoLink(string File)
{
   struct stat St;
   if (lstat(File.c_str(),&St) != 0 || S_ISLNK(St.st_mode) == 0)
      return File;
   if (stat(File.c_str(),&St) != 0)
      return File;
   
   /* Loop resolving the link. There is no need to limit the number of 
      loops because the stat call above ensures that the symlink is not 
      circular */
   char Buffer[1024];
   string NFile = File;
   while (1)
   {
      // Read the link
      int Res;
      if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 || 
	  (unsigned)Res >= sizeof(Buffer))
	  return File;
      
      // Append or replace the previous path
      Buffer[Res] = 0;
      if (Buffer[0] == '/')
	 NFile = Buffer;
      else
	 NFile = flNotFile(NFile) + Buffer;
      
      // See if we are done
      if (lstat(NFile.c_str(),&St) != 0)
	 return File;
      if (S_ISLNK(St.st_mode) == 0)
	 return NFile;      
   }   
}
									/*}}}*/
// flCombine - Combine a file and a directory				/*{{{*/
// ---------------------------------------------------------------------
/* If the file is an absolute path then it is just returned, otherwise
   the directory is pre-pended to it. */
string flCombine(string Dir,string File)
{
   if (File.empty() == true)
      return string();
   
   if (File[0] == '/' || Dir.empty() == true)
      return File;
   if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
      return File;
   if (Dir[Dir.length()-1] == '/')
      return Dir + File;
   return Dir + '/' + File;
}
									/*}}}*/
// SetCloseExec - Set the close on exec flag				/*{{{*/
// ---------------------------------------------------------------------
/* */
void SetCloseExec(int Fd,bool Close)
{   
   if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
   {
      cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
      exit(100);
   }
}
									/*}}}*/
// SetNonBlock - Set the nonblocking flag				/*{{{*/
// ---------------------------------------------------------------------
/* */
void SetNonBlock(int Fd,bool Block)
{   
   int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
   if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
   {
      cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
      exit(100);
   }
}
									/*}}}*/
// WaitFd - Wait for a FD to become readable				/*{{{*/
// ---------------------------------------------------------------------
/* This waits for a FD to become readable using select. It is useful for
   applications making use of non-blocking sockets. The timeout is 
   in seconds. */
bool WaitFd(int Fd,bool write,unsigned long timeout)
{
   fd_set Set;
   struct timeval tv;
   FD_ZERO(&Set);
   FD_SET(Fd,&Set);
   tv.tv_sec = timeout;
   tv.tv_usec = 0;
   if (write == true) 
   {      
      int Res;
      do
      {
	 Res = select(Fd+1,0,&Set,0,(timeout != 0?&tv:0));
      }
      while (Res < 0 && errno == EINTR);
      
      if (Res <= 0)
	 return false;
   } 
   else 
   {
      int Res;
      do
      {
	 Res = select(Fd+1,&Set,0,0,(timeout != 0?&tv:0));
      }
      while (Res < 0 && errno == EINTR);
      
      if (Res <= 0)
	 return false;
   }
   
   return true;
}
									/*}}}*/
// ExecFork - Magical fork that sanitizes the context before execing	/*{{{*/
// ---------------------------------------------------------------------
/* This is used if you want to cleanse the environment for the forked 
   child, it fixes up the important signals and nukes all of the fds,
   otherwise acts like normal fork. */
pid_t ExecFork()
{
   // Fork off the process
   pid_t Process = fork();
   if (Process < 0)
   {
      cerr << "FATAL -> Failed to fork." << endl;
      exit(100);
   }

   // Spawn the subprocess
   if (Process == 0)
   {
      // Setup the signals
      signal(SIGPIPE,SIG_DFL);
      signal(SIGQUIT,SIG_DFL);
      signal(SIGINT,SIG_DFL);
      signal(SIGWINCH,SIG_DFL);
      signal(SIGCONT,SIG_DFL);
      signal(SIGTSTP,SIG_DFL);

      set<int> KeepFDs;
      Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
      if (Opts != 0 && Opts->Child != 0)
      {
	 Opts = Opts->Child;
	 for (; Opts != 0; Opts = Opts->Next)
	 {
	    if (Opts->Value.empty() == true)
	       continue;
	    int fd = atoi(Opts->Value.c_str());
	    KeepFDs.insert(fd);
	 }
      }

      // Close all of our FDs - just in case
      for (int K = 3; K != 40; K++)
      {
	 if(KeepFDs.find(K) == KeepFDs.end())
	    fcntl(K,F_SETFD,FD_CLOEXEC);
      }
   }
   
   return Process;
}
									/*}}}*/
// ExecWait - Fancy waitpid						/*{{{*/
// ---------------------------------------------------------------------
/* Waits for the given sub process. If Reap is set then no errors are 
   generated. Otherwise a failed subprocess will generate a proper descriptive
   message */
bool ExecWait(pid_t Pid,const char *Name,bool Reap)
{
   if (Pid <= 1)
      return true;
   
   // Wait and collect the error code
   int Status;
   while (waitpid(Pid,&Status,0) != Pid)
   {
      if (errno == EINTR)
	 continue;

      if (Reap == true)
	 return false;
      
      return _error->Error(_("Waited for %s but it wasn't there"),Name);
   }

   
   // Check for an error code.
   if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
   {
      if (Reap == true)
	 return false;
      if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
	 return _error->Error(_("Sub-process %s received a segmentation fault."),Name);

      if (WIFEXITED(Status) != 0)
	 return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
      
      return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
   }      
   
   return true;
}
									/*}}}*/

// FileFd::Open - Open a file						/*{{{*/
// ---------------------------------------------------------------------
/* The most commonly used open mode combinations are given with Mode */
bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
{
   Close();
   Flags = AutoClose;
   switch (Mode)
   {
      case ReadOnly:
      iFd = open(FileName.c_str(),O_RDONLY);
      break;
      
      case WriteEmpty:
      {
	 struct stat Buf;
	 if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
	    unlink(FileName.c_str());
	 iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_TRUNC,Perms);
	 break;
      }
      
      case WriteExists:
      iFd = open(FileName.c_str(),O_RDWR);
      break;

      case WriteAny:
      iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
      break;      

      case WriteTemp:
      unlink(FileName.c_str());
      iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
      break;
   }  

   if (iFd < 0)
      return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
   
   this->FileName = FileName;
   SetCloseExec(iFd,true);
   return true;
}
									/*}}}*/
// FileFd::~File - Closes the file					/*{{{*/
// ---------------------------------------------------------------------
/* If the proper modes are selected then we close the Fd and possibly
   unlink the file on error. */
FileFd::~FileFd()
{
   Close();
}
									/*}}}*/
// FileFd::Read - Read a bit of the file				/*{{{*/
// ---------------------------------------------------------------------
/* We are carefull to handle interruption by a signal while reading 
   gracefully. */
bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
{
   int Res;
   errno = 0;
   if (Actual != 0)
      *Actual = 0;
   
   do
   {
      Res = read(iFd,To,Size);
      if (Res < 0 && errno == EINTR)
	 continue;
      if (Res < 0)
      {
	 Flags |= Fail;
	 return _error->Errno("read",_("Read error"));
      }
      
      To = (char *)To + Res;
      Size -= Res;
      if (Actual != 0)
	 *Actual += Res;
   }
   while (Res > 0 && Size > 0);
   
   if (Size == 0)
      return true;
   
   // Eof handling
   if (Actual != 0)
   {
      Flags |= HitEof;
      return true;
   }
   
   Flags |= Fail;
   return _error->Error(_("read, still have %lu to read but none left"),Size);
}
									/*}}}*/
// FileFd::Write - Write to the file					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool FileFd::Write(const void *From,unsigned long Size)
{
   int Res;
   errno = 0;
   do
   {
      Res = write(iFd,From,Size);
      if (Res < 0 && errno == EINTR)
	 continue;
      if (Res < 0)
      {
	 Flags |= Fail;
	 return _error->Errno("write",_("Write error"));
      }
      
      From = (char *)From + Res;
      Size -= Res;
   }
   while (Res > 0 && Size > 0);
   
   if (Size == 0)
      return true;
   
   Flags |= Fail;
   return _error->Error(_("write, still have %lu to write but couldn't"),Size);
}
									/*}}}*/
// FileFd::Seek - Seek in the file					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool FileFd::Seek(unsigned long To)
{
   if (lseek(iFd,To,SEEK_SET) != (signed)To)
   {
      Flags |= Fail;
      return _error->Error("Unable to seek to %lu",To);
   }
   
   return true;
}
									/*}}}*/
// FileFd::Skip - Seek in the file					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool FileFd::Skip(unsigned long Over)
{
   if (lseek(iFd,Over,SEEK_CUR) < 0)
   {
      Flags |= Fail;
      return _error->Error("Unable to seek ahead %lu",Over);
   }
   
   return true;
}
									/*}}}*/
// FileFd::Truncate - Truncate the file 				/*{{{*/
// ---------------------------------------------------------------------
/* */
bool FileFd::Truncate(unsigned long To)
{
   if (ftruncate(iFd,To) != 0)
   {
      Flags |= Fail;
      return _error->Error("Unable to truncate to %lu",To);
   }
   
   return true;
}
									/*}}}*/
// FileFd::Tell - Current seek position					/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long FileFd::Tell()
{
   off_t Res = lseek(iFd,0,SEEK_CUR);
   if (Res == (off_t)-1)
      _error->Errno("lseek","Failed to determine the current file position");
   return Res;
}
									/*}}}*/
// FileFd::Size - Return the size of the file				/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long FileFd::Size()
{
   struct stat Buf;
   if (fstat(iFd,&Buf) != 0)
      return _error->Errno("fstat","Unable to determine the file size");
   return Buf.st_size;
}
									/*}}}*/
// FileFd::Close - Close the file if the close flag is set		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool FileFd::Close()
{
   bool Res = true;
   if ((Flags & AutoClose) == AutoClose)
      if (iFd >= 0 && close(iFd) != 0)
	 Res &= _error->Errno("close",_("Problem closing the file"));
   iFd = -1;
   
   if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
       FileName.empty() == false)
      if (unlink(FileName.c_str()) != 0)
	 Res &= _error->WarningE("unlnk",_("Problem unlinking the file"));
   return Res;
}
									/*}}}*/
// FileFd::Sync - Sync the file						/*{{{*/
// ---------------------------------------------------------------------
/* */
bool FileFd::Sync()
{
#ifdef _POSIX_SYNCHRONIZED_IO
   if (fsync(iFd) != 0)
      return _error->Errno("sync",_("Problem syncing the file"));
#endif
   return true;
}
									/*}}}*/
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
7da2b375	3	// $Id: fileutl.cc,v 1.42 2002/09/14 05:29:22 jgg Exp $
578bfd0a AL	4	/* ######################################################################
	5
	6	File Utilities
	7
	8	CopyFile - Buffered copy of a single file
	9	GetLock - dpkg compatible lock file manipulation (fcntl)
	10
614adaa0 MV	11	Most of this source is placed in the Public Domain, do with it what
614adaa0 MV	12	you will
7da2b375	13	It was originally written by Jason Gunthorpe <jgg@debian.org>.
578bfd0a	14
614adaa0 MV	15	The exception is RunScripts() it is under the GPLv2
614adaa0 MV	16
578bfd0a AL	17	##################################################################### */
	18	/}}}/
	19	// Include Files /{{{/
094a497d AL	20	#include <apt-pkg/fileutl.h>
094a497d AL	21	#include <apt-pkg/error.h>
b2e465d6	22	#include <apt-pkg/sptr.h>
75ef8f14	23	#include <apt-pkg/configuration.h>
b2e465d6 AL	24
b2e465d6 AL	25	#include <apti18n.h>
578bfd0a	26
152ab79e	27	#include <cstdlib>
4f333a8b MV	28	#include <cstring>
4f333a8b MV	29
4d055c05	30	#include <iostream>
578bfd0a	31	#include <unistd.h>
2c206aa4	32	#include <fcntl.h>
578bfd0a	33	#include <sys/stat.h>
578bfd0a	34	#include <sys/types.h>
cc2313b7	35	#include <sys/time.h>
1ae93c94	36	#include <sys/wait.h>
54676e1a	37	#include <signal.h>
65a1e968	38	#include <errno.h>
75ef8f14	39	#include <set>
578bfd0a AL	40	/}}}/
578bfd0a AL	41
4d055c05 AL	42	using namespace std;
4d055c05 AL	43
614adaa0 MV	44	// RunScripts - Run a set of scripts from a configuration subtree /{{{/
	45	// ---------------------------------------------------------------------
	46	/* */
	47	bool RunScripts(const char *Cnf)
	48	{
	49	Configuration::Item const *Opts = _config->Tree(Cnf);
	50	if (Opts == 0 \|\| Opts->Child == 0)
	51	return true;
	52	Opts = Opts->Child;
	53
	54	// Fork for running the system calls
	55	pid_t Child = ExecFork();
	56
	57	// This is the child
	58	if (Child == 0)
	59	{
	60	if (chdir("/tmp/") != 0)
	61	_exit(100);
	62
	63	unsigned int Count = 1;
	64	for (; Opts != 0; Opts = Opts->Next, Count++)
	65	{
	66	if (Opts->Value.empty() == true)
	67	continue;
	68
	69	if (system(Opts->Value.c_str()) != 0)
	70	_exit(100+Count);
	71	}
	72	_exit(0);
	73	}
	74
	75	// Wait for the child
	76	int Status = 0;
	77	while (waitpid(Child,&Status,0) != Child)
	78	{
	79	if (errno == EINTR)
	80	continue;
	81	return _error->Errno("waitpid","Couldn't wait for subprocess");
	82	}
	83
	84	// Restore sig int/quit
	85	signal(SIGQUIT,SIG_DFL);
	86	signal(SIGINT,SIG_DFL);
	87
	88	// Check for an error code.
	89	if (WIFEXITED(Status) == 0 \|\| WEXITSTATUS(Status) != 0)
	90	{
	91	unsigned int Count = WEXITSTATUS(Status);
	92	if (Count > 100)
	93	{
	94	Count -= 100;
	95	for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
	96	_error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
	97	}
	98
	99	return _error->Error("Sub-process returned an error code");
	100	}
	101
	102	return true;
	103	}
	104	/}}}/
	105
578bfd0a AL	106	// CopyFile - Buffered copy of a file /{{{/
	107	// ---------------------------------------------------------------------
	108	/* The caller is expected to set things so that failure causes erasure */
8b89e57f	109	bool CopyFile(FileFd &From,FileFd &To)
578bfd0a AL	110	{
	111	if (From.IsOpen() == false \|\| To.IsOpen() == false)
	112	return false;
	113
	114	// Buffered copy between fds
b2e465d6	115	SPtrArray<unsigned char> Buf = new unsigned char[64000];
b0db36b1 AL	116	unsigned long Size = From.Size();
b0db36b1 AL	117	while (Size != 0)
578bfd0a	118	{
b0db36b1 AL	119	unsigned long ToRead = Size;
	120	if (Size > 64000)
	121	ToRead = 64000;
	122
4a6d5862	123	if (From.Read(Buf,ToRead) == false \|\|
b0db36b1	124	To.Write(Buf,ToRead) == false)
578bfd0a	125	return false;
b0db36b1 AL	126
b0db36b1 AL	127	Size -= ToRead;
578bfd0a AL	128	}
578bfd0a AL	129
578bfd0a AL	130	return true;
	131	}
	132	/}}}/
	133	// GetLock - Gets a lock file /{{{/
	134	// ---------------------------------------------------------------------
	135	/* This will create an empty file of the given name and lock it. Once this
	136	is done all other calls to GetLock in any other process will fail with
	137	-1. The return result is the fd of the file, the call should call
	138	close at some time. */
	139	int GetLock(string File,bool Errors)
	140	{
f659b39a OS	141	// GetLock() is used in aptitude on directories with public-write access
	142	// Use O_NOFOLLOW here to prevent symlink traversal attacks
	143	int FD = open(File.c_str(),O_RDWR \| O_CREAT \| O_NOFOLLOW,0640);
578bfd0a AL	144	if (FD < 0)
578bfd0a AL	145	{
b2e465d6 AL	146	// Read only .. cant have locking problems there.
	147	if (errno == EROFS)
	148	{
	149	_error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
	150	return dup(0); // Need something for the caller to close
	151	}
	152
578bfd0a	153	if (Errors == true)
b2e465d6 AL	154	_error->Errno("open",_("Could not open lock file %s"),File.c_str());
	155
	156	// Feh.. We do this to distinguish the lock vs open case..
	157	errno = EPERM;
578bfd0a AL	158	return -1;
578bfd0a AL	159	}
b2e465d6 AL	160	SetCloseExec(FD,true);
b2e465d6 AL	161
578bfd0a AL	162	// Aquire a write lock
578bfd0a AL	163	struct flock fl;
c71bc556 AL	164	fl.l_type = F_WRLCK;
	165	fl.l_whence = SEEK_SET;
	166	fl.l_start = 0;
	167	fl.l_len = 0;
578bfd0a AL	168	if (fcntl(FD,F_SETLK,&fl) == -1)
578bfd0a AL	169	{
d89df07a AL	170	if (errno == ENOLCK)
d89df07a AL	171	{
b2e465d6 AL	172	_error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
b2e465d6 AL	173	return dup(0); // Need something for the caller to close
d89df07a	174	}
578bfd0a	175	if (Errors == true)
b2e465d6 AL	176	_error->Errno("open",_("Could not get lock %s"),File.c_str());
	177
	178	int Tmp = errno;
578bfd0a	179	close(FD);
b2e465d6	180	errno = Tmp;
578bfd0a AL	181	return -1;
	182	}
	183
	184	return FD;
	185	}
	186	/}}}/
	187	// FileExists - Check if a file exists /{{{/
	188	// ---------------------------------------------------------------------
	189	/* */
	190	bool FileExists(string File)
	191	{
	192	struct stat Buf;
	193	if (stat(File.c_str(),&Buf) != 0)
	194	return false;
	195	return true;
	196	}
	197	/}}}/
	198	// SafeGetCWD - This is a safer getcwd that returns a dynamic string /{{{/
	199	// ---------------------------------------------------------------------
	200	/* We return / on failure. */
	201	string SafeGetCWD()
	202	{
	203	// Stash the current dir.
	204	char S[300];
	205	S[0] = 0;
7f25bdff	206	if (getcwd(S,sizeof(S)-2) == 0)
578bfd0a	207	return "/";
7f25bdff AL	208	unsigned int Len = strlen(S);
	209	S[Len] = '/';
	210	S[Len+1] = 0;
578bfd0a AL	211	return S;
	212	}
	213	/}}}/
8ce4327b AL	214	// flNotDir - Strip the directory from the filename /{{{/
	215	// ---------------------------------------------------------------------
	216	/* */
	217	string flNotDir(string File)
	218	{
	219	string::size_type Res = File.rfind('/');
	220	if (Res == string::npos)
	221	return File;
	222	Res++;
	223	return string(File,Res,Res - File.length());
	224	}
	225	/}}}/
d38b7b3d AL	226	// flNotFile - Strip the file from the directory name /{{{/
d38b7b3d AL	227	// ---------------------------------------------------------------------
171c45bc	228	/* Result ends in a / */
d38b7b3d AL	229	string flNotFile(string File)
	230	{
	231	string::size_type Res = File.rfind('/');
	232	if (Res == string::npos)
171c45bc	233	return "./";
d38b7b3d AL	234	Res++;
	235	return string(File,0,Res);
	236	}
	237	/}}}/
b2e465d6 AL	238	// flExtension - Return the extension for the file /{{{/
	239	// ---------------------------------------------------------------------
	240	/* */
	241	string flExtension(string File)
	242	{
	243	string::size_type Res = File.rfind('.');
	244	if (Res == string::npos)
	245	return File;
	246	Res++;
	247	return string(File,Res,Res - File.length());
	248	}
	249	/}}}/
421c8d10 AL	250	// flNoLink - If file is a symlink then deref it /{{{/
	251	// ---------------------------------------------------------------------
	252	/* If the name is not a link then the returned path is the input. */
	253	string flNoLink(string File)
	254	{
	255	struct stat St;
	256	if (lstat(File.c_str(),&St) != 0 \|\| S_ISLNK(St.st_mode) == 0)
	257	return File;
	258	if (stat(File.c_str(),&St) != 0)
	259	return File;
	260
	261	/* Loop resolving the link. There is no need to limit the number of
	262	loops because the stat call above ensures that the symlink is not
	263	circular */
	264	char Buffer[1024];
	265	string NFile = File;
	266	while (1)
	267	{
	268	// Read the link
	269	int Res;
	270	if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 \|\|
	271	(unsigned)Res >= sizeof(Buffer))
	272	return File;
	273
	274	// Append or replace the previous path
	275	Buffer[Res] = 0;
	276	if (Buffer[0] == '/')
	277	NFile = Buffer;
	278	else
	279	NFile = flNotFile(NFile) + Buffer;
	280
	281	// See if we are done
	282	if (lstat(NFile.c_str(),&St) != 0)
	283	return File;
	284	if (S_ISLNK(St.st_mode) == 0)
	285	return NFile;
	286	}
	287	}
	288	/}}}/
b2e465d6 AL	289	// flCombine - Combine a file and a directory /{{{/
	290	// ---------------------------------------------------------------------
	291	/* If the file is an absolute path then it is just returned, otherwise
	292	the directory is pre-pended to it. */
	293	string flCombine(string Dir,string File)
	294	{
	295	if (File.empty() == true)
	296	return string();
	297
	298	if (File[0] == '/' \|\| Dir.empty() == true)
	299	return File;
	300	if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
	301	return File;
	302	if (Dir[Dir.length()-1] == '/')
	303	return Dir + File;
	304	return Dir + '/' + File;
	305	}
	306	/}}}/
3b5421b4 AL	307	// SetCloseExec - Set the close on exec flag /{{{/
	308	// ---------------------------------------------------------------------
	309	/* */
	310	void SetCloseExec(int Fd,bool Close)
	311	{
	312	if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
	313	{
	314	cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
	315	exit(100);
	316	}
	317	}
	318	/}}}/
	319	// SetNonBlock - Set the nonblocking flag /{{{/
	320	// ---------------------------------------------------------------------
	321	/* */
	322	void SetNonBlock(int Fd,bool Block)
	323	{
0a8a80e5 AL	324	int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
0a8a80e5 AL	325	if (fcntl(Fd,F_SETFL,Flags \| ((Block == false)?0:O_NONBLOCK)) != 0)
3b5421b4 AL	326	{
	327	cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
	328	exit(100);
	329	}
	330	}
	331	/}}}/
	332	// WaitFd - Wait for a FD to become readable /{{{/
	333	// ---------------------------------------------------------------------
b2e465d6	334	/* This waits for a FD to become readable using select. It is useful for
6d5dd02a AL	335	applications making use of non-blocking sockets. The timeout is
6d5dd02a AL	336	in seconds. */
1084d58a	337	bool WaitFd(int Fd,bool write,unsigned long timeout)
3b5421b4 AL	338	{
3b5421b4 AL	339	fd_set Set;
cc2313b7	340	struct timeval tv;
3b5421b4 AL	341	FD_ZERO(&Set);
3b5421b4 AL	342	FD_SET(Fd,&Set);
6d5dd02a AL	343	tv.tv_sec = timeout;
6d5dd02a AL	344	tv.tv_usec = 0;
1084d58a	345	if (write == true)
b0db36b1 AL	346	{
	347	int Res;
	348	do
	349	{
	350	Res = select(Fd+1,0,&Set,0,(timeout != 0?&tv:0));
	351	}
	352	while (Res < 0 && errno == EINTR);
	353
	354	if (Res <= 0)
	355	return false;
1084d58a AL	356	}
	357	else
	358	{
b0db36b1 AL	359	int Res;
	360	do
	361	{
	362	Res = select(Fd+1,&Set,0,0,(timeout != 0?&tv:0));
	363	}
	364	while (Res < 0 && errno == EINTR);
	365
	366	if (Res <= 0)
	367	return false;
cc2313b7	368	}
1084d58a	369
3b5421b4 AL	370	return true;
	371	}
	372	/}}}/
54676e1a AL	373	// ExecFork - Magical fork that sanitizes the context before execing /{{{/
	374	// ---------------------------------------------------------------------
	375	/* This is used if you want to cleanse the environment for the forked
	376	child, it fixes up the important signals and nukes all of the fds,
	377	otherwise acts like normal fork. */
75ef8f14	378	pid_t ExecFork()
54676e1a AL	379	{
	380	// Fork off the process
	381	pid_t Process = fork();
	382	if (Process < 0)
	383	{
	384	cerr << "FATAL -> Failed to fork." << endl;
	385	exit(100);
	386	}
	387
	388	// Spawn the subprocess
	389	if (Process == 0)
	390	{
	391	// Setup the signals
	392	signal(SIGPIPE,SIG_DFL);
	393	signal(SIGQUIT,SIG_DFL);
	394	signal(SIGINT,SIG_DFL);
	395	signal(SIGWINCH,SIG_DFL);
	396	signal(SIGCONT,SIG_DFL);
	397	signal(SIGTSTP,SIG_DFL);
75ef8f14 MV	398
	399	set<int> KeepFDs;
	400	Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
	401	if (Opts != 0 && Opts->Child != 0)
	402	{
	403	Opts = Opts->Child;
	404	for (; Opts != 0; Opts = Opts->Next)
	405	{
	406	if (Opts->Value.empty() == true)
	407	continue;
	408	int fd = atoi(Opts->Value.c_str());
	409	KeepFDs.insert(fd);
	410	}
	411	}
	412
54676e1a AL	413	// Close all of our FDs - just in case
54676e1a AL	414	for (int K = 3; K != 40; K++)
75ef8f14 MV	415	{
75ef8f14 MV	416	if(KeepFDs.find(K) == KeepFDs.end())
007dc9e0	417	fcntl(K,F_SETFD,FD_CLOEXEC);
75ef8f14	418	}
54676e1a AL	419	}
	420
	421	return Process;
	422	}
	423	/}}}/
ddc1d8d0 AL	424	// ExecWait - Fancy waitpid /{{{/
ddc1d8d0 AL	425	// ---------------------------------------------------------------------
2c9a72d1	426	/* Waits for the given sub process. If Reap is set then no errors are
ddc1d8d0 AL	427	generated. Otherwise a failed subprocess will generate a proper descriptive
ddc1d8d0 AL	428	message */
3826564e	429	bool ExecWait(pid_t Pid,const char *Name,bool Reap)
ddc1d8d0 AL	430	{
	431	if (Pid <= 1)
	432	return true;
	433
	434	// Wait and collect the error code
	435	int Status;
	436	while (waitpid(Pid,&Status,0) != Pid)
	437	{
	438	if (errno == EINTR)
	439	continue;
	440
	441	if (Reap == true)
	442	return false;
	443
db0db9fe	444	return _error->Error(_("Waited for %s but it wasn't there"),Name);
ddc1d8d0 AL	445	}
	446
	447
	448	// Check for an error code.
	449	if (WIFEXITED(Status) == 0 \|\| WEXITSTATUS(Status) != 0)
	450	{
	451	if (Reap == true)
	452	return false;
	453	if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
b2e465d6	454	return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
ddc1d8d0 AL	455
ddc1d8d0 AL	456	if (WIFEXITED(Status) != 0)
b2e465d6	457	return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
ddc1d8d0	458
b2e465d6	459	return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
ddc1d8d0 AL	460	}
	461
	462	return true;
	463	}
	464	/}}}/
578bfd0a	465
13d87e2e	466	// FileFd::Open - Open a file /{{{/
578bfd0a AL	467	// ---------------------------------------------------------------------
578bfd0a AL	468	/* The most commonly used open mode combinations are given with Mode */
13d87e2e	469	bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
578bfd0a	470	{
13d87e2e	471	Close();
1164783d	472	Flags = AutoClose;
578bfd0a AL	473	switch (Mode)
	474	{
	475	case ReadOnly:
	476	iFd = open(FileName.c_str(),O_RDONLY);
	477	break;
	478
	479	case WriteEmpty:
50b513a1 AL	480	{
50b513a1 AL	481	struct stat Buf;
459681d3	482	if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
50b513a1 AL	483	unlink(FileName.c_str());
	484	iFd = open(FileName.c_str(),O_RDWR \| O_CREAT \| O_TRUNC,Perms);
	485	break;
	486	}
578bfd0a AL	487
	488	case WriteExists:
	489	iFd = open(FileName.c_str(),O_RDWR);
	490	break;
0a8e3465 AL	491
	492	case WriteAny:
	493	iFd = open(FileName.c_str(),O_RDWR \| O_CREAT,Perms);
d38b7b3d	494	break;
f08fcf34 AL	495
f08fcf34 AL	496	case WriteTemp:
4decd43c AL	497	unlink(FileName.c_str());
4decd43c AL	498	iFd = open(FileName.c_str(),O_RDWR \| O_CREAT \| O_EXCL,Perms);
f08fcf34	499	break;
578bfd0a AL	500	}
	501
	502	if (iFd < 0)
b2e465d6	503	return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
13d87e2e AL	504
	505	this->FileName = FileName;
	506	SetCloseExec(iFd,true);
	507	return true;
578bfd0a AL	508	}
578bfd0a AL	509	/}}}/
8e06abb2	510	// FileFd::~File - Closes the file /{{{/
578bfd0a AL	511	// ---------------------------------------------------------------------
	512	/* If the proper modes are selected then we close the Fd and possibly
	513	unlink the file on error. */
8e06abb2	514	FileFd::~FileFd()
578bfd0a AL	515	{
	516	Close();
	517	}
	518	/}}}/
8e06abb2	519	// FileFd::Read - Read a bit of the file /{{{/
578bfd0a	520	// ---------------------------------------------------------------------
b0db36b1 AL	521	/* We are carefull to handle interruption by a signal while reading
b0db36b1 AL	522	gracefully. */
f604cf55	523	bool FileFd::Read(void To,unsigned long Size,unsigned long Actual)
578bfd0a	524	{
b0db36b1 AL	525	int Res;
b0db36b1 AL	526	errno = 0;
f604cf55 AL	527	if (Actual != 0)
	528	*Actual = 0;
	529
b0db36b1	530	do
578bfd0a	531	{
b0db36b1 AL	532	Res = read(iFd,To,Size);
	533	if (Res < 0 && errno == EINTR)
	534	continue;
	535	if (Res < 0)
	536	{
	537	Flags \|= Fail;
b2e465d6	538	return _error->Errno("read",_("Read error"));
b0db36b1	539	}
578bfd0a	540
b0db36b1 AL	541	To = (char *)To + Res;
b0db36b1 AL	542	Size -= Res;
f604cf55 AL	543	if (Actual != 0)
f604cf55 AL	544	*Actual += Res;
b0db36b1 AL	545	}
	546	while (Res > 0 && Size > 0);
	547
	548	if (Size == 0)
	549	return true;
	550
ddc1d8d0	551	// Eof handling
f604cf55	552	if (Actual != 0)
ddc1d8d0 AL	553	{
	554	Flags \|= HitEof;
	555	return true;
	556	}
	557
b0db36b1	558	Flags \|= Fail;
b2e465d6	559	return _error->Error(_("read, still have %lu to read but none left"),Size);
578bfd0a AL	560	}
578bfd0a AL	561	/}}}/
8e06abb2	562	// FileFd::Write - Write to the file /{{{/
578bfd0a AL	563	// ---------------------------------------------------------------------
578bfd0a AL	564	/* */
a05599f1	565	bool FileFd::Write(const void *From,unsigned long Size)
578bfd0a	566	{
b0db36b1 AL	567	int Res;
	568	errno = 0;
	569	do
578bfd0a	570	{
b0db36b1 AL	571	Res = write(iFd,From,Size);
	572	if (Res < 0 && errno == EINTR)
	573	continue;
	574	if (Res < 0)
	575	{
	576	Flags \|= Fail;
b2e465d6	577	return _error->Errno("write",_("Write error"));
b0db36b1 AL	578	}
	579
	580	From = (char *)From + Res;
	581	Size -= Res;
578bfd0a	582	}
b0db36b1	583	while (Res > 0 && Size > 0);
578bfd0a	584
b0db36b1 AL	585	if (Size == 0)
	586	return true;
	587
	588	Flags \|= Fail;
b2e465d6	589	return _error->Error(_("write, still have %lu to write but couldn't"),Size);
578bfd0a AL	590	}
578bfd0a AL	591	/}}}/
8e06abb2	592	// FileFd::Seek - Seek in the file /{{{/
578bfd0a AL	593	// ---------------------------------------------------------------------
578bfd0a AL	594	/* */
8e06abb2	595	bool FileFd::Seek(unsigned long To)
578bfd0a AL	596	{
	597	if (lseek(iFd,To,SEEK_SET) != (signed)To)
	598	{
	599	Flags \|= Fail;
b2e465d6	600	return _error->Error("Unable to seek to %lu",To);
578bfd0a AL	601	}
578bfd0a AL	602
727f18af AL	603	return true;
	604	}
	605	/}}}/
	606	// FileFd::Skip - Seek in the file /{{{/
	607	// ---------------------------------------------------------------------
	608	/* */
	609	bool FileFd::Skip(unsigned long Over)
	610	{
	611	if (lseek(iFd,Over,SEEK_CUR) < 0)
	612	{
	613	Flags \|= Fail;
b2e465d6	614	return _error->Error("Unable to seek ahead %lu",Over);
727f18af AL	615	}
727f18af AL	616
6d5dd02a AL	617	return true;
	618	}
	619	/}}}/
	620	// FileFd::Truncate - Truncate the file /{{{/
	621	// ---------------------------------------------------------------------
	622	/* */
	623	bool FileFd::Truncate(unsigned long To)
	624	{
	625	if (ftruncate(iFd,To) != 0)
	626	{
	627	Flags \|= Fail;
b2e465d6	628	return _error->Error("Unable to truncate to %lu",To);
6d5dd02a AL	629	}
6d5dd02a AL	630
578bfd0a AL	631	return true;
	632	}
	633	/}}}/
7f25bdff AL	634	// FileFd::Tell - Current seek position /{{{/
	635	// ---------------------------------------------------------------------
	636	/* */
	637	unsigned long FileFd::Tell()
	638	{
	639	off_t Res = lseek(iFd,0,SEEK_CUR);
	640	if (Res == (off_t)-1)
	641	_error->Errno("lseek","Failed to determine the current file position");
	642	return Res;
	643	}
	644	/}}}/
8e06abb2	645	// FileFd::Size - Return the size of the file /{{{/
578bfd0a AL	646	// ---------------------------------------------------------------------
578bfd0a AL	647	/* */
8e06abb2	648	unsigned long FileFd::Size()
578bfd0a AL	649	{
	650	struct stat Buf;
	651	if (fstat(iFd,&Buf) != 0)
	652	return _error->Errno("fstat","Unable to determine the file size");
	653	return Buf.st_size;
	654	}
	655	/}}}/
8e06abb2	656	// FileFd::Close - Close the file if the close flag is set /{{{/
578bfd0a AL	657	// ---------------------------------------------------------------------
578bfd0a AL	658	/* */
8e06abb2	659	bool FileFd::Close()
578bfd0a AL	660	{
	661	bool Res = true;
	662	if ((Flags & AutoClose) == AutoClose)
1164783d	663	if (iFd >= 0 && close(iFd) != 0)
b2e465d6	664	Res &= _error->Errno("close",_("Problem closing the file"));
1164783d AL	665	iFd = -1;
1164783d AL	666
578bfd0a AL	667	if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
	668	FileName.empty() == false)
	669	if (unlink(FileName.c_str()) != 0)
b2e465d6	670	Res &= _error->WarningE("unlnk",_("Problem unlinking the file"));
578bfd0a AL	671	return Res;
	672	}
	673	/}}}/
b2e465d6 AL	674	// FileFd::Sync - Sync the file /{{{/
	675	// ---------------------------------------------------------------------
	676	/* */
	677	bool FileFd::Sync()
	678	{
	679	#ifdef _POSIX_SYNCHRONIZED_IO
	680	if (fsync(iFd) != 0)
	681	return _error->Errno("sync",_("Problem syncing the file"));
	682	#endif
	683	return true;
	684	}
	685	/}}}/