apt  0.9.14.1+nmu1
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 
174 bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
175 
176 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
177  bool const &SortList, bool const &AllowNoExt=false);
178 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
179  bool const &SortList);
180 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
181 std::string SafeGetCWD();
182 void SetCloseExec(int Fd,bool Close);
183 void SetNonBlock(int Fd,bool Block);
184 bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
185 pid_t ExecFork();
186 pid_t ExecFork(std::set<int> keep_fds);
187 void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds);
188 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
189 
190 // File string manipulators
191 std::string flNotDir(std::string File);
192 std::string flNotFile(std::string File);
193 std::string flNoLink(std::string File);
194 std::string flExtension(std::string File);
195 std::string flCombine(std::string Dir,std::string File);
196 
197 // simple c++ glob
198 std::vector<std::string> Glob(std::string const &pattern, int flags=0);
199 
200 #endif
Definition: fileutl.h:41
Definition: fileutl.cc:65
Representation of supported compressors.
Definition: aptconfiguration.h:95