[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();
   unsigned long long Size();
   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);

// process releated
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();
	88	unsigned long long Size();
	89	unsigned long long FileSize();
76a763e1	90	time_t ModificationTime();
650faab0 DK	91
	92	/* You want to use 'unsigned long long' if you are talking about a file
	93	to be able to support large files (>2 or >4 GB) properly.
	94	This shouldn't happen all to often for the indexes, but deb's might be…
	95	And as the auto-conversation converts a 'unsigned long *' to a 'bool'
	96	instead of 'unsigned long long *' we need to provide this explicitely -
	97	otherwise applications magically start to fail… */
453b82a3	98	bool Read(void To,unsigned long long Size,unsigned long Actual) APT_DEPRECATED
650faab0 DK	99	{
	100	unsigned long long R;
	101	bool const T = Read(To, Size, &R);
	102	*Actual = R;
	103	return T;
	104	}
	105
e5f3f8c1 MV	106	bool Open(std::string FileName,unsigned int const Mode,CompressMode Compress,unsigned long const AccessMode = 0666);
	107	bool Open(std::string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor,unsigned long const AccessMode = 0666);
	108	inline bool Open(std::string const &FileName,unsigned int const Mode, unsigned long const AccessMode = 0666) {
	109	return Open(FileName, Mode, None, AccessMode);
257e8d66	110	};
52b47296 DK	111	bool OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose=false);
	112	bool OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose=false);
	113	inline bool OpenDescriptor(int Fd, unsigned int const Mode, bool AutoClose=false) {
bce778a3	114	return OpenDescriptor(Fd, Mode, None, AutoClose);
257e8d66	115	};
578bfd0a	116	bool Close();
b2e465d6 AL	117	bool Sync();
b2e465d6 AL	118
578bfd0a AL	119	// Simple manipulators
578bfd0a AL	120	inline int Fd() {return iFd;};
d0254ba7	121	inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);};
a02db58f	122	gzFile gzFd() APT_DEPRECATED APT_PURE;
699b209e	123
578bfd0a AL	124	inline bool IsOpen() {return iFd >= 0;};
	125	inline bool Failed() {return (Flags & Fail) == Fail;};
	126	inline void EraseOnFailure() {Flags \|= DelOnFail;};
	127	inline void OpFail() {Flags \|= Fail;};
ddc1d8d0	128	inline bool Eof() {return (Flags & HitEof) == HitEof;};
032bd56f	129	inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
8f3ba4e8	130	inline std::string &Name() {return FileName;};
c7b5ce1c	131
e5f3f8c1	132	FileFd(std::string FileName,unsigned int const Mode,unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
13d87e2e	133	{
e5f3f8c1	134	Open(FileName,Mode, None, AccessMode);
468720c5	135	};
e5f3f8c1	136	FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
468720c5	137	{
e5f3f8c1	138	Open(FileName,Mode, Compress, AccessMode);
13d87e2e	139	};
032bd56f	140	FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {};
52b47296	141	FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL)
032bd56f DK	142	{
	143	OpenDescriptor(Fd, Mode, Compress);
	144	};
	145	FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
	146	{
	147	OpenDescriptor(Fd, ReadWrite, None, AutoClose);
	148	};
8e06abb2	149	virtual ~FileFd();
468720c5 DK	150
468720c5 DK	151	private:
032bd56f	152	FileFdPrivate* d;
ce62f1de	153	APT_HIDDEN bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor);
ae635e3c DK	154
ae635e3c DK	155	// private helpers to set Fail flag and call _error->Error
ce62f1de DK	156	APT_HIDDEN bool FileFdErrno(const char* Function, const char* Description,...) APT_PRINTF(3) APT_COLD;
ce62f1de DK	157	APT_HIDDEN bool FileFdError(const char* Description,...) APT_PRINTF(2) APT_COLD;
578bfd0a AL	158	};
578bfd0a AL	159
614adaa0	160	bool RunScripts(const char *Cnf);
8b89e57f	161	bool CopyFile(FileFd &From,FileFd &To);
8f3ba4e8 DK	162	int GetLock(std::string File,bool Errors = true);
	163	bool FileExists(std::string File);
	164	bool RealFileExists(std::string File);
453b82a3	165	bool DirectoryExists(std::string const &Path) APT_CONST;
8f3ba4e8 DK	166	bool CreateDirectory(std::string const &Parent, std::string const &Path);
8f3ba4e8 DK	167	time_t GetModificationTime(std::string const &Path);
c1409d1b	168	bool Rename(std::string From, std::string To);
b29c3712	169
68e01721	170	std::string GetTempDir();
0d29b9d4 MV	171	FileFd* GetTempFile(std::string const &Prefix = "",
0d29b9d4 MV	172	bool ImmediateUnlink = true);
68e01721	173
b29c3712 DK	174	/** \brief Ensure the existence of the given Path
	175	*
	176	* \param Parent directory of the Path directory - a trailing
	177	* /apt/ will be removed before CreateDirectory call.
	178	* \param Path which should exist after (successful) call
	179	*/
8f3ba4e8	180	bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
b29c3712	181
8f3ba4e8	182	std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
b3793d41	183	bool const &SortList, bool const &AllowNoExt=false);
8f3ba4e8	184	std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
b39c1859	185	bool const &SortList);
fbb2c7e0	186	std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
8f3ba4e8	187	std::string SafeGetCWD();
3b5421b4 AL	188	void SetCloseExec(int Fd,bool Close);
3b5421b4 AL	189	void SetNonBlock(int Fd,bool Block);
1084d58a	190	bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
75ef8f14	191	pid_t ExecFork();
e45c4617	192	pid_t ExecFork(std::set<int> keep_fds);
96ae6de5	193	void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds);
3826564e	194	bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
578bfd0a	195
17091f2f	196
479a2beb	197	// check if the given file starts with a PGP cleartext signature
fe5804fc	198	bool StartsWithGPGClearTextSignature(std::string const &FileName);
0854ad8b	199
fc1a78d8 MV	200	// process releated
	201	bool DropPrivs();
	202
8ce4327b	203	// File string manipulators
8f3ba4e8 DK	204	std::string flNotDir(std::string File);
	205	std::string flNotFile(std::string File);
	206	std::string flNoLink(std::string File);
	207	std::string flExtension(std::string File);
	208	std::string flCombine(std::string Dir,std::string File);
8ce4327b	209
53ac87ac MV	210	/** \brief Takes a file path and returns the absolute path
	211	*/
	212	std::string flAbsPath(std::string File);
	213
8d01b9d6 MV	214	// simple c++ glob
8d01b9d6 MV	215	std::vector<std::string> Glob(std::string const &pattern, int flags=0);
0854ad8b	216
7ad2a347 MV	217	/** \brief Popen() implementation that execv() instead of using a shell
	218	*
	219	* \param Args the execv style command to run
	220	* \param FileFd is a referenz to the FileFd to use for input or output
	221	* \param Child a reference to the integer that stores the child pid
	222	* Note that you must call ExecWait() or similar to cleanup
	223	* \param Mode is either FileFd::ReadOnly or FileFd::WriteOnly
	224	* \return true on success, false on failure with _error set
	225	*/
	226	bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode);
	227
	228
578bfd0a	229	#endif