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
  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    // private helpers to set Fail flag and call _error->Error
 154    bool FileFdErrno(const char* Function, const char* Description,...) __like_printf(3) __cold;
 155    bool FileFdError(const char* Description,...) __like_printf(2) __cold;
 156 };
 157
 158 bool RunScripts(const char *Cnf);
 159 bool CopyFile(FileFd &From,FileFd &To);
 160 int GetLock(std::string File,bool Errors = true);
 161 bool FileExists(std::string File);
 162 bool RealFileExists(std::string File);
 163 bool DirectoryExists(std::string const &Path) __attrib_const;
 164 bool CreateDirectory(std::string const &Parent, std::string const &Path);
 165 time_t GetModificationTime(std::string const &Path);
 166
 167 /** \brief Ensure the existence of the given Path
 168  *
 169  *  \param Parent directory of the Path directory - a trailing
 170  *  /apt/ will be removed before CreateDirectory call.
 171  *  \param Path which should exist after (successful) call
 172  */
 173 bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
 174
 175 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
 176                                         bool const &SortList, bool const &AllowNoExt=false);
 177 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
 178                                         bool const &SortList);
 179 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
 180 std::string SafeGetCWD();
 181 void SetCloseExec(int Fd,bool Close);
 182 void SetNonBlock(int Fd,bool Block);
 183 bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
 184 pid_t ExecFork();
 185 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
 186
 187 // File string manipulators
 188 std::string flNotDir(std::string File);
 189 std::string flNotFile(std::string File);
 190 std::string flNoLink(std::string File);
 191 std::string flExtension(std::string File);
 192 std::string flCombine(std::string Dir,std::string File);
 193
 194 // simple c++ glob
 195 std::vector<std::string> Glob(std::string const &pattern, int flags=0);
 196
 197 #endif