1.11/html/fs_8h_source.html

 #ifndef __fs_h__

 #define __fs_h__


 #include <iostream>

 #include <string>

 #include <vector>


 #ifdef HAVE_SYS_TYPES_H

 #include <sys/types.h>

 #endif

 #ifdef HAVE_SYS_STAT_H

 #include <sys/stat.h>

 #endif

 #ifdef HAVE_UNISTD_H

 #include <unistd.h>

 #endif

 #include <pwd.h>

 #include <grp.h>

 #ifdef HAVE_SYS_PARAM_H

 #include <sys/param.h>

 #endif

 #ifdef HAVE_SYS_MOUNT_H

 #include <sys/mount.h>

 #endif

 #ifdef HAVE_SIGNAL_H

 #include <signal.h>

 #endif


 /*

  * *** NASTY KLUDGE ***

  *

  * _FILE_OFFSET_BITS == 64 is needed for a 64-bit off_t, but on sun-solaris2.8

  * it interferes with struct statvfs64, which needs _LARGE_FILES instead.

  * Surely there is a proper way to do this...

  *

  */

 #ifdef HAVE_SYS_STATVFS_H

 #       ifdef sun

 #               ifdef _FILE_OFFSET_BITS

 #                       if _FILE_OFFSET_BITS == 64

 #                               define __HOLD_FILE_OFFSET_BITS_64

 #                               undef _FILE_OFFSET_BITS

 #                       endif

 #               endif

 #       endif

 #include <sys/statvfs.h>

 #       ifdef __HOLD_FILE_OFFSET_BITS_64

 #               define _FILE_OFFSET_BITS 64

 #               undef __HOLD_FILE_OFFSET_BITS_64

 #       endif

 #endif


 #ifdef HAVE_SYS_VFS_H

 #include <sys/vfs.h>

 #endif


 #include "types.h"


 #ifdef HAVE_SYS_STATVFS_H

 #define STATFS statvfs

 #else

 #define STATFS statfs

 #endif


 #include <string.h>


 const std::string cwd(void);

 const pid_t pid(void);

 const pid_t parent_pid(void);


 bool absolute_path(const std::string& a_path);

 bool relative_path(const std::string& a_path);

 std::string reform_path(const std::string& a_path);

 std::string permute_path(const std::string& a_path);

 std::string path_basename(const std::string& a_path);

 std::string path_dirname(const std::string& a_path);

 std::string mk_absolute_path(

         const std::string a_path,

         const std::string a_rel_path

         );

 std::string mk_relative_path(

         const std::string a_path_to,

         const std::string a_path_from

         );

 bool exists(const std::string& a_path);

 bool readable(const std::string& a_path);

 bool writable(const std::string& a_path);

 bool executable(const std::string& a_path);

 #ifdef S_ISFIFO

 bool is_fifo_special(const std::string& a_path);

 #endif

 #ifdef S_ISCHR

 bool is_char_special(const std::string& a_path);

 #endif

 #ifdef S_ISDIR

 bool is_dir(const std::string& a_path);

 #endif

 #ifdef S_ISREG

 bool is_file(const std::string& a_path);

 #endif

 #ifdef S_ISBLK

 bool is_block_special(const std::string& a_path);

 #endif

 #ifdef S_ISLNK

 bool is_link(const std::string& a_path);

 #endif

 #ifdef S_ISSOCK

 bool is_socket(const std::string& a_path);

 #endif

 #ifdef S_ISDOOR

 bool is_door(const std::string& a_path);

 #endif

 void mk_dir(const std::string& a_path);

 void rm_dir(const std::string a_path);

 void rm_file(const std::string a_path);

 void mk_dirhier(const std::string a_path);

 void rename_file(const std::string a_from, const std::string a_to);

 void mk_symlink(const std::string a_from, const std::string a_to);

 void mk_relative_symlink(const std::string a_from, const std::string a_to);


 /** Retrieve information about a file or directory */

 class filestatus

 {

 public:

         enum filetype {

 #ifdef S_ISFIFO

                 type_fifo_special,

 #endif

 #ifdef S_ISCHR

                 type_character_special,

 #endif

 #ifdef S_ISDIR

                 type_directory,

 #endif

 #ifdef S_ISREG

                 type_regular_file,

 #endif

 #ifdef S_ISBLK

                 type_block_special,

 #endif

 #ifdef S_ISLNK

                 type_link,

 #endif

 #ifdef S_ISSOCK

                 type_socket,

 #endif

 #ifdef S_ISDOOR

                 type_door,

 #endif

                 type_unknown

         };

         typedef mode_t mode_type;

         typedef ino_t inode_type;

         typedef dev_t device_type;

         typedef uint32 major_type;

         typedef uint32 minor_type;

         typedef nlink_t num_links_type;

         typedef uid_t uid_type;

         typedef gid_t gid_type;

         typedef uint64 size_type;

         typedef time_t time_type;


         filestatus();

         filestatus(const std::string a_path);

         ~filestatus();


         void path(const std::string a_path);

         const std::string path(void) const;

         const filetype type(void) const;

         const std::string link(void) const;


         const mode_type mode(void) const;

         const inode_type inode(void) const;

         const device_type dev(void) const;

         const device_type rdev(void) const;

         const major_type get_major(void) const;

         const minor_type get_minor(void) const;

         const num_links_type num_links(void) const;

         const uid_type uid(void) const;

         const gid_type gid(void) const;

         const size_type size(void) const;

         const time_type last_access_time(void) const;

         const time_type last_modification_time(void) const;

         const time_type last_status_change_time(void) const;

         const size_type blocksize(void) const;

         const size_type blocks(void) const;

         const bool uid_is_found(void) const;

         const bool gid_is_found(void) const;

         const std::string uid_name(void) const;

         const std::string gid_name(void) const;


         void clear(void);


 #ifdef S_ISFIFO

         const bool is_fifo_special(void) const;

 #endif

 #ifdef S_ISCHR

         const bool is_character_special(void) const;

 #endif

 #ifdef S_ISBLK

         const bool is_block_special(void) const;

 #endif

 #ifdef S_ISLNK

         const bool is_link(void) const;

 #endif

 #ifdef S_ISSOCK

         const bool is_socket(void) const;

 #endif

 #ifdef S_ISDOOR

         const bool is_door(void) const;

 #endif

 #ifdef S_ISDIR

         const bool is_directory(void) const;

 #endif

 #ifdef S_ISREG

         const bool is_regular_file(void) const;

 #endif


 #ifdef S_IRUSR

         const bool user_can_read(void) const;

 #endif

 #ifdef S_IWUSR

         const bool user_can_write(void) const;

 #endif

 #ifdef S_IXUSR

         const bool user_can_execute(void) const;

 #endif

 #ifdef S_IRGRP

         const bool group_can_read(void) const;

 #endif

 #ifdef S_IWGRP

         const bool group_can_write(void) const;

 #endif

 #ifdef S_IXGRP

         const bool group_can_execute(void) const;

 #endif

 #ifdef S_IROTH

         const bool other_can_read(void) const;

 #endif

 #ifdef S_IWOTH

         const bool other_can_write(void) const;

 #endif

 #ifdef S_IXOTH

         const bool other_can_execute(void) const;

 #endif

 #ifdef S_ISUID

         const bool is_set_uid(void) const;

 #endif

 #ifdef S_ISGID

         const bool is_set_gid(void) const;

 #endif

 #ifdef S_ISVTX

         const bool is_set_sticky(void) const;

 #endif


 private:

         std::string m_path;

         struct stat m_stat;

         std::string m_link;

         major_type m_major;

         minor_type m_minor;

         bool m_uidfound;

         bool m_gidfound;

         std::string m_uname;

         std::string m_gname;

 };


 /** Retrieve a list of files in a subdirectory that match a given wildcard

         filename


         Pathnames to the files are not included.

  */

 class subdirectory : public std::vector<std::string>

 {

 public:

         typedef std::vector<std::string> type;


         subdirectory();

         subdirectory(const subdirectory& a_class);

         subdirectory(const std::string a_path, const std::string a_filter = "*");

         ~subdirectory();


         void assign(const subdirectory& a_class);


         const type&

                 path(const std::string a_path, const std::string a_filter = "*");


         subdirectory& operator=(const subdirectory& a_class);


 private:

 };


 void rm_recursive(const std::string a_path);


 /** Retrieve a list of pathnames that match a given wildcard path


         Pathnames to the files are included.  Depending on the wildcard path given,

         files listed may be in multiple directories.

  */

 class directory : public std::vector<std::string>

 {

 public:

         typedef std::vector<std::string> type;


         directory();

         directory(const directory& a_class);

         directory(const std::string& a_str);

         ~directory();


         const type& path(const std::string& a_path);


 private:

 };


 /** Retrieve information about a filesystem */

 class filesystem {

 public:

         typedef uint64 size_type;


         filesystem();

         filesystem(const std::string& a_path);


         void clear(void);


         void path(const std::string& a_path);

         const std::string path(void) const;

         const size_type blocksize(void) const;

         const size_type total_blocks(void) const;

         const size_type free_blocks(void) const;

         const size_type used_blocks(void) const;

         const size_type total_inodes(void) const;

         const size_type free_inodes(void) const;

         const size_type used_inodes(void) const;


         filesystem& operator=(const filesystem& a_class);


 private:

         std::string m_path;

         struct STATFS m_statfs;

 };


 /** A simple locking mechanism */

 class simple_lock {

 public:

         typedef pid_t pid_type;


         simple_lock();

         simple_lock(const std::string& a_lockfile);

         ~simple_lock();


         void clear(void);


         void lockfile(const std::string& a_lockfile);

         const std::string lockfile(void) const;


         const pid_type locked_by(void) const;

         const bool is_locked(void) const;

         bool lock(void);

         void unlock(void);

 private:

         std::string m_lockfile;

 };


 #endif

