PathInfo.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PATHINFO_H
#define ZYPP_PATHINFO_H
 
extern "C"
{
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
}
 
#include <cerrno>
#include <iosfwd>
#include <list>
#include <set>
#include <map>
 
#include <zypp/Pathname.h>
#include <zypp/CheckSum.h>
#include <zypp/ByteCount.h>
 
namespace zypp
{ 
 
  class StrMatcher;
 
 
  namespace filesystem
  { 
 
 
    enum FileType
      {
        FT_NOT_AVAIL = 0x00, // no typeinfo available
        FT_NOT_EXIST = 0x01, // file does not exist
        FT_FILE      = 0x02,
        FT_DIR       = 0x04,
        FT_CHARDEV   = 0x08,
        FT_BLOCKDEV  = 0x10,
        FT_FIFO      = 0x20,
        FT_LINK      = 0x40,
        FT_SOCKET    = 0x80
      };
 
    extern std::ostream & operator<<( std::ostream & str, FileType obj );
 
 
    //
    //  CLASS NAME : StatMode
    class StatMode
    {
      friend std::ostream & operator<<( std::ostream & str, const StatMode & obj );
 
    public:
      StatMode( const mode_t & mode_r = 0 )
      : _mode( mode_r )
      {}
 
    public:
 
      FileType fileType() const;
 
      bool   isFile()  const { return S_ISREG( _mode ); }
      bool   isDir ()  const { return S_ISDIR( _mode ); }
      bool   isLink()  const { return S_ISLNK( _mode ); }
      bool   isChr()   const { return S_ISCHR( _mode ); }
      bool   isBlk()   const { return S_ISBLK( _mode ); }
      bool   isFifo()  const { return S_ISFIFO( _mode ); }
      bool   isSock()  const { return S_ISSOCK( _mode ); }
 
      bool   isRUsr()  const { return (_mode & S_IRUSR); }
      bool   isWUsr()  const { return (_mode & S_IWUSR); }
      bool   isXUsr()  const { return (_mode & S_IXUSR); }
 
      bool   isR()     const { return isRUsr(); }
      bool   isW()     const { return isWUsr(); }
      bool   isX()     const { return isXUsr(); }
 
      bool   isRGrp()  const { return (_mode & S_IRGRP); }
      bool   isWGrp()  const { return (_mode & S_IWGRP); }
      bool   isXGrp()  const { return (_mode & S_IXGRP); }
 
      bool   isROth()  const { return (_mode & S_IROTH); }
      bool   isWOth()  const { return (_mode & S_IWOTH); }
      bool   isXOth()  const { return (_mode & S_IXOTH); }
 
      bool   isUid()   const { return (_mode & S_ISUID); }
      bool   isGid()   const { return (_mode & S_ISGID); }
      bool   isVtx()   const { return (_mode & S_ISVTX); }
 
      bool   isPerm ( mode_t m ) const { return (m == perm()); }
      bool   hasPerm( mode_t m ) const { return (m == (m & perm())); }
 
      mode_t uperm()   const { return (_mode & S_IRWXU); }
      mode_t gperm()   const { return (_mode & S_IRWXG); }
      mode_t operm()   const { return (_mode & S_IRWXO); }
      mode_t perm()    const { return (_mode & (S_IRWXU|S_IRWXG|S_IRWXO|S_ISUID|S_ISGID|S_ISVTX)); }
 
      mode_t st_mode() const { return _mode; }
 
    private:
      mode_t _mode;
    };
 
    extern std::ostream & operator<<( std::ostream & str, const StatMode & obj );
 
 
    //
    //  CLASS NAME : DevInoCache
    class DevInoCache
    {
    public:
      DevInoCache() {}
 
      void clear() { _devino.clear(); }
 
      bool insert( const dev_t & dev_r, const ino_t & ino_r ) {
        return _devino[dev_r].insert( ino_r ).second;
      }
 
    private:
      std::map<dev_t,std::set<ino_t> > _devino;
    };
 
    //
    //  CLASS NAME : PathInfo
    class PathInfo
    {
      friend std::ostream & operator<<( std::ostream & str, const PathInfo & obj );
 
    public:
      enum Mode { STAT, LSTAT };
 
    public:
      PathInfo();
      explicit
      PathInfo( const Pathname & path, Mode initial = STAT );
      explicit
      PathInfo( const std::string & path, Mode initial = STAT );
      explicit
      PathInfo( const char * path, Mode initial = STAT );
 
      ~PathInfo();
 
      const Pathname &    path()     const { return path_t; }
      const std::string & asString() const { return path_t.asString(); }
      const char * c_str()           const { return path_t.asString().c_str(); }
      Mode                mode()     const { return mode_e; }
      int                 error()    const { return error_i; }
 
