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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: fileutl.h,v 1.26 2001/05/07 05:06:52 jgg Exp $
/* ######################################################################
   
   File Utilities
   
   CopyFile - Buffered copy of a single file
   GetLock - dpkg compatible lock file manipulation (fcntl)
   FileExists - Returns true if the file exists
   SafeGetCWD - Returns the CWD in a string with overrun protection 
   
   The file class is a handy abstraction for various functions+classes
   that need to accept filenames.
   
   This source is placed in the Public Domain, do with it what you will
   It was originally written by Jason Gunthorpe.
   
   ##################################################################### */
									/*}}}*/
#ifndef PKGLIB_FILEUTL_H
#define PKGLIB_FILEUTL_H

#include <apt-pkg/macros.h>
#include <apt-pkg/aptconfiguration.h>

#include <string>
#include <vector>
#include <set>
#include <time.h>

#include <zlib.h>

#ifndef APT_8_CLEANER_HEADERS
using std::string;
#endif

/* Define this for python-apt */
#define APT_HAS_GZIP 1

class FileFdPrivate;
class FileFd
{
   protected:
   int iFd;
 
   enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
                    HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) };
   unsigned long Flags;
   std::string FileName;
   std::string TemporaryFileName;

   public:
   enum OpenMode {
	ReadOnly = (1 << 0),
	WriteOnly = (1 << 1),
	ReadWrite = ReadOnly | WriteOnly,

	Create = (1 << 2),
	Exclusive = (1 << 3),
	Atomic = Exclusive | (1 << 4),
	Empty = (1 << 5),

	WriteEmpty = ReadWrite | Create | Empty,
	WriteExists = ReadWrite,
	WriteAny = ReadWrite | Create,
	WriteTemp = ReadWrite | Create | Exclusive,
	ReadOnlyGzip,
	WriteAtomic = ReadWrite | Create | Atomic
   };
   enum CompressMode { Auto = 'A', None = 'N', Extension = 'E', Gzip = 'G', Bzip2 = 'B', Lzma = 'L', Xz = 'X' };
   
   inline bool Read(void *To,unsigned long long Size,bool AllowEof)
   {
      unsigned long long Jnk;
      if (AllowEof)
	 return Read(To,Size,&Jnk);
      return Read(To,Size);
   }   
   bool Read(void *To,unsigned long long Size,unsigned long long *Actual = 0);
   char* ReadLine(char *To, unsigned long long const Size);
   bool Write(const void *From,unsigned long long Size);
   bool static Write(int Fd, const void *From, unsigned long long Size);
   bool Seek(unsigned long long To);
   bool Skip(unsigned long long To);
   bool Truncate(unsigned long long To);
   unsigned long long Tell();
   // the size of the file content (compressed files will be uncompressed first)
   unsigned long long Size();
   // the size of the file itself
   unsigned long long FileSize();
   time_t ModificationTime();

   /* You want to use 'unsigned long long' if you are talking about a file
      to be able to support large files (>2 or >4 GB) properly.
      This shouldn't happen all to often for the indexes, but deb's might be…
      And as the auto-conversation converts a 'unsigned long *' to a 'bool'
      instead of 'unsigned long long *' we need to provide this explicitely -
      otherwise applications magically start to fail… */
   bool Read(void *To,unsigned long long Size,unsigned long *Actual) APT_DEPRECATED
   {
	unsigned long long R;
	bool const T = Read(To, Size, &R);
	*Actual = R;
	return T;
   }

   bool Open(std::string FileName,unsigned int const Mode,CompressMode Compress,unsigned long const AccessMode = 0666);
   bool Open(std::string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor,unsigned long const AccessMode = 0666);
   inline bool Open(std::string const &FileName,unsigned int const Mode, unsigned long const AccessMode = 0666) {
      return Open(FileName, Mode, None, AccessMode);
   };
   bool OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose=false);
   bool OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose=false);
   inline bool OpenDescriptor(int Fd, unsigned int const Mode, bool AutoClose=false) {
      return OpenDescriptor(Fd, Mode, None, AutoClose);
   };
   bool Close();
   bool Sync();
   
   // Simple manipulators
   inline int Fd() {return iFd;};
   inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);};
   gzFile gzFd() APT_DEPRECATED APT_PURE;

   inline bool IsOpen() {return iFd >= 0;};
   inline bool Failed() {return (Flags & Fail) == Fail;};
   inline void EraseOnFailure() {Flags |= DelOnFail;};
   inline void OpFail() {Flags |= Fail;};
   inline bool Eof() {return (Flags & HitEof) == HitEof;};
   inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
   inline std::string &Name() {return FileName;};
   
   FileFd(std::string FileName,unsigned int const Mode,unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
   {
      Open(FileName,Mode, None, AccessMode);
   };
   FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
   {
      Open(FileName,Mode, Compress, AccessMode);
   };
   FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {};
   FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL)
   {
      OpenDescriptor(Fd, Mode, Compress);
   };
   FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
   {
      OpenDescriptor(Fd, ReadWrite, None, AutoClose);
   };
   virtual ~FileFd();

   private:
   FileFdPrivate* d;
   APT_HIDDEN bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor);

   // private helpers to set Fail flag and call _error->Error
   APT_HIDDEN bool FileFdErrno(const char* Function, const char* Description,...) APT_PRINTF(3) APT_COLD;
   APT_HIDDEN bool FileFdError(const char* Description,...) APT_PRINTF(2) APT_COLD;
};