filesystem::filesystem
filesystem()
C'tor.
Definition: fs.cc:1580

filesystem
Retrieve information about a filesystem.
Definition: fs.h:316

filesystem::total_inodes
const size_type total_inodes(void) const
Return the filesystem's total number of inodes, if supported by the filesystem, otherwise the result ...
Definition: fs.cc:1662

readable
bool readable(const std::string &a_path)
Return true if the file or directory exists and is readable.
Definition: fs.cc:417

filestatus::size_type
uint64 size_type
Definition: fs.h:160

directory::path
const type & path(const std::string &a_path)
Retrieve a list of paths that match the wildcard path given.
Definition: fs.cc:1510

types.h
Basic types definitions and templates.

directory::~directory
~directory()
D'tor.
Definition: fs.cc:1505

absolute_path
bool absolute_path(const std::string &a_path)
Return true if the string looks like an absolute path.
Definition: fs.cc:186

path_basename
std::string path_basename(const std::string &a_path)
Return everything after the last slash from a path.
Definition: fs.cc:247

path_dirname
std::string path_dirname(const std::string &a_path)
Return everything up to the last slash from a path.
Definition: fs.cc:264

rm_recursive
void rm_recursive(const std::string a_path)
Recursively delete the contents of a directory.
Definition: fs.cc:1414

