[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)
   
   This source is placed in the Public Domain, do with it what you will
   It was originally written by Jason Gunthorpe <jgg@debian.org>.
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/fileutl.h"
#endif 
#include <apt-pkg/fileutl.h>
#include <apt-pkg/error.h>
#include <apt-pkg/sptr.h>

#include <apti18n.h>

#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>
									/*}}}*/

using namespace std;

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