bool RunScripts(const char *Cnf);
bool CopyFile(FileFd &From,FileFd &To);
int GetLock(std::string File,bool Errors = true);
bool FileExists(std::string File);
bool RealFileExists(std::string File);
bool DirectoryExists(std::string const &Path) APT_CONST;
bool CreateDirectory(std::string const &Parent, std::string const &Path);
time_t GetModificationTime(std::string const &Path);
bool Rename(std::string From, std::string To);

std::string GetTempDir();
FileFd* GetTempFile(std::string const &Prefix = "", 
                    bool ImmediateUnlink = true);

/** \brief Ensure the existence of the given Path
 *
 *  \param Parent directory of the Path directory - a trailing
 *  /apt/ will be removed before CreateDirectory call.
 *  \param Path which should exist after (successful) call
 */
bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);

std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
					bool const &SortList, bool const &AllowNoExt=false);
std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
					bool const &SortList);
std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
std::string SafeGetCWD();
void SetCloseExec(int Fd,bool Close);
void SetNonBlock(int Fd,bool Block);
bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
pid_t ExecFork();
pid_t ExecFork(std::set<int> keep_fds);
void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds);
bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);


// check if the given file starts with a PGP cleartext signature
bool StartsWithGPGClearTextSignature(std::string const &FileName);

/**
 * \brief Drop privileges
 *
 * Drop the privileges to the user _apt (or the one specified in
 * APT::Sandbox::User). This does not set the supplementary group
 * ids up correctly, it only uses the default group. Also prevent
 * the process from gaining any new privileges afterwards, at least
 * on Linux.
 *
 * \return true on success, false on failure with _error set
 */
bool DropPrivs();

// File string manipulators
std::string flNotDir(std::string File);
std::string flNotFile(std::string File);
std::string flNoLink(std::string File);
std::string flExtension(std::string File);
std::string flCombine(std::string Dir,std::string File);

/** \brief Takes a file path and returns the absolute path
 */
std::string flAbsPath(std::string File);

// simple c++ glob
std::vector<std::string> Glob(std::string const &pattern, int flags=0);

