]>
Commit | Line | Data |
---|---|---|
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 | #include <time.h> | |
31 | ||
32 | #include <zlib.h> | |
33 | ||
34 | #ifndef APT_8_CLEANER_HEADERS | |
35 | using std::string; | |
36 | #endif | |
37 | ||
38 | /* Define this for python-apt */ | |
39 | #define APT_HAS_GZIP 1 | |
40 | ||
41 | class FileFdPrivate; | |
42 | class FileFd | |
43 | { | |
44 | protected: | |
45 | int iFd; | |
46 | ||
47 | enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2), | |
48 | HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) }; | |
49 | unsigned long Flags; | |
50 | std::string FileName; | |
51 | std::string TemporaryFileName; | |
52 | ||
53 | public: | |
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 | }; | |
71 | enum CompressMode { Auto = 'A', None = 'N', Extension = 'E', Gzip = 'G', Bzip2 = 'B', Lzma = 'L', Xz = 'X' }; | |
72 | ||
73 | inline bool Read(void *To,unsigned long long Size,bool AllowEof) | |
74 | { | |
75 | unsigned long long Jnk; | |
76 | if (AllowEof) | |
77 | return Read(To,Size,&Jnk); | |
78 | return Read(To,Size); | |
79 | } | |
80 | bool Read(void *To,unsigned long long Size,unsigned long long *Actual = 0); | |
81 | char* ReadLine(char *To, unsigned long long const Size); | |
82 | bool Write(const void *From,unsigned long long Size); | |
83 | bool static Write(int Fd, const void *From, unsigned long long Size); | |
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(); | |
90 | time_t ModificationTime(); | |
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… */ | |
98 | bool Read(void *To,unsigned long long Size,unsigned long *Actual) APT_DEPRECATED | |
99 | { | |
100 | unsigned long long R; | |
101 | bool const T = Read(To, Size, &R); | |
102 | *Actual = R; | |
103 | return T; | |
104 | } | |
105 | ||
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); | |
110 | }; | |
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) { | |
114 | return OpenDescriptor(Fd, Mode, None, AutoClose); | |
115 | }; | |
116 | bool Close(); | |
117 | bool Sync(); | |
118 | ||
119 | // Simple manipulators | |
120 | inline int Fd() {return iFd;}; | |
121 | inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);}; | |
122 | gzFile gzFd() APT_DEPRECATED APT_PURE; | |
123 | ||
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;}; | |
128 | inline bool Eof() {return (Flags & HitEof) == HitEof;}; | |
129 | inline bool IsCompressed() {return (Flags & Compressed) == Compressed;}; | |
130 | inline std::string &Name() {return FileName;}; | |
131 | ||
132 | FileFd(std::string FileName,unsigned int const Mode,unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL) | |
133 | { | |
134 | Open(FileName,Mode, None, AccessMode); | |
135 | }; | |
136 | FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL) | |
137 | { | |
138 | Open(FileName,Mode, Compress, AccessMode); | |
139 | }; | |
140 | FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {}; | |
141 | FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL) | |
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 | }; | |
149 | virtual ~FileFd(); | |
150 | ||
151 | private: | |
152 | FileFdPrivate* d; | |
153 | APT_HIDDEN bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor); | |
154 | ||
155 | // private helpers to set Fail flag and call _error->Error | |
156 | APT_HIDDEN bool FileFdErrno(const char* Function, const char* Description,...) APT_PRINTF(3) APT_COLD; | |
157 | APT_HIDDEN bool FileFdError(const char* Description,...) APT_PRINTF(2) APT_COLD; | |
158 | }; | |
159 | ||
160 | bool RunScripts(const char *Cnf); | |
161 | bool CopyFile(FileFd &From,FileFd &To); | |
162 | int GetLock(std::string File,bool Errors = true); | |
163 | bool FileExists(std::string File); | |
164 | bool RealFileExists(std::string File); | |
165 | bool DirectoryExists(std::string const &Path) APT_CONST; | |
166 | bool CreateDirectory(std::string const &Parent, std::string const &Path); | |
167 | time_t GetModificationTime(std::string const &Path); | |
168 | bool Rename(std::string From, std::string To); | |
169 | ||
170 | std::string GetTempDir(); | |
171 | ||
172 | /** \brief Ensure the existence of the given Path | |
173 | * | |
174 | * \param Parent directory of the Path directory - a trailing | |
175 | * /apt/ will be removed before CreateDirectory call. | |
176 | * \param Path which should exist after (successful) call | |
177 | */ | |
178 | bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path); | |
179 | ||
180 | std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext, | |
181 | bool const &SortList, bool const &AllowNoExt=false); | |
182 | std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext, | |
183 | bool const &SortList); | |
184 | std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList); | |
185 | std::string SafeGetCWD(); | |
186 | void SetCloseExec(int Fd,bool Close); | |
187 | void SetNonBlock(int Fd,bool Block); | |
188 | bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0); | |
189 | pid_t ExecFork(); | |
190 | pid_t ExecFork(std::set<int> keep_fds); | |
191 | void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds); | |
192 | bool ExecWait(pid_t Pid,const char *Name,bool Reap = false); | |
193 | ||
194 | // File string manipulators | |
195 | std::string flNotDir(std::string File); | |
196 | std::string flNotFile(std::string File); | |
197 | std::string flNoLink(std::string File); | |
198 | std::string flExtension(std::string File); | |
199 | std::string flCombine(std::string Dir,std::string File); | |
200 | ||
201 | // simple c++ glob | |
202 | std::vector<std::string> Glob(std::string const &pattern, int flags=0); | |
203 | ||
204 | #endif |