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