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