apt  0.9.7.7ubuntu3
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 
30 #include <zlib.h>
31 
32 #ifndef APT_8_CLEANER_HEADERS
33 using std::string;
34 #endif
35 
36 /* Define this for python-apt */
37 #define APT_HAS_GZIP 1
38 
39 class FileFdPrivate;
40 class FileFd
41 {
42  protected:
43  int iFd;
44 
45  enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
46  HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) };
47  unsigned long Flags;
48  std::string FileName;
49  std::string TemporaryFileName;
50 
51  public:
52  enum OpenMode {
53  ReadOnly = (1 << 0),
54  WriteOnly = (1 << 1),
55  ReadWrite = ReadOnly | WriteOnly,
56 
57  Create = (1 << 2),
58  Exclusive = (1 << 3),
59  Atomic = Exclusive | (1 << 4),
60  Empty = (1 << 5),
61 
62  WriteEmpty = ReadWrite | Create | Empty,
63  WriteExists = ReadWrite,
64  WriteAny = ReadWrite | Create,
65  WriteTemp = ReadWrite | Create | Exclusive,
66  ReadOnlyGzip,
67  WriteAtomic = ReadWrite | Create | Atomic
68  };
69  enum CompressMode { Auto = 'A', None = 'N', Extension = 'E', Gzip = 'G', Bzip2 = 'B', Lzma = 'L', Xz = 'X' };
70 
71  inline bool Read(void *To,unsigned long long Size,bool AllowEof)
72  {
73  unsigned long long Jnk;
74  if (AllowEof)
75  return Read(To,Size,&Jnk);
76  return Read(To,Size);
77  }
78  bool Read(void *To,unsigned long long Size,unsigned long long *Actual = 0);
79  char* ReadLine(char *To, unsigned long long const Size);
80  bool Write(const void *From,unsigned long long Size);
81  bool static Write(int Fd, const void *From, unsigned long long Size);
82  bool Seek(unsigned long long To);
83  bool Skip(unsigned long long To);
84  bool Truncate(unsigned long long To);
85  unsigned long long Tell();
86  unsigned long long Size();
87  unsigned long long FileSize();
88  time_t ModificationTime();
89 
90  /* You want to use 'unsigned long long' if you are talking about a file
91  to be able to support large files (>2 or >4 GB) properly.
92  This shouldn't happen all to often for the indexes, but deb's might be…
93  And as the auto-conversation converts a 'unsigned long *' to a 'bool'
94  instead of 'unsigned long long *' we need to provide this explicitely -
95  otherwise applications magically start to fail… */
96  __deprecated bool Read(void *To,unsigned long long Size,unsigned long *Actual)
97  {
98  unsigned long long R;
99  bool const T = Read(To, Size, &R);
100  *Actual = R;
101  return T;
102  }
103 
104  bool Open(std::string FileName,unsigned int const Mode,CompressMode Compress,unsigned long const Perms = 0666);
105  bool Open(std::string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor,unsigned long const Perms = 0666);
106  inline bool Open(std::string const &FileName,unsigned int const Mode, unsigned long const Perms = 0666) {
107  return Open(FileName, Mode, None, Perms);
108  };
109  bool OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose=false);
110  bool OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose=false);
111  inline bool OpenDescriptor(int Fd, unsigned int const Mode, bool AutoClose=false) {
112  return OpenDescriptor(Fd, Mode, None, AutoClose);
113  };
114  bool Close();
115  bool Sync();
116 
117  // Simple manipulators
118  inline int Fd() {return iFd;};
119  inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);};
120  __deprecated gzFile gzFd();
121 
122  inline bool IsOpen() {return iFd >= 0;};
123  inline bool Failed() {return (Flags & Fail) == Fail;};
124  inline void EraseOnFailure() {Flags |= DelOnFail;};
125  inline void OpFail() {Flags |= Fail;};
126  inline bool Eof() {return (Flags & HitEof) == HitEof;};
127  inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
128  inline std::string &Name() {return FileName;};
129 
130  FileFd(std::string FileName,unsigned int const Mode,unsigned long Perms = 0666) : iFd(-1), Flags(0), d(NULL)
131  {
132  Open(FileName,Mode, None, Perms);
133  };
134  FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long Perms = 0666) : iFd(-1), Flags(0), d(NULL)
135  {
136  Open(FileName,Mode, Compress, Perms);
137  };
138  FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {};
139  FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL)
140  {
141  OpenDescriptor(Fd, Mode, Compress);
142  };
143  FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
144  {
145  OpenDescriptor(Fd, ReadWrite, None, AutoClose);
146  };
147  virtual ~FileFd();
148 
149  private:
150  FileFdPrivate* d;
151  bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor);
152 };
153 
154 bool RunScripts(const char *Cnf);
155 bool CopyFile(FileFd &From,FileFd &To);
156 int GetLock(std::string File,bool Errors = true);
157 bool FileExists(std::string File);
158 bool RealFileExists(std::string File);
159 bool DirectoryExists(std::string const &Path) __attrib_const;
160 bool CreateDirectory(std::string const &Parent, std::string const &Path);
161 time_t GetModificationTime(std::string const &Path);
162 
169 bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
170 
171 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
172  bool const &SortList, bool const &AllowNoExt=false);
173 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
174  bool const &SortList);
175 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
176 std::string SafeGetCWD();
177 void SetCloseExec(int Fd,bool Close);
178 void SetNonBlock(int Fd,bool Block);
179 bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
180 pid_t ExecFork();
181 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
182 
183 // check if the given file starts with a PGP cleartext signature
184 bool StartsWithGPGClearTextSignature(std::string const &FileName);
185 
186 // File string manipulators
187 std::string flNotDir(std::string File);
188 std::string flNotFile(std::string File);
189 std::string flNoLink(std::string File);
190 std::string flExtension(std::string File);
191 std::string flCombine(std::string Dir,std::string File);
192 
193 
194 
195 #endif