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