]> git.saurik.com Git - apt.git/blob - apt-pkg/contrib/fileutl.h
Merge branch 'feature/test-apt-key-net-update' into debian/sid
[apt.git] / apt-pkg / contrib / fileutl.h
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: fileutl.h,v 1.26 2001/05/07 05:06:52 jgg Exp $
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 /*}}}*/
21 #ifndef PKGLIB_FILEUTL_H
22 #define PKGLIB_FILEUTL_H
23
24 #include <apt-pkg/macros.h>
25 #include <apt-pkg/aptconfiguration.h>
26
27 #include <string>
28 #include <vector>
29 #include <set>
30
31 #include <zlib.h>
32
33 #ifndef APT_8_CLEANER_HEADERS
34 using std::string;
35 #endif
36
37 /* Define this for python-apt */
38 #define APT_HAS_GZIP 1
39
40 class FileFdPrivate;
41 class FileFd
42 {
43 protected:
44 int iFd;
45
46 enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
47 HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) };
48 unsigned long Flags;
49 std::string FileName;
50 std::string TemporaryFileName;
51
52 public:
53 enum OpenMode {
54 ReadOnly = (1 << 0),
55 WriteOnly = (1 << 1),
56 ReadWrite = ReadOnly | WriteOnly,
57
58 Create = (1 << 2),
59 Exclusive = (1 << 3),
60 Atomic = Exclusive | (1 << 4),
61 Empty = (1 << 5),
62
63 WriteEmpty = ReadWrite | Create | Empty,
64 WriteExists = ReadWrite,
65 WriteAny = ReadWrite | Create,
66 WriteTemp = ReadWrite | Create | Exclusive,
67 ReadOnlyGzip,
68 WriteAtomic = ReadWrite | Create | Atomic
69 };
70 enum CompressMode { Auto = 'A', None = 'N', Extension = 'E', Gzip = 'G', Bzip2 = 'B', Lzma = 'L', Xz = 'X' };
71
72 inline bool Read(void *To,unsigned long long Size,bool AllowEof)
73 {
74 unsigned long long Jnk;
75 if (AllowEof)
76 return Read(To,Size,&Jnk);
77 return Read(To,Size);
78 }
79 bool Read(void *To,unsigned long long Size,unsigned long long *Actual = 0);
80 char* ReadLine(char *To, unsigned long long const Size);
81 bool Write(const void *From,unsigned long long Size);
82 bool static Write(int Fd, const void *From, unsigned long long Size);
83 bool Seek(unsigned long long To);
84 bool Skip(unsigned long long To);
85 bool Truncate(unsigned long long To);
86 unsigned long long Tell();
87 unsigned long long Size();
88 unsigned long long FileSize();
89 time_t ModificationTime();
90
91 /* You want to use 'unsigned long long' if you are talking about a file
92 to be able to support large files (>2 or >4 GB) properly.
93 This shouldn't happen all to often for the indexes, but deb's might be…
94 And as the auto-conversation converts a 'unsigned long *' to a 'bool'
95 instead of 'unsigned long long *' we need to provide this explicitely -
96 otherwise applications magically start to fail… */
97 __deprecated bool Read(void *To,unsigned long long Size,unsigned long *Actual)
98 {
99 unsigned long long R;
100 bool const T = Read(To, Size, &R);
101 *Actual = R;
102 return T;
103 }
104
105 bool Open(std::string FileName,unsigned int const Mode,CompressMode Compress,unsigned long const Perms = 0666);
106 bool Open(std::string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor,unsigned long const Perms = 0666);
107 inline bool Open(std::string const &FileName,unsigned int const Mode, unsigned long const Perms = 0666) {
108 return Open(FileName, Mode, None, Perms);
109 };
110 bool OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose=false);
111 bool OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose=false);
112 inline bool OpenDescriptor(int Fd, unsigned int const Mode, bool AutoClose=false) {
113 return OpenDescriptor(Fd, Mode, None, AutoClose);
114 };
115 bool Close();
116 bool Sync();
117
118 // Simple manipulators
119 inline int Fd() {return iFd;};
120 inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);};
121 __deprecated gzFile gzFd();
122
123 inline bool IsOpen() {return iFd >= 0;};
124 inline bool Failed() {return (Flags & Fail) == Fail;};
125 inline void EraseOnFailure() {Flags |= DelOnFail;};
126 inline void OpFail() {Flags |= Fail;};
127 inline bool Eof() {return (Flags & HitEof) == HitEof;};
128 inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
129 inline std::string &Name() {return FileName;};
130
131 FileFd(std::string FileName,unsigned int const Mode,unsigned long Perms = 0666) : iFd(-1), Flags(0), d(NULL)
132 {
133 Open(FileName,Mode, None, Perms);
134 };
135 FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long Perms = 0666) : iFd(-1), Flags(0), d(NULL)
136 {
137 Open(FileName,Mode, Compress, Perms);
138 };
139 FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {};
140 FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL)
141 {
142 OpenDescriptor(Fd, Mode, Compress);
143 };
144 FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
145 {
146 OpenDescriptor(Fd, ReadWrite, None, AutoClose);
147 };
148 virtual ~FileFd();
149
150 private:
151 FileFdPrivate* d;
152 bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor);
153
154 // private helpers to set Fail flag and call _error->Error
155 bool FileFdErrno(const char* Function, const char* Description,...) __like_printf(3) __cold;
156 bool FileFdError(const char* Description,...) __like_printf(2) __cold;
157 };
158
159 bool RunScripts(const char *Cnf);
160 bool CopyFile(FileFd &From,FileFd &To);
161 int GetLock(std::string File,bool Errors = true);
162 bool FileExists(std::string File);
163 bool RealFileExists(std::string File);
164 bool DirectoryExists(std::string const &Path) __attrib_const;
165 bool CreateDirectory(std::string const &Parent, std::string const &Path);
166 time_t GetModificationTime(std::string const &Path);
167
168 std::string GetTempDir();
169
170 /** \brief Ensure the existence of the given Path
171 *
172 * \param Parent directory of the Path directory - a trailing
173 * /apt/ will be removed before CreateDirectory call.
174 * \param Path which should exist after (successful) call
175 */
176 bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
177
178 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
179 bool const &SortList, bool const &AllowNoExt=false);
180 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
181 bool const &SortList);
182 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
183 std::string SafeGetCWD();
184 void SetCloseExec(int Fd,bool Close);
185 void SetNonBlock(int Fd,bool Block);
186 bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
187 pid_t ExecFork();
188 pid_t ExecFork(std::set<int> keep_fds);
189 void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds);
190 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
191
192 // File string manipulators
193 std::string flNotDir(std::string File);
194 std::string flNotFile(std::string File);
195 std::string flNoLink(std::string File);
196 std::string flExtension(std::string File);
197 std::string flCombine(std::string Dir,std::string File);
198
199 // simple c++ glob
200 std::vector<std::string> Glob(std::string const &pattern, int flags=0);
201
202 #endif