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 FileFdPrivate;
  35 class FileFd
  36 {
  37    protected:
  38    int iFd;
  39
  40    enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
  41                     HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) };
  42    unsigned long Flags;
  43    std::string FileName;
  44    std::string TemporaryFileName;
  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    char* ReadLine(char *To, unsigned long long const Size);
  75    bool Write(const void *From,unsigned long long Size);
  76    bool Seek(unsigned long long To);
  77    bool Skip(unsigned long long To);
  78    bool Truncate(unsigned long long To);
  79    unsigned long long Tell();
  80    unsigned long long Size();
  81    unsigned long long FileSize();
  82    time_t ModificationTime();
  83
  84    /* You want to use 'unsigned long long' if you are talking about a file
  85       to be able to support large files (>2 or >4 GB) properly.
  86       This shouldn't happen all to often for the indexes, but deb's might be…
  87       And as the auto-conversation converts a 'unsigned long *' to a 'bool'
  88       instead of 'unsigned long long *' we need to provide this explicitely -
  89       otherwise applications magically start to fail… */
  90    __deprecated bool Read(void *To,unsigned long long Size,unsigned long *Actual)
  91    {
  92         unsigned long long R;
  93         bool const T = Read(To, Size, &R);
  94         *Actual = R;
  95         return T;
  96    }
  97
  98    bool Open(std::string FileName,OpenMode Mode,CompressMode Compress,unsigned long const Perms = 0666);
  99    inline bool Open(std::string const &FileName,OpenMode Mode, unsigned long const Perms = 0666) {
 100       return Open(FileName, Mode, None, Perms);
 101    };
 102    bool OpenDescriptor(int Fd, OpenMode Mode, CompressMode Compress, bool AutoClose=false);
 103    inline bool OpenDescriptor(int Fd, OpenMode Mode, bool AutoClose=false) {
 104       return OpenDescriptor(Fd, Mode, None, AutoClose);
 105    };
 106    bool Close();
 107    bool Sync();
 108
 109    // Simple manipulators
 110    inline int Fd() {return iFd;};
 111    inline void Fd(int fd) {iFd = fd;};
 112    __deprecated gzFile gzFd();
 113    inline bool IsOpen() {return iFd >= 0;};
 114    inline bool Failed() {return (Flags & Fail) == Fail;};
 115    inline void EraseOnFailure() {Flags |= DelOnFail;};
 116    inline void OpFail() {Flags |= Fail;};
 117    inline bool Eof() {return (Flags & HitEof) == HitEof;};
 118    inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
 119    inline std::string &Name() {return FileName;};
 120
 121    FileFd(std::string FileName,OpenMode Mode,unsigned long Perms = 0666) : iFd(-1), Flags(0), d(NULL)
 122    {
 123       Open(FileName,Mode, None, Perms);
 124    };
 125    FileFd(std::string FileName,OpenMode Mode, CompressMode Compress, unsigned long Perms = 0666) : iFd(-1), Flags(0), d(NULL)
 126    {
 127       Open(FileName,Mode, Compress, Perms);
 128    };
 129    FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {};
 130    FileFd(int const Fd, OpenMode Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL)
 131    {
 132       OpenDescriptor(Fd, Mode, Compress);
 133    };
 134    FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
 135    {
 136       OpenDescriptor(Fd, ReadWrite, None, AutoClose);
 137    };
 138    virtual ~FileFd();
 139
 140    private:
 141    FileFdPrivate* d;
 142    bool OpenInternDescriptor(OpenMode Mode, CompressMode Compress);
 143 };
 144
 145 bool RunScripts(const char *Cnf);
 146 bool CopyFile(FileFd &From,FileFd &To);
 147 int GetLock(std::string File,bool Errors = true);
 148 bool FileExists(std::string File);
 149 bool RealFileExists(std::string File);
 150 bool DirectoryExists(std::string const &Path) __attrib_const;
 151 bool CreateDirectory(std::string const &Parent, std::string const &Path);
 152 time_t GetModificationTime(std::string const &Path);
 153
 154 /** \brief Ensure the existence of the given Path
 155  *
 156  *  \param Parent directory of the Path directory - a trailing
 157  *  /apt/ will be removed before CreateDirectory call.
 158  *  \param Path which should exist after (successful) call
 159  */
 160 bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
 161
 162 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
 163                                         bool const &SortList, bool const &AllowNoExt=false);
 164 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
 165                                         bool const &SortList);
 166 std::string SafeGetCWD();
 167 void SetCloseExec(int Fd,bool Close);
 168 void SetNonBlock(int Fd,bool Block);
 169 bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
 170 pid_t ExecFork();
 171 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
 172
 173 // File string manipulators
 174 std::string flNotDir(std::string File);
 175 std::string flNotFile(std::string File);
 176 std::string flNoLink(std::string File);
 177 std::string flExtension(std::string File);
 178 std::string flCombine(std::string Dir,std::string File);
 179
 180 #endif