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 /** \brief Ensure the existence of the given Path
 169  *
 170  *  \param Parent directory of the Path directory - a trailing
 171  *  /apt/ will be removed before CreateDirectory call.
 172  *  \param Path which should exist after (successful) call
 173  */
 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 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
 188
 189 // File string manipulators
 190 std::string flNotDir(std::string File);
 191 std::string flNotFile(std::string File);
 192 std::string flNoLink(std::string File);
 193 std::string flExtension(std::string File);
 194 std::string flCombine(std::string Dir,std::string File);
 195
 196 // simple c++ glob
 197 std::vector<std::string> Glob(std::string const &pattern, int flags=0);
 198
 199 #endif