      void setPath( const Pathname & path ) { if ( path != path_t ) error_i = -1; path_t = path; }
      void setMode( Mode mode )             { if ( mode != mode_e ) error_i = -1; mode_e = mode; }
 
      bool stat      ( const Pathname & path ) { setPath( path ); setMode( STAT );  return operator()(); }
      bool lstat     ( const Pathname & path ) { setPath( path ); setMode( LSTAT ); return operator()(); }
      bool operator()( const Pathname & path ) { setPath( path ); return operator()(); }
 
      bool stat()   { setMode( STAT );  return operator()(); }
      bool lstat()  { setMode( LSTAT ); return operator()(); }
      bool operator()();
 
    public:
 
      bool   isExist() const { return !error_i; }
 
      FileType fileType() const;
 
      bool   isFile()  const { return isExist() && S_ISREG( statbuf_C.st_mode ); }
      bool   isDir ()  const { return isExist() && S_ISDIR( statbuf_C.st_mode ); }
      bool   isLink()  const { return isExist() && S_ISLNK( statbuf_C.st_mode ); }
      bool   isChr()   const { return isExist() && S_ISCHR( statbuf_C.st_mode ); }
      bool   isBlk()   const { return isExist() && S_ISBLK( statbuf_C.st_mode ); }
      bool   isFifo()  const { return isExist() && S_ISFIFO( statbuf_C.st_mode ); }
      bool   isSock()  const { return isExist() && S_ISSOCK( statbuf_C.st_mode ); }
 
      // permission
      bool   isRUsr()  const { return isExist() && (statbuf_C.st_mode & S_IRUSR); }
      bool   isWUsr()  const { return isExist() && (statbuf_C.st_mode & S_IWUSR); }
      bool   isXUsr()  const { return isExist() && (statbuf_C.st_mode & S_IXUSR); }
 
      bool   isR()     const { return isRUsr(); }
      bool   isW()     const { return isWUsr(); }
      bool   isX()     const { return isXUsr(); }
 
      bool   isRGrp()  const { return isExist() && (statbuf_C.st_mode & S_IRGRP); }
      bool   isWGrp()  const { return isExist() && (statbuf_C.st_mode & S_IWGRP); }
      bool   isXGrp()  const { return isExist() && (statbuf_C.st_mode & S_IXGRP); }
 
      bool   isROth()  const { return isExist() && (statbuf_C.st_mode & S_IROTH); }
      bool   isWOth()  const { return isExist() && (statbuf_C.st_mode & S_IWOTH); }
      bool   isXOth()  const { return isExist() && (statbuf_C.st_mode & S_IXOTH); }
 
      bool   isUid()   const { return isExist() && (statbuf_C.st_mode & S_ISUID); }
      bool   isGid()   const { return isExist() && (statbuf_C.st_mode & S_ISGID); }
      bool   isVtx()   const { return isExist() && (statbuf_C.st_mode & S_ISVTX); }
 
      bool   isPerm ( mode_t m ) const { return isExist() && (m == perm()); }
      bool   hasPerm( mode_t m ) const { return isExist() && (m == (m & perm())); }
 
      mode_t uperm()   const { return isExist() ? (statbuf_C.st_mode & S_IRWXU) : 0; }
      mode_t gperm()   const { return isExist() ? (statbuf_C.st_mode & S_IRWXG) : 0; }
      mode_t operm()   const { return isExist() ? (statbuf_C.st_mode & S_IRWXO) : 0; }
      mode_t perm()    const { return isExist() ? (statbuf_C.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO|S_ISUID|S_ISGID|S_ISVTX)) : 0; }
 
      mode_t st_mode() const { return isExist() ? statbuf_C.st_mode : 0; }
 
      StatMode asStatMode() const { return st_mode(); }
 
      nlink_t nlink()  const { return isExist() ? statbuf_C.st_nlink : 0; }
 
      uid_t  owner()   const { return isExist() ? statbuf_C.st_uid : 0; }
      gid_t  group()   const { return isExist() ? statbuf_C.st_gid : 0; }
 
      mode_t userMay() const;
 
      bool   userMayR() const { return( userMay() & 04 ); }
      bool   userMayW() const { return( userMay() & 02 ); }
      bool   userMayX() const { return( userMay() & 01 ); }
 
      bool   userMayRW()  const { return( (userMay() & 06) == 06 ); }
      bool   userMayRX()  const { return( (userMay() & 05) == 05 ); }
      bool   userMayWX()  const { return( (userMay() & 03) == 03 ); }
 
      bool   userMayRWX() const { return( userMay() == 07 ); }
 
      ino_t  ino()     const { return isExist() ? statbuf_C.st_ino  : 0; }
      dev_t  dev()     const { return isExist() ? statbuf_C.st_dev  : 0; }
      dev_t  rdev()    const { return isExist() ? statbuf_C.st_rdev : 0; }
 
