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