/** \brief Popen() implementation that execv() instead of using a shell
 *
 * \param Args the execv style command to run
 * \param FileFd is a referenz to the FileFd to use for input or output
 * \param Child a reference to the integer that stores the child pid
 *        Note that you must call ExecWait() or similar to cleanup
 * \param Mode is either FileFd::ReadOnly or FileFd::WriteOnly
 * \return true on success, false on failure with _error set
 */
bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode);


#endif
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
233b185f	3	// $Id: fileutl.h,v 1.26 2001/05/07 05:06:52 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	FileExists - Returns true if the file exists
	11	SafeGetCWD - Returns the CWD in a string with overrun protection
	12
	13	The file class is a handy abstraction for various functions+classes
	14	that need to accept filenames.
	15
	16	This source is placed in the Public Domain, do with it what you will
	17	It was originally written by Jason Gunthorpe.
	18
	19	##################################################################### */
	20	/}}}/
578bfd0a AL	21	#ifndef PKGLIB_FILEUTL_H
	22	#define PKGLIB_FILEUTL_H
	23
1cd1c398	24	#include <apt-pkg/macros.h>
699b209e	25	#include <apt-pkg/aptconfiguration.h>
6c139d6e	26
578bfd0a	27	#include <string>
46e39c8e	28	#include <vector>
e45c4617	29	#include <set>
453b82a3	30	#include <time.h>
578bfd0a	31
a3a03f5d	32	#include <zlib.h>
a3a03f5d	33
a4f6bdc8 DK	34	#ifndef APT_8_CLEANER_HEADERS
	35	using std::string;
	36	#endif
	37
144c0969 JAK	38	/* Define this for python-apt */
	39	#define APT_HAS_GZIP 1
	40
032bd56f	41	class FileFdPrivate;
8e06abb2	42	class FileFd
578bfd0a AL	43	{
	44	protected:
	45	int iFd;
	46
ddc1d8d0	47	enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
032bd56f	48	HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) };
578bfd0a	49	unsigned long Flags;
8f3ba4e8 DK	50	std::string FileName;
8f3ba4e8 DK	51	std::string TemporaryFileName;
3184b4cf	52
578bfd0a	53	public:
257e8d66 DK	54	enum OpenMode {
	55	ReadOnly = (1 << 0),
	56	WriteOnly = (1 << 1),
	57	ReadWrite = ReadOnly \| WriteOnly,
	58
	59	Create = (1 << 2),
	60	Exclusive = (1 << 3),
	61	Atomic = Exclusive \| (1 << 4),
	62	Empty = (1 << 5),
	63
	64	WriteEmpty = ReadWrite \| Create \| Empty,
	65	WriteExists = ReadWrite,
	66	WriteAny = ReadWrite \| Create,
	67	WriteTemp = ReadWrite \| Create \| Exclusive,
	68	ReadOnlyGzip,
	69	WriteAtomic = ReadWrite \| Create \| Atomic
	70	};
468720c5	71	enum CompressMode { Auto = 'A', None = 'N', Extension = 'E', Gzip = 'G', Bzip2 = 'B', Lzma = 'L', Xz = 'X' };
578bfd0a	72
650faab0	73	inline bool Read(void *To,unsigned long long Size,bool AllowEof)
f604cf55	74	{
650faab0	75	unsigned long long Jnk;
f604cf55 AL	76	if (AllowEof)
	77	return Read(To,Size,&Jnk);
	78	return Read(To,Size);
	79	}
650faab0	80	bool Read(void To,unsigned long long Size,unsigned long long Actual = 0);
032bd56f	81	char* ReadLine(char *To, unsigned long long const Size);
650faab0	82	bool Write(const void *From,unsigned long long Size);
d68d65ad	83	bool static Write(int Fd, const void *From, unsigned long long Size);
650faab0 DK	84	bool Seek(unsigned long long To);
	85	bool Skip(unsigned long long To);
	86	bool Truncate(unsigned long long To);
	87	unsigned long long Tell();
