[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)
	 if( WTERMSIG(Status) == SIGSEGV)
	    return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
	 else 
	    return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));

      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;
ab7f4d7c MV	453	if (WIFSIGNALED(Status) != 0)
	454	if( WTERMSIG(Status) == SIGSEGV)
	455	return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
	456	else
	457	return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));
ddc1d8d0 AL	458
ddc1d8d0 AL	459	if (WIFEXITED(Status) != 0)
b2e465d6	460	return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
ddc1d8d0	461
b2e465d6	462	return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
ddc1d8d0 AL	463	}
	464
	465	return true;
	466	}
	467	/}}}/
578bfd0a	468
13d87e2e	469	// FileFd::Open - Open a file /{{{/
578bfd0a AL	470	// ---------------------------------------------------------------------
578bfd0a AL	471	/* The most commonly used open mode combinations are given with Mode */
13d87e2e	472	bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
578bfd0a	473	{
13d87e2e	474	Close();
1164783d	475	Flags = AutoClose;
578bfd0a AL	476	switch (Mode)
	477	{
	478	case ReadOnly:
	479	iFd = open(FileName.c_str(),O_RDONLY);
	480	break;
	481
	482	case WriteEmpty:
50b513a1 AL	483	{
50b513a1 AL	484	struct stat Buf;
459681d3	485	if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
50b513a1 AL	486	unlink(FileName.c_str());
	487	iFd = open(FileName.c_str(),O_RDWR \| O_CREAT \| O_TRUNC,Perms);
	488	break;
	489	}
578bfd0a AL	490
	491	case WriteExists:
	492	iFd = open(FileName.c_str(),O_RDWR);
	493	break;
0a8e3465 AL	494
	495	case WriteAny:
	496	iFd = open(FileName.c_str(),O_RDWR \| O_CREAT,Perms);
d38b7b3d	497	break;
f08fcf34 AL	498
f08fcf34 AL	499	case WriteTemp:
4decd43c AL	500	unlink(FileName.c_str());
4decd43c AL	501	iFd = open(FileName.c_str(),O_RDWR \| O_CREAT \| O_EXCL,Perms);
f08fcf34	502	break;
578bfd0a AL	503	}
	504
	505	if (iFd < 0)
b2e465d6	506	return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
13d87e2e AL	507
	508	this->FileName = FileName;
	509	SetCloseExec(iFd,true);
	510	return true;
578bfd0a AL	511	}
578bfd0a AL	512	/}}}/
8e06abb2	513	// FileFd::~File - Closes the file /{{{/
578bfd0a AL	514	// ---------------------------------------------------------------------
	515	/* If the proper modes are selected then we close the Fd and possibly
	516	unlink the file on error. */
8e06abb2	517	FileFd::~FileFd()
578bfd0a AL	518	{
	519	Close();
	520	}
	521	/}}}/