      unsigned int devMajor() const;
      unsigned int devMinor() const;
 
      off_t         size()    const { return isExist() ? statbuf_C.st_size : 0; }
      unsigned long blksize() const { return isExist() ? statbuf_C.st_blksize : 0; }
      unsigned long blocks()  const { return isExist() ? statbuf_C.st_blocks  : 0; }
 
      time_t atime()   const { return isExist() ? statbuf_C.st_atime : 0; } /* time of last access */
      time_t mtime()   const { return isExist() ? statbuf_C.st_mtime : 0; } /* time of last modification */
      time_t ctime()   const { return isExist() ? statbuf_C.st_ctime : 0; }
 
    private:
      Pathname    path_t;
      struct stat statbuf_C;
      Mode        mode_e;
      int         error_i;
    };
 
    extern std::ostream & operator<<( std::ostream & str, const PathInfo & obj );
 
 
 
    int mkdir( const Pathname & path, unsigned mode = 0755 );
 
    int assert_dir( const Pathname & path, unsigned mode = 0755 );
 
    int rmdir( const Pathname & path );
 
    int recursive_rmdir( const Pathname & path );
 
    int clean_dir( const Pathname & path );
 
    int copy_dir( const Pathname & srcpath, const Pathname & destpath );
 
    int copy_dir_content( const Pathname & srcpath, const Pathname & destpath);
 
    const StrMatcher & matchNoDots();
 
    int dirForEach( const Pathname & dir_r, function<bool(const Pathname &, const char *const)> fnc_r );
 
    int dirForEach( const Pathname & dir_r, const StrMatcher & matcher_r, function<bool(const Pathname &, const char *const)> fnc_r );
 
    int readdir( std::list<std::string> & retlist,
                 const Pathname & path, bool dots = true );
 
    int readdir( std::list<Pathname> & retlist,
                 const Pathname & path, bool dots = true );
 
    struct DirEntry {
      std::string name;
      FileType    type;
      DirEntry( const std::string & name_r = std::string(), FileType type_r = FT_NOT_AVAIL )
      : name( name_r )
      , type( type_r )
      {}
 
      bool operator==( const DirEntry &rhs ) const;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const DirEntry & obj )
    { return str << '[' << obj.type << "] " << obj.name; }
 
    typedef std::list<DirEntry> DirContent;
 
    std::ostream & operator<<( std::ostream & str, const DirContent & obj );
 
    int readdir( DirContent & retlist, const Pathname & path,
                 bool dots = true, PathInfo::Mode statmode = PathInfo::STAT );
 
    int is_empty_dir(const Pathname & path);
 
 
 
    int assert_file( const Pathname & path, unsigned mode = 0644 );
    int assert_file_mode( const Pathname & path, unsigned mode = 0644 );
 
    int touch (const Pathname & path);
 
    int unlink( const Pathname & path );
 
    int rename( const Pathname & oldpath, const Pathname & newpath );
 
    int exchange( const Pathname & lpath, const Pathname & rpath );
 
    int copy( const Pathname & file, const Pathname & dest );
 
    int symlink( const Pathname & oldpath, const Pathname & newpath );
 
    int hardlink( const Pathname & oldpath, const Pathname & newpath );
 
    int hardlinkCopy( const Pathname & oldpath, const Pathname & newpath );
 
    int readlink( const Pathname & symlink_r, Pathname & target_r );
    inline Pathname readlink( const Pathname & symlink_r )
    {
      Pathname target;
      readlink( symlink_r, target );
      return target;
    }
 
    Pathname expandlink( const Pathname & path_r );
 
    int copy_file2dir( const Pathname & file, const Pathname & dest );
 
 
    std::string md5sum( const Pathname & file );
 
    std::string sha1sum( const Pathname & file );
 
    std::string checksum( const Pathname & file, const std::string &algorithm );
 
    bool is_checksum( const Pathname & file, const CheckSum &checksum );
 
 
    int chmod( const Pathname & path, mode_t mode );
 
    int addmod( const Pathname & path, mode_t mode );
 
    int delmod( const Pathname & path, mode_t mode );
 
 
    enum ZIP_TYPE { ZT_NONE, ZT_GZ, ZT_BZ2, ZT_ZCHNK };
 
    ZIP_TYPE zipType( const Pathname & file );
 
    int erase( const Pathname & path );
 
    ByteCount df( const Pathname & path );
 
    mode_t getUmask();
 
    inline mode_t applyUmaskTo( mode_t mode_r )
    { return mode_r & ~getUmask(); }
 
  } // namespace filesystem
 
  using filesystem::PathInfo;
 
} // namespace zypp
#endif // ZYPP_PATHINFO_H