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    friend class FileFdPrivate;
  45    friend class GzipFileFdPrivate;
  46    friend class Bz2FileFdPrivate;
  47    friend class LzmaFileFdPrivate;
  48    friend class Lz4FileFdPrivate;
  49    friend class DirectFileFdPrivate;
  50    friend class PipedFileFdPrivate;
  51    protected:
  52    int iFd;
  53
  54    enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
  55                     HitEof = (1<<3), Replace = (1<<4), Compressed = (1<<5) };
  56    unsigned long Flags;
  57    std::string FileName;
  58    std::string TemporaryFileName;
  59
  60    public:
  61    enum OpenMode {
  62         ReadOnly = (1 << 0),
  63         WriteOnly = (1 << 1),
  64         ReadWrite = ReadOnly | WriteOnly,
  65
  66         Create = (1 << 2),
  67         Exclusive = (1 << 3),
  68         Atomic = Exclusive | (1 << 4),
  69         Empty = (1 << 5),
  70         BufferedWrite = (1 << 6),
  71
  72         WriteEmpty = ReadWrite | Create | Empty,
  73         WriteExists = ReadWrite,
  74         WriteAny = ReadWrite | Create,
  75         WriteTemp = ReadWrite | Create | Exclusive,
  76         ReadOnlyGzip,
  77         WriteAtomic = ReadWrite | Create | Atomic
  78    };
  79    enum CompressMode { Auto = 'A', None = 'N', Extension = 'E', Gzip = 'G', Bzip2 = 'B', Lzma = 'L', Xz = 'X', Lz4='4' };
  80
  81    inline bool Read(void *To,unsigned long long Size,bool AllowEof)
  82    {
  83       unsigned long long Jnk;
  84       if (AllowEof)
  85          return Read(To,Size,&Jnk);
  86       return Read(To,Size);
  87    }
  88    bool Read(void *To,unsigned long long Size,unsigned long long *Actual = 0);
  89    bool static Read(int const Fd, void *To, unsigned long long Size, unsigned long long * const Actual = 0);
  90    char* ReadLine(char *To, unsigned long long const Size);
  91    bool Flush();
  92    bool Write(const void *From,unsigned long long Size);
  93    bool static Write(int Fd, const void *From, unsigned long long Size);
  94    bool Seek(unsigned long long To);
  95    bool Skip(unsigned long long To);
  96    bool Truncate(unsigned long long To);
  97    unsigned long long Tell();
  98    // the size of the file content (compressed files will be uncompressed first)
  99    unsigned long long Size();
 100    // the size of the file itself
 101    unsigned long long FileSize();
 102    time_t ModificationTime();
 103
 104    /* You want to use 'unsigned long long' if you are talking about a file
 105       to be able to support large files (>2 or >4 GB) properly.
 106       This shouldn't happen all to often for the indexes, but deb's might be…
 107       And as the auto-conversation converts a 'unsigned long *' to a 'bool'
 108       instead of 'unsigned long long *' we need to provide this explicitly -
 109       otherwise applications magically start to fail… */
 110    bool Read(void *To,unsigned long long Size,unsigned long *Actual) APT_DEPRECATED_MSG("The Actual variable you pass in should be an unsigned long long")
 111    {
 112         unsigned long long R;
 113         bool const T = Read(To, Size, &R);
 114         *Actual = R;
 115         return T;
 116    }
 117
 118    bool Open(std::string FileName,unsigned int const Mode,CompressMode Compress,unsigned long const AccessMode = 0666);
 119    bool Open(std::string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor,unsigned long const AccessMode = 0666);
 120    inline bool Open(std::string const &FileName,unsigned int const Mode, unsigned long const AccessMode = 0666) {
 121       return Open(FileName, Mode, None, AccessMode);
 122    };
 123    bool OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose=false);
 124    bool OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose=false);
 125    inline bool OpenDescriptor(int Fd, unsigned int const Mode, bool AutoClose=false) {
 126       return OpenDescriptor(Fd, Mode, None, AutoClose);
 127    };
 128    bool Close();
 129    bool Sync();
 130
 131    // Simple manipulators
 132    inline int Fd() {return iFd;};
 133    inline void Fd(int fd) { OpenDescriptor(fd, ReadWrite);};
 134    gzFile gzFd() APT_DEPRECATED_MSG("Implementation detail, do not use to be able to support bzip2, xz and co") APT_PURE;
 135
 136    inline bool IsOpen() {return iFd >= 0;};
 137    inline bool Failed() {return (Flags & Fail) == Fail;};
 138    inline void EraseOnFailure() {Flags |= DelOnFail;};
 139    inline void OpFail() {Flags |= Fail;};
 140    inline bool Eof() {return (Flags & HitEof) == HitEof;};
 141    inline bool IsCompressed() {return (Flags & Compressed) == Compressed;};
 142    inline std::string &Name() {return FileName;};
 143
 144    FileFd(std::string FileName,unsigned int const Mode,unsigned long AccessMode = 0666);
 145    FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long AccessMode = 0666);
 146    FileFd();
 147    FileFd(int const Fd, unsigned int const Mode = ReadWrite, CompressMode Compress = None);
 148    FileFd(int const Fd, bool const AutoClose);
 149    virtual ~FileFd();
 150
 151    private:
 152    FileFdPrivate * d;
 153    APT_HIDDEN FileFd & operator=(const FileFd &);
 154    APT_HIDDEN bool OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor);
 155
 156    // private helpers to set Fail flag and call _error->Error
 157    APT_HIDDEN bool FileFdErrno(const char* Function, const char* Description,...) APT_PRINTF(3) APT_COLD;
 158    APT_HIDDEN bool FileFdError(const char* Description,...) APT_PRINTF(2) APT_COLD;
 159 };
 160
 161 bool RunScripts(const char *Cnf);
 162 bool CopyFile(FileFd &From,FileFd &To);
 163 bool RemoveFile(char const * const Function, std::string const &FileName);
 164 int GetLock(std::string File,bool Errors = true);
 165 bool FileExists(std::string File);
 166 bool RealFileExists(std::string File);
 167 bool DirectoryExists(std::string const &Path);
 168 bool CreateDirectory(std::string const &Parent, std::string const &Path);
 169 time_t GetModificationTime(std::string const &Path);
 170 bool Rename(std::string From, std::string To);
 171
 172 std::string GetTempDir();
 173 std::string GetTempDir(std::string const &User);
 174 FileFd* GetTempFile(std::string const &Prefix = "",
 175                     bool ImmediateUnlink = true,
 176                     FileFd * const TmpFd = NULL);
 177
 178 /** \brief Ensure the existence of the given Path
 179  *
 180  *  \param Parent directory of the Path directory - a trailing
 181  *  /apt/ will be removed before CreateDirectory call.
 182  *  \param Path which should exist after (successful) call
 183  */
 184 bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
 185
 186 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
 187                                         bool const &SortList, bool const &AllowNoExt=false);
 188 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
 189                                         bool const &SortList);
 190 std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, bool SortList);
 191 std::string SafeGetCWD();
 192 void SetCloseExec(int Fd,bool Close);
 193 void SetNonBlock(int Fd,bool Block);
 194 bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
 195 pid_t ExecFork();
 196 pid_t ExecFork(std::set<int> keep_fds);
 197 void MergeKeepFdsFromConfiguration(std::set<int> &keep_fds);
 198 bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
 199
 200 // check if the given file starts with a PGP cleartext signature
 201 bool StartsWithGPGClearTextSignature(std::string const &FileName);
 202
 203 /** change file attributes to requested known good values
 204  *
 205  * The method skips the user:group setting if not root.
 206  *
 207  * @param requester is printed as functionname in error cases
 208  * @param file is the file to be modified
 209  * @param user is the (new) owner of the file, e.g. _apt
 210  * @param group is the (new) group owning the file, e.g. root
 211  * @param mode is the access mode of the file, e.g. 0644
 212  */
 213 bool ChangeOwnerAndPermissionOfFile(char const * const requester, char const * const file, char const * const user, char const * const group, mode_t const mode);
 214
 215 /**
 216  * \brief Drop privileges
 217  *
 218  * Drop the privileges to the user _apt (or the one specified in
 219  * APT::Sandbox::User). This does not set the supplementary group
 220  * ids up correctly, it only uses the default group. Also prevent
 221  * the process from gaining any new privileges afterwards, at least
 222  * on Linux.
 223  *
 224  * \return true on success, false on failure with _error set
 225  */
 226 bool DropPrivileges();
 227
 228 // File string manipulators
 229 std::string flNotDir(std::string File);
 230 std::string flNotFile(std::string File);
 231 std::string flNoLink(std::string File);
 232 std::string flExtension(std::string File);
 233 std::string flCombine(std::string Dir,std::string File);
 234
 235 /** \brief Takes a file path and returns the absolute path
 236  */
 237 std::string flAbsPath(std::string File);
 238 /** \brief removes superfluous /./ and // from path */
 239 APT_HIDDEN std::string flNormalize(std::string file);
 240
 241 // simple c++ glob
 242 std::vector<std::string> Glob(std::string const &pattern, int flags=0);
 243
 244 /** \brief Popen() implementation that execv() instead of using a shell
 245  *
 246  * \param Args the execv style command to run
 247  * \param FileFd is a referenz to the FileFd to use for input or output
 248  * \param Child a reference to the integer that stores the child pid
 249  *        Note that you must call ExecWait() or similar to cleanup
 250  * \param Mode is either FileFd::ReadOnly or FileFd::WriteOnly
 251  * \param CaptureStderr True if we should capture stderr in addition to stdout.
 252  *                      (default: True).
 253  * \return true on success, false on failure with _error set
 254  */
 255 bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode, bool CaptureStderr);
 256 bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode);
 257
 258
 259 #endif