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 #include <set>
  30 #include <time.h>
  31
  32 #include <zlib.h>
  33
  34 #ifndef APT_8_CLEANER_HEADERS
  35 using std::string;
  36 #endif
  37
  38 /* Define this for python-apt */
  39 #define APT_HAS_GZIP 1
  40
  41 class FileFdPrivate;
  42 class FileFd
  43 {
  44    protected:
  45    int iFd;
  46
  47    enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
  48                     HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) };
  49    unsigned long Flags;
  50    std::string FileName;
  51    std::string TemporaryFileName;
  52
  53    public:
  54    enum OpenMode {
  55         ReadOnly = (1 << 0),
  56         WriteOnly = (1 << 1),
  57         ReadWrite = ReadOnly | WriteOnly,
  58
  59         Create = (1 << 2),
  60         Exclusive = (1 << 3),
  61         Atomic = Exclusive | (1 << 4),
  62         Empty = (1 << 5),
  63
  64         WriteEmpty = ReadWrite | Create | Empty,
  65         WriteExists = ReadWrite,
  66         WriteAny = ReadWrite | Create,
  67         WriteTemp = ReadWrite | Create | Exclusive,
  68         ReadOnlyGzip,
  69         WriteAtomic = ReadWrite | Create | Atomic
  70    };
  71    enum CompressMode { Auto = 'A', None = 'N', Extension = 'E', Gzip = 'G', Bzip2 = 'B', Lzma = 'L', Xz = 'X' };
  72
  73    inline bool Read(void *To,unsigned long long Size,bool AllowEof)
  74    {
  75       unsigned long long Jnk;
  76       if (AllowEof)
  77          return Read(To,Size,&Jnk);
  78       return Read(To,Size);
  79    }
  80    bool Read(void *To,unsigned long long Size,unsigned long long *Actual = 0);
  81    char* ReadLine(char *To, unsigned long long const Size);
  82    bool Write(const void *From,unsigned long long Size);
  83    bool static Write(int Fd, const void *From, unsigned long long Size);
  84    bool Seek(unsigned long long To);
  85    bool Skip(unsigned long long To);
  86    bool Truncate(unsigned long long To);
  87    unsigned long long Tell();
  88    unsigned long long Size();
  89    unsigned long long FileSize();
  90    time_t ModificationTime();
  91
  92    /* You want to use 'unsigned long long' if you are talking about a file
  93       to be able to support large files (>2 or >4 GB) properly.
  94       This shouldn't happen all to often for the indexes, but deb's might be…
  95       And as the auto-conversation converts a 'unsigned long *' to a 'bool'
  96       instead of 'unsigned long long *' we need to provide this explicitely -
  97       otherwise applications magically start to fail… */
  98    bool Read(void *To,unsigned long long Size,unsigned long *Actual) APT_DEPRECATED
  99    {
 100         unsigned long long R;
 101         bool const T = Read(To, Size, &R);
 102         *Actual = R;
 103         return T;
 104    }
 105
 106    bool Open(std::string FileName,unsigned int const Mode,CompressMode Compress,unsigned long const AccessMode = 0666);
 107    bool Open(std::string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor,unsigned long const AccessMode = 0666);
 108    inline bool Open(std::string const &FileName,unsigned int const Mode, unsigned long const AccessMode = 0666) {
 109       return Open(FileName, Mode, None, AccessMode);
 110    };
 111    bool OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose=false);
 112    bool OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose=false);
 113    inline bool OpenDescriptor(int Fd, unsigned int const Mode, bool AutoClose=false) {
 114       return OpenDescriptor(Fd, Mode, None, AutoClose);
 115    };
 116    bool Close();
 117    bool Sync();
 118
 119    // Simple manipulators
 120    inline int Fd() {return iFd;};
 121    inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);};
 122    gzFile gzFd() APT_DEPRECATED APT_PURE;
 123
 124    inline bool IsOpen() {return iFd >= 0;};
 125    inline bool Failed() {return (Flags & Fail) == Fail;};
 126    inline void EraseOnFailure() {Flags |= DelOnFail;};
 127    inline void OpFail() {Flags |= Fail;};
 128    inline bool Eof() {return (Flags & HitEof) == HitEof;};
 129    inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
 130    inline std::string &Name() {return FileName;};
 131
 132    FileFd(std::string FileName,unsigned int const Mode,unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
 133    {
 134       Open(FileName,Mode, None, AccessMode);
 135    };
 136    FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long AccessMode = 0666) : iFd(-1), Flags(0), d(NULL)
 137    {
 138       Open(FileName,Mode, Compress, AccessMode);
 139    };
 140    FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {};
 141    FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None) : iFd(-1), Flags(0), d(NULL)
 142    {
 143       OpenDescriptor(Fd, Mode, Compress);
 144    };
 145    FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
 146    {
 147       OpenDescriptor(Fd, ReadWrite, None, AutoClose);
 148    };
 149    virtual ~FileFd();
 150
 151    private:
 152    FileFdPrivate* d;
 153    APT_HIDDEN bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor);
 154
 155    // private helpers to set Fail flag and call _error->Error
 156    APT_HIDDEN bool FileFdErrno(const char* Function, const char* Description,...) APT_PRINTF(3) APT_COLD;
 157    APT_HIDDEN bool FileFdError(const char* Description,...) APT_PRINTF(2) APT_COLD;
 158 };
 159
 160 bool RunScripts(const char *Cnf);
 161 bool CopyFile(FileFd &From,FileFd &To);
 162 int GetLock(std::string File,bool Errors = true);
 163 bool FileExists(std::string File);
 164 bool RealFileExists(std::string File);
 165 bool DirectoryExists(std::string const &Path) APT_CONST;
 166 bool CreateDirectory(std::string const &Parent, std::string const &Path);
 167 time_t GetModificationTime(std::string const &Path);
 168 bool Rename(std::string From, std::string To);
 169
 170 std::string GetTempDir();
 171 FileFd* GetTempFile(std::string const &Prefix = "",
 172                     bool ImmediateUnlink = true);
 173
 174 /** \brief Ensure the existence of the given Path
 175  *
 176  *  \param Parent directory of the Path directory - a trailing
 177  *  /apt/ will be removed before CreateDirectory call.
 178  *  \param Path which should exist after (successful) call
 179  */
 180 bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
 181
 182 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
 183                                         bool const &SortList, bool const &AllowNoExt=false);
 184 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
 185                                         bool const &SortList);
 186 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
 187 std::string SafeGetCWD();
 188 void SetCloseExec(int Fd,bool Close);
 189 void SetNonBlock(int Fd,bool Block);
 190 bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
 191 pid_t ExecFork();
 192 pid_t ExecFork(std::set<int> keep_fds);
 193 void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds);
 194 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
 195
 196
 197 // check if the given file starts with a PGP cleartext signature
 198 bool StartsWithGPGClearTextSignature(std::string const &FileName);
 199
 200 // process releated
 201 bool DropPrivs();
 202
 203 // File string manipulators
 204 std::string flNotDir(std::string File);
 205 std::string flNotFile(std::string File);
 206 std::string flNoLink(std::string File);
 207 std::string flExtension(std::string File);
 208 std::string flCombine(std::string Dir,std::string File);
 209
 210 /** \brief Takes a file path and returns the absolute path
 211  */
 212 std::string flAbsPath(std::string File);
 213
 214 // simple c++ glob
 215 std::vector<std::string> Glob(std::string const &pattern, int flags=0);
 216
 217 /** \brief Popen() implementation that execv() instead of using a shell
 218  *
 219  * \param Args the execv style command to run
 220  * \param FileFd is a referenz to the FileFd to use for input or output
 221  * \param Child a reference to the integer that stores the child pid
 222  *        Note that you must call ExecWait() or similar to cleanup
 223  * \param Mode is either FileFd::ReadOnly or FileFd::WriteOnly
 224  * \return true on success, false on failure with _error set
 225  */
 226 bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode);
 227
 228
 229 #endif