ca7fd76c	88	// the size of the file content (compressed files will be uncompressed first)
650faab0	89	unsigned long long Size();
ca7fd76c	90	// the size of the file itself
650faab0	91	unsigned long long FileSize();
76a763e1	92	time_t ModificationTime();
650faab0 DK	93
	94	/* You want to use 'unsigned long long' if you are talking about a file
	95	to be able to support large files (>2 or >4 GB) properly.
	96	This shouldn't happen all to often for the indexes, but deb's might be…
	97	And as the auto-conversation converts a 'unsigned long *' to a 'bool'
	98	instead of 'unsigned long long *' we need to provide this explicitely -
	99	otherwise applications magically start to fail… */
453b82a3	100	bool Read(void To,unsigned long long Size,unsigned long Actual) APT_DEPRECATED
650faab0 DK	101	{
	102	unsigned long long R;
	103	bool const T = Read(To, Size, &R);
	104	*Actual = R;
	105	return T;
	106	}
	107
e5f3f8c1 MV	108	bool Open(std::string FileName,unsigned int const Mode,CompressMode Compress,unsigned long const AccessMode = 0666);
	109	bool Open(std::string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor,unsigned long const AccessMode = 0666);
	110	inline bool Open(std::string const &FileName,unsigned int const Mode, unsigned long const AccessMode = 0666) {
	111	return Open(FileName, Mode, None, AccessMode);
257e8d66	112	};
52b47296 DK	113	bool OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose=false);
	114	bool OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose=false);
	115	inline bool OpenDescriptor(int Fd, unsigned int const Mode, bool AutoClose=false) {
bce778a3	116	return OpenDescriptor(Fd, Mode, None, AutoClose);
257e8d66	117	};
578bfd0a	118	bool Close();
b2e465d6 AL	119	bool Sync();
b2e465d6 AL	120
578bfd0a AL	121	// Simple manipulators
578bfd0a AL	122	inline int Fd() {return iFd;};
d0254ba7	123	inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);};
a02db58f	124	gzFile gzFd() APT_DEPRECATED APT_PURE;
699b209e	125
578bfd0a AL	126	inline bool IsOpen() {return iFd >= 0;};
	127	inline bool Failed() {return (Flags & Fail) == Fail;};
	128	inline void EraseOnFailure() {Flags \|= DelOnFail;};
	129	inline void OpFail() {Flags \|= Fail;};
ddc1d8d0	130	inline bool Eof() {return (Flags & HitEof) == HitEof;};
032bd56f	131	inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
8f3ba4e8	132	inline std::string &Name() {return FileName;};
c7b5ce1c	133
e5f3f8c1	134	FileFd(std::string FileName,unsigned int const Mode,unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
13d87e2e	135	{
e5f3f8c1	136	Open(FileName,Mode, None, AccessMode);
468720c5	137	};
e5f3f8c1	138	FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
468720c5	139	{
e5f3f8c1	140	Open(FileName,Mode, Compress, AccessMode);
13d87e2e	141	};
032bd56f	142	FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {};
52b47296	143	FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL)
032bd56f DK	144	{
	145	OpenDescriptor(Fd, Mode, Compress);
	146	};
	147	FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
	148	{
	149	OpenDescriptor(Fd, ReadWrite, None, AutoClose);
	150	};
8e06abb2	151	virtual ~FileFd();
468720c5 DK	152
468720c5 DK	153	private:
032bd56f	154	FileFdPrivate* d;
ce62f1de	155	APT_HIDDEN bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor);
ae635e3c DK	156
ae635e3c DK	157	// private helpers to set Fail flag and call _error->Error
ce62f1de DK	158	APT_HIDDEN bool FileFdErrno(const char* Function, const char* Description,...) APT_PRINTF(3) APT_COLD;
ce62f1de DK	159	APT_HIDDEN bool FileFdError(const char* Description,...) APT_PRINTF(2) APT_COLD;
578bfd0a AL	160	};
578bfd0a AL	161
614adaa0	162	bool RunScripts(const char *Cnf);
8b89e57f	163	bool CopyFile(FileFd &From,FileFd &To);
8f3ba4e8 DK	164	int GetLock(std::string File,bool Errors = true);
	165	bool FileExists(std::string File);
	166	bool RealFileExists(std::string File);
453b82a3	167	bool DirectoryExists(std::string const &Path) APT_CONST;
8f3ba4e8 DK	168	bool CreateDirectory(std::string const &Parent, std::string const &Path);
8f3ba4e8 DK	169	time_t GetModificationTime(std::string const &Path);
c1409d1b	170	bool Rename(std::string From, std::string To);
b29c3712	171
68e01721	172	std::string GetTempDir();
0d29b9d4 MV	173	FileFd* GetTempFile(std::string const &Prefix = "",
0d29b9d4 MV	174	bool ImmediateUnlink = true);
68e01721	175
b29c3712 DK	176	/** \brief Ensure the existence of the given Path
	177	*
	178	* \param Parent directory of the Path directory - a trailing
	179	* /apt/ will be removed before CreateDirectory call.
	180	* \param Path which should exist after (successful) call
	181	*/
8f3ba4e8	182	bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
b29c3712	183
8f3ba4e8	184	std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
b3793d41	185	bool const &SortList, bool const &AllowNoExt=false);
8f3ba4e8	186	std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
b39c1859	187	bool const &SortList);
fbb2c7e0	188	std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
8f3ba4e8	189	std::string SafeGetCWD();
3b5421b4 AL	190	void SetCloseExec(int Fd,bool Close);
3b5421b4 AL	191	void SetNonBlock(int Fd,bool Block);
1084d58a	192	bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
75ef8f14	193	pid_t ExecFork();
e45c4617	194	pid_t ExecFork(std::set<int> keep_fds);
96ae6de5	195	void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds);
3826564e	196	bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
578bfd0a	197
17091f2f	198
479a2beb	199	// check if the given file starts with a PGP cleartext signature
fe5804fc	200	bool StartsWithGPGClearTextSignature(std::string const &FileName);
0854ad8b	201
13a28d85 JAK	202	/**
	203	* \brief Drop privileges
	204	*
	205	* Drop the privileges to the user _apt (or the one specified in
	206	* APT::Sandbox::User). This does not set the supplementary group
	207	* ids up correctly, it only uses the default group. Also prevent
	208	* the process from gaining any new privileges afterwards, at least
	209	* on Linux.
	210	*
	211	* \return true on success, false on failure with _error set
	212	*/
fc1a78d8 MV	213	bool DropPrivs();
fc1a78d8 MV	214
8ce4327b	215	// File string manipulators
8f3ba4e8 DK	216	std::string flNotDir(std::string File);
	217	std::string flNotFile(std::string File);
	218	std::string flNoLink(std::string File);
	219	std::string flExtension(std::string File);
	220	std::string flCombine(std::string Dir,std::string File);
8ce4327b	221
53ac87ac MV	222	/** \brief Takes a file path and returns the absolute path
	223	*/
	224	std::string flAbsPath(std::string File);
	225
8d01b9d6 MV	226	// simple c++ glob
8d01b9d6 MV	227	std::vector<std::string> Glob(std::string const &pattern, int flags=0);
0854ad8b	228
7ad2a347 MV	229	/** \brief Popen() implementation that execv() instead of using a shell
	230	*
	231	* \param Args the execv style command to run
	232	* \param FileFd is a referenz to the FileFd to use for input or output
	233	* \param Child a reference to the integer that stores the child pid
	234	* Note that you must call ExecWait() or similar to cleanup
	235	* \param Mode is either FileFd::ReadOnly or FileFd::WriteOnly
	236	* \return true on success, false on failure with _error set
	237	*/
	238	bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode);
	239
	240
578bfd0a	241	#endif