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