8e06abb2	522	// FileFd::Read - Read a bit of the file /{{{/
578bfd0a	523	// ---------------------------------------------------------------------
b0db36b1 AL	524	/* We are carefull to handle interruption by a signal while reading
b0db36b1 AL	525	gracefully. */
f604cf55	526	bool FileFd::Read(void To,unsigned long Size,unsigned long Actual)
578bfd0a	527	{
b0db36b1 AL	528	int Res;
b0db36b1 AL	529	errno = 0;
f604cf55 AL	530	if (Actual != 0)
	531	*Actual = 0;
	532
b0db36b1	533	do
578bfd0a	534	{
b0db36b1 AL	535	Res = read(iFd,To,Size);
	536	if (Res < 0 && errno == EINTR)
	537	continue;
	538	if (Res < 0)
	539	{
	540	Flags \|= Fail;
b2e465d6	541	return _error->Errno("read",_("Read error"));
b0db36b1	542	}
578bfd0a	543
b0db36b1 AL	544	To = (char *)To + Res;
b0db36b1 AL	545	Size -= Res;
f604cf55 AL	546	if (Actual != 0)
f604cf55 AL	547	*Actual += Res;
b0db36b1 AL	548	}
	549	while (Res > 0 && Size > 0);
	550
	551	if (Size == 0)
	552	return true;
	553
ddc1d8d0	554	// Eof handling
f604cf55	555	if (Actual != 0)
ddc1d8d0 AL	556	{
	557	Flags \|= HitEof;
	558	return true;
	559	}
	560
b0db36b1	561	Flags \|= Fail;
b2e465d6	562	return _error->Error(_("read, still have %lu to read but none left"),Size);
578bfd0a AL	563	}
578bfd0a AL	564	/}}}/
8e06abb2	565	// FileFd::Write - Write to the file /{{{/
578bfd0a AL	566	// ---------------------------------------------------------------------
578bfd0a AL	567	/* */
a05599f1	568	bool FileFd::Write(const void *From,unsigned long Size)
578bfd0a	569	{
b0db36b1 AL	570	int Res;
	571	errno = 0;
	572	do
578bfd0a	573	{
b0db36b1 AL	574	Res = write(iFd,From,Size);
	575	if (Res < 0 && errno == EINTR)
	576	continue;
	577	if (Res < 0)
	578	{
	579	Flags \|= Fail;
b2e465d6	580	return _error->Errno("write",_("Write error"));
b0db36b1 AL	581	}
	582
	583	From = (char *)From + Res;
	584	Size -= Res;
578bfd0a	585	}
b0db36b1	586	while (Res > 0 && Size > 0);
578bfd0a	587
b0db36b1 AL	588	if (Size == 0)
	589	return true;
	590
	591	Flags \|= Fail;
b2e465d6	592	return _error->Error(_("write, still have %lu to write but couldn't"),Size);
578bfd0a AL	593	}
578bfd0a AL	594	/}}}/
8e06abb2	595	// FileFd::Seek - Seek in the file /{{{/
578bfd0a AL	596	// ---------------------------------------------------------------------
578bfd0a AL	597	/* */
8e06abb2	598	bool FileFd::Seek(unsigned long To)
578bfd0a AL	599	{
	600	if (lseek(iFd,To,SEEK_SET) != (signed)To)
	601	{
	602	Flags \|= Fail;
b2e465d6	603	return _error->Error("Unable to seek to %lu",To);
578bfd0a AL	604	}
578bfd0a AL	605
727f18af AL	606	return true;
	607	}
	608	/}}}/
	609	// FileFd::Skip - Seek in the file /{{{/
	610	// ---------------------------------------------------------------------
	611	/* */
	612	bool FileFd::Skip(unsigned long Over)
	613	{
	614	if (lseek(iFd,Over,SEEK_CUR) < 0)
	615	{
	616	Flags \|= Fail;
b2e465d6	617	return _error->Error("Unable to seek ahead %lu",Over);
727f18af AL	618	}
727f18af AL	619
6d5dd02a AL	620	return true;
	621	}
	622	/}}}/
	623	// FileFd::Truncate - Truncate the file /{{{/
	624	// ---------------------------------------------------------------------
	625	/* */
	626	bool FileFd::Truncate(unsigned long To)
	627	{
	628	if (ftruncate(iFd,To) != 0)
	629	{
	630	Flags \|= Fail;
b2e465d6	631	return _error->Error("Unable to truncate to %lu",To);
6d5dd02a AL	632	}
6d5dd02a AL	633
578bfd0a AL	634	return true;
	635	}
	636	/}}}/
7f25bdff AL	637	// FileFd::Tell - Current seek position /{{{/
	638	// ---------------------------------------------------------------------
	639	/* */
	640	unsigned long FileFd::Tell()
	641	{
	642	off_t Res = lseek(iFd,0,SEEK_CUR);
	643	if (Res == (off_t)-1)
	644	_error->Errno("lseek","Failed to determine the current file position");
	645	return Res;
	646	}
	647	/}}}/
8e06abb2	648	// FileFd::Size - Return the size of the file /{{{/
578bfd0a AL	649	// ---------------------------------------------------------------------
578bfd0a AL	650	/* */
8e06abb2	651	unsigned long FileFd::Size()
578bfd0a AL	652	{
	653	struct stat Buf;
	654	if (fstat(iFd,&Buf) != 0)
	655	return _error->Errno("fstat","Unable to determine the file size");
	656	return Buf.st_size;
	657	}
	658	/}}}/
8e06abb2	659	// FileFd::Close - Close the file if the close flag is set /{{{/
578bfd0a AL	660	// ---------------------------------------------------------------------
578bfd0a AL	661	/* */
8e06abb2	662	bool FileFd::Close()
578bfd0a AL	663	{
	664	bool Res = true;
	665	if ((Flags & AutoClose) == AutoClose)
1164783d	666	if (iFd >= 0 && close(iFd) != 0)
b2e465d6	667	Res &= _error->Errno("close",_("Problem closing the file"));
1164783d AL	668	iFd = -1;
1164783d AL	669
578bfd0a AL	670	if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
	671	FileName.empty() == false)
	672	if (unlink(FileName.c_str()) != 0)
b2e465d6	673	Res &= _error->WarningE("unlnk",_("Problem unlinking the file"));
578bfd0a AL	674	return Res;
	675	}
	676	/}}}/
b2e465d6 AL	677	// FileFd::Sync - Sync the file /{{{/
	678	// ---------------------------------------------------------------------
	679	/* */
	680	bool FileFd::Sync()
	681	{
	682	#ifdef _POSIX_SYNCHRONIZED_IO
	683	if (fsync(iFd) != 0)
	684	return _error->Errno("sync",_("Problem syncing the file"));
	685	#endif
	686	return true;
	687	}
	688	/}}}/