filestatus::device_type
dev_t device_type
Definition: fs.h:154

mk_dir
void mk_dir(const std::string &a_path)
Create a directory.
Definition: fs.cc:599

filestatus::blocks
const size_type blocks(void) const
Return the number of blocks used to store this file.
Definition: fs.cc:1038

filestatus::filetype
filetype
Definition: fs.h:125

filestatus::minor_type
uint32 minor_type
Definition: fs.h:156

mk_relative_path
std::string mk_relative_path(const std::string a_path_to, const std::string a_path_from)
Make the path a_path_to relative from a_path_from, where a_path_to and a_path_from are directory name...
Definition: fs.cc:314

filestatus::gid_is_found
const bool gid_is_found(void) const
If the file's owner's GID is found in the passwd file, return true.
Definition: fs.cc:1054

reform_path
std::string reform_path(const std::string &a_path)
Reformat a path to remove double slashes.
Definition: fs.cc:205

simple_lock::lock
bool lock(void)
Lock.
Definition: fs.cc:1778

filestatus::uid_is_found
const bool uid_is_found(void) const
If the file's owner's UID is found in the passwd file, return true.
Definition: fs.cc:1048

filesystem::blocksize
const size_type blocksize(void) const
Return the filesystem block size.
Definition: fs.cc:1620

filestatus::inode
const inode_type inode(void) const
Return the file inode.
Definition: fs.cc:952

filestatus::link
const std::string link(void) const
If the pathname is a link, return the path it is linked to.
Definition: fs.cc:940

filesystem::m_statfs
struct STATFS m_statfs
Definition: fs.h:339

relative_path
bool relative_path(const std::string &a_path)
Return true if the string looks like a relative path.
Definition: fs.cc:195

exists
bool exists(const std::string &a_path)
Return true if the file or directory exists.
Definition: fs.cc:385

filesystem::size_type
uint64 size_type
Definition: fs.h:318

filestatus::m_uname
std::string m_uname
Definition: fs.h:264

executable
bool executable(const std::string &a_path)
Return true if the file or directory exists and is executable.
Definition: fs.cc:437

filesystem::used_blocks
const size_type used_blocks(void) const
Return the filesystem's number of used blocks.
Definition: fs.cc:1650

pid
const pid_t pid(void)
Return the PID of this process.
Definition: fs.cc:162

filestatus::m_link
std::string m_link
Definition: fs.h:259

directory
Retrieve a list of pathnames that match a given wildcard path.
Definition: fs.h:300

simple_lock::~simple_lock
~simple_lock()
D'tor.
Definition: fs.cc:1718

mk_relative_symlink
void mk_relative_symlink(const std::string a_from, const std::string a_to)
Given a from and to path, create a relative symbolic link.
Definition: fs.cc:770

filestatus::last_status_change_time
const time_type last_status_change_time(void) const
Return the last status change time of this file.
Definition: fs.cc:1022

filestatus::filestatus
filestatus()
C'tor.
Definition: fs.cc:808

filesystem::m_path
std::string m_path
Definition: fs.h:338

filestatus::major_type
uint32 major_type
Definition: fs.h:155

filestatus::blocksize
const size_type blocksize(void) const
Return the blocksize used to store this file.
Definition: fs.cc:1028

directory::directory
directory()
C'tor.
Definition: fs.cc:1488

filestatus::m_stat
struct stat m_stat
Definition: fs.h:258

writable
bool writable(const std::string &a_path)
Return true if the file or directory exists and is writable.
Definition: fs.cc:427

simple_lock::lockfile
const std::string lockfile(void) const
Get the lockfile path.
Definition: fs.cc:1740

filestatus::mode
const mode_type mode(void) const
Return the file mode.
Definition: fs.cc:946

filesystem::operator=
filesystem & operator=(const filesystem &a_class)
Copy values from another instance.
Definition: fs.cc:1694

directory::type
std::vector< std::string > type
Definition: fs.h:303

rm_dir
void rm_dir(const std::string a_path)
Remove a directory.
Definition: fs.cc:612

filestatus::mode_type
mode_t mode_type
Definition: fs.h:152

simple_lock::unlock
void unlock(void)
Unlock.
Definition: fs.cc:1798

simple_lock
A simple locking mechanism.
Definition: fs.h:343

filestatus::num_links_type
nlink_t num_links_type
Definition: fs.h:157

simple_lock::m_lockfile
std::string m_lockfile
Definition: fs.h:361

subdirectory::path
const type & path(const std::string a_path, const std::string a_filter="*")
Return a vector of strings of a list of files in a subdirectory.
Definition: fs.cc:1361

filestatus::m_minor
minor_type m_minor
Definition: fs.h:261

simple_lock::locked_by
const pid_type locked_by(void) const
Get the PID of the locking process.
Definition: fs.cc:1746

filestatus::time_type
time_t time_type
Definition: fs.h:161

filestatus::type
const filetype type(void) const
Return the type of file.
Definition: fs.cc:894

filesystem::free_inodes
const size_type free_inodes(void) const
Return the filesystem's total number of free inodes, if supported by the filesystem, otherwise the result is system-dependent, but usually 0.
Definition: fs.cc:1674

filestatus::type_unknown
Definition: fs.h:150

filestatus::gid_type
gid_t gid_type
Definition: fs.h:159

filestatus::uid_name
const std::string uid_name(void) const
Return the file's owner's user name (from UID)
Definition: fs.cc:1060

filestatus::uid
const uid_type uid(void) const
Return the file's owner's UID.
Definition: fs.cc:988

filestatus::last_modification_time
const time_type last_modification_time(void) const
Return the last modification time of this file.
Definition: fs.cc:1016

permute_path
std::string permute_path(const std::string &a_path)
Reformat a path to remove the begining and trailing slashes, and replace all other slashes with under...
Definition: fs.cc:224

filestatus::get_minor
const minor_type get_minor(void) const
If the pathname is a special file, return it's minor number.
Definition: fs.cc:976

rename_file
void rename_file(const std::string a_from, const std::string a_to)
Rename a file or directory.
Definition: fs.cc:709

cwd
const std::string cwd(void)
Return the current working directory.
Definition: fs.cc:148

filestatus::m_gname
std::string m_gname
Definition: fs.h:265

filestatus::dev
const device_type dev(void) const
Return the file's device.
Definition: fs.cc:958

mk_absolute_path
std::string mk_absolute_path(const std::string a_path, const std::string a_rel_path)
Make the path a_rel_path absolute with respect to a_path, where a_rel_path and a_path are directory n...
Definition: fs.cc:282

filestatus
Retrieve information about a file or directory.
Definition: fs.h:122

filestatus::uid_type
uid_t uid_type
Definition: fs.h:158

filestatus::m_major
major_type m_major
Definition: fs.h:260

simple_lock::clear
void clear(void)
Clear the simple_lock object.
Definition: fs.cc:1724

filestatus::path
const std::string path(void) const
Return the pathname that this filestatus object has information about.
Definition: fs.cc:888

filesystem::used_inodes
const size_type used_inodes(void) const
Return the filesystem's number of used inodes.
Definition: fs.cc:1684

simple_lock::pid_type
pid_t pid_type
Definition: fs.h:345

mk_dirhier
void mk_dirhier(const std::string a_path)
Recursively create a directory heirarchy.
Definition: fs.cc:683

filestatus::clear
void clear(void)
Clear all values.
Definition: fs.cc:1312

filesystem::free_blocks
const size_type free_blocks(void) const
Return the filesystem's number of free blocks.
Definition: fs.cc:1640

filestatus::gid_name
const std::string gid_name(void) const
Return the file's owner's group name (from UID)
Definition: fs.cc:1066

subdirectory::~subdirectory
~subdirectory()
D'tor.
Definition: fs.cc:1345

filestatus::m_path
std::string m_path
Definition: fs.h:257

filestatus::size
const size_type size(void) const
Return the file size in bytes.
Definition: fs.cc:1000

subdirectory::assign
void assign(const subdirectory &a_class)
Assign the contents of a given subdirectory to this subdirectory.
Definition: fs.cc:1350

filestatus::gid
const gid_type gid(void) const
Return the file's owner's GID.
Definition: fs.cc:994

simple_lock::simple_lock
simple_lock()
C'tor.
Definition: fs.cc:1705

subdirectory::type
std::vector< std::string > type
Definition: fs.h:276

filestatus::m_uidfound
bool m_uidfound
Definition: fs.h:262

STATFS
#define STATFS
Definition: fs.h:62

filestatus::num_links
const num_links_type num_links(void) const
Return the number of links to this file.
Definition: fs.cc:982

filestatus::last_access_time
const time_type last_access_time(void) const
Return the last access time of this file.
Definition: fs.cc:1010

subdirectory
Retrieve a list of files in a subdirectory that match a given wildcard filename.
Definition: fs.h:273

filestatus::inode_type
ino_t inode_type
Definition: fs.h:153

filesystem::clear
void clear(void)
Clear the filesystem object.
Definition: fs.cc:1593

mk_symlink
void mk_symlink(const std::string a_from, const std::string a_to)
Create a symbolic link.
Definition: fs.cc:754

filestatus::rdev
const device_type rdev(void) const
Return the file's raw device.
Definition: fs.cc:964

filestatus::m_gidfound
bool m_gidfound
Definition: fs.h:263

filesystem::path
const std::string path(void) const
Return the path from which this filesystem information was obtained.
Definition: fs.cc:1614

filestatus::get_major
const major_type get_major(void) const
If the pathname is a special file, return it's major number.
Definition: fs.cc:970

filesystem::total_blocks
const size_type total_blocks(void) const
Return the filesystem's total number of blocks.
Definition: fs.cc:1630

parent_pid
const pid_t parent_pid(void)
Return the PID of the parent process.
Definition: fs.cc:174

simple_lock::is_locked
const bool is_locked(void) const
Find out whether or not the lock is in place.
Definition: fs.cc:1765

filestatus::~filestatus
~filestatus()
D'tor.
Definition: fs.cc:819

subdirectory::operator=
subdirectory & operator=(const subdirectory &a_class)
Definition: fs.cc:1404

rm_file
void rm_file(const std::string a_path)
Remove a file.
Definition: fs.cc:637

subdirectory::subdirectory
subdirectory()
C'tor.
Definition: fs.cc:1327