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