fsys.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_FSYS_H_
#define _UCOMMON_FSYS_H_
 
#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif
 
#ifndef _UCOMMON_PROTOCOLS_H_
#include <ucommon/protocols.h>
#endif
 
#ifndef _UCOMMON_THREAD_H_
#include <ucommon/thread.h>
#endif
 
#ifndef _UCOMMON_TYPEREF_H_
#include <ucommon/typeref.h>
#endif
 
#ifndef _UCOMMON_MEMORY_H_
#include <ucommon/memory.h>
#endif
 
#ifndef _MSWINDOWS_
#include <sys/stat.h>
#else
#include <io.h>
#ifndef R_OK
#define F_OK 0
#define X_OK 1
#define W_OK 2
#define R_OK 4
#endif
#endif
 
#include <errno.h>
#include <stdio.h>
 
#ifndef __S_ISTYPE
#define __S_ISTYPE(mode, mask)  (((mode) & S_IFMT) == (mask))
#endif
 
#if !defined(S_ISDIR) && defined(S_IFDIR)
#define S_ISDIR(mode)   __S_ISTYPE((mode), S_IFDIR)
#endif
 
#if !defined(S_ISCHR) && defined(S_IFCHR)
#define S_ISCHR(mode)   __S_ISTYPE((mode), S_IFCHR)
#elif !defined(S_ISCHR)
#define S_ISCHR(mode)   0
#endif
 
#if !defined(S_ISBLK) && defined(S_IFBLK)
#define S_ISBLK(mode)   __S_ISTYPE((mode), S_IFBLK)
#elif !defined(S_ISBLK)
#define S_ISBLK(mode)   0
#endif
 
#if !defined(S_ISREG) && defined(S_IFREG)
#define S_ISREG(mode)   __S_ISTYPE((mode), S_IFREG)
#elif !defined(S_ISREG)
#define S_ISREG(mode)   1
#endif
 
#if !defined(S_ISSOCK) && defined(S_IFSOCK)
#define S_ISSOCK(mode)  __S_ISTYPE((mode), S_IFSOCK)
#elif !defined(S_ISSOCK)
#define S_ISSOCK(mode)  (0)
#endif
 
#if !defined(S_ISFIFO) && defined(S_IFIFO)
#define S_ISFIFO(mode)  __S_ISTYPE((mode), S_IFIFO)
#elif !defined(S_ISFIFO)
#define S_ISFIFO(mode)  (0)
#endif
 
#if !defined(S_ISLNK) && defined(S_IFLNK)
#define S_ISLNK(mode)   __S_ISTYPE((mode), S_IFLNK)
#elif !defined(S_ISLNK)
#define S_ISLNK(mode)   (0)
#endif
 
namespace ucommon {
 
typedef void *mem_t;
 
class __EXPORT fsys
{
protected:
    fd_t    fd;
    mutable int     error;
 
public:
    enum {
        OWNER_READONLY = 0400,
        GROUP_READONLY = 0440,
        PUBLIC_READONLY = 0444,
        OWNER_PRIVATE = 0600,
        OWNER_PUBLIC = 0644,
        GROUP_PRIVATE = 0660,
        GROUP_PUBLIC = 0664,
        EVERYONE = 0666,
        DIR_TEMPORARY = 01777
    };
 
    typedef struct stat fileinfo_t;
 
#ifdef  _MSWINDOWS_
    static int remapError(void);
#else
    inline static int remapError(void) {
        return errno;
    }
#endif
 
    typedef enum {
        RDONLY,
        WRONLY,
        REWRITE,
        RDWR = REWRITE,
        APPEND,
        SHARED,
        EXCLUSIVE,
        DEVICE,
        STREAM,
        RANDOM
    } access_t;
 
    typedef long offset_t;
 
    static const offset_t end;
 
    fsys();
 
    fsys(fd_t handle);
 
    fsys(const fsys& descriptor);
 
    fsys(const char *path, access_t access);
 
    fsys(const char *path, unsigned permission, access_t access);
 
    ~fsys();
 
    inline fd_t operator*() const {
        return fd;
    }
 
    inline operator fd_t() const {
        return fd;
    }
 
    inline void reset(void) {
        error = 0;
    }
 
    inline operator bool() const {
        return fd != INVALID_HANDLE_VALUE;
    }
 
    inline bool operator!() const {
        return fd == INVALID_HANDLE_VALUE;
    }
 
    fsys& operator=(const fsys& descriptor);
 
    fsys& operator*=(fd_t& descriptor);
 
    fsys& operator=(fd_t descriptor);
 
    inline fd_t handle(void) const {
        return fd;
    }
 
    void set(fd_t descriptor);
 
    fd_t release(void);
 
    int seek(offset_t offset);
 
    int drop(offset_t size = 0);
 
    bool is_tty(void) const;
 
    static bool is_tty(fd_t fd);
 
    ssize_t read(void *buffer, size_t count);
 
    ssize_t write(const void *buffer, size_t count);
 
    int info(fileinfo_t *buffer);
 
    int trunc(offset_t offset);
 
    int sync(void);
 
    static int prefix(const char *path);
 
    static int prefix(char *path, size_t size);
 
    static stringref_t prefix(void);
 
    static int info(const char *path, fileinfo_t *buffer);
 
    static int erase(const char *path);
 
    static int copy(const char *source, const char *target, size_t size = 1024);
 
    static int rename(const char *oldpath, const char *newpath);
 
    static int mode(const char *path, unsigned value);
 
    static bool is_exists(const char *path);
 
    static bool is_readable(const char *path);
 
    static bool is_writable(const char *path);
 
    static bool is_executable(const char *path);
 
    static bool is_file(const char *path);
 
    static bool is_dir(const char *path);
 
    static bool is_link(const char *path);
 
    static bool is_device(const char *path);
 
    static bool is_hidden(const char *path);
 
    void open(const char *path, access_t access);
 
    inline void assign(fd_t descriptor) {
        close(); 
        fd = descriptor;
    }
 
    inline static void assign(fsys& object, fd_t descriptor) {
        object.close(); 
        object.fd = descriptor;
    }
 
    void open(const char *path, unsigned mode, access_t access);
 
    static int unlink(const char *path);
 
    static int link(const char *path, const char *target);
 
    static int hardlink(const char *path, const char *target);
 
    static int linkinfo(const char *path, char *buffer, size_t size);
 
    int close(void);
 
    inline int err(void) const {
        return error;
    }
 
    static fd_t input(const char *path);
 
    static fd_t output(const char *path);
 
    static fd_t append(const char *path);
 
    static void release(fd_t descriptor);
 
    static int pipe(fd_t& input, fd_t& output, size_t size = 0);
 
    static int inherit(fd_t& descriptor, bool enable);
 
    static fd_t null(void);
 
    static int load(const char *path);
 
    static int exec(const char *path, char **argv, char **envp = NULL);
 
    static inline bool is_file(struct stat *inode) {
        return S_ISREG(inode->st_mode);
    }
 
    static inline bool is_dir(struct stat *inode) {
        return S_ISDIR(inode->st_mode);
    }
 
    static inline bool is_link(struct stat *inode) {
        return S_ISLNK(inode->st_mode);
    }
 
    static inline bool is_dev(struct stat *inode) {
        return S_ISBLK(inode->st_mode) || S_ISCHR(inode->st_mode);
    }
 
    static inline bool is_char(struct stat *inode) {
        return S_ISCHR(inode->st_mode);
    }
 
    static inline bool is_disk(struct stat *inode) {
        return S_ISBLK(inode->st_mode);
    }
 
    static inline bool is_sys(struct stat *inode) {
        return S_ISSOCK(inode->st_mode) || S_ISFIFO(inode->st_mode);
    }
};
 
class __EXPORT dso
{
private:
    friend class fsys;
 
#ifdef  _MSWINDOWS_
    HINSTANCE   ptr;
#else
    void    *ptr;
#endif
    int     error;
 
    __DELETE_COPY(dso);
 
public:
#ifdef  _MSWINDOWS_
    typedef int (FAR WINAPI *addr_t)();
#else
    typedef void *addr_t;
#endif
 
    dso();
 
    dso(const char *path);
 
    ~dso();
 
    void map(const char *path);
 
    void release(void);
 
    addr_t find(const char *symbol) const;
 
    inline int err(void) const {
        return error;
    }
 
    inline addr_t operator[](const char *symbol) const {
        return find(symbol);
    }
 
    inline addr_t operator()(const char *symbol) const {
        return find(symbol);
    }
 
    inline operator bool() const {
        return ptr != NULL;
    }
 
    inline bool operator!() const {
        return ptr == NULL;
    }
};
 
class __EXPORT dir : private fsys
{
private:
#ifdef  _MSWINDOWS_
    WIN32_FIND_DATA *ptr;
    HINSTANCE   mem;
#else
    void    *ptr;
#endif
 
public:
    dir(const char *path);
 
    dir();
 
    ~dir();
 
    static int create(const char *path, unsigned mode);
 
    static int remove(const char *path);
 
    void open(const char *path);
 
    ssize_t read(char *buffer, size_t count);
 
    void close(void);
 
    inline int err(void) const {
        return fsys::err();
    }
 
    inline void reset(void) {
        fsys::reset();
    }
 
    inline operator bool() const {
        return ptr != NULL;
    }
 
    inline bool operator!() const {
        return ptr == NULL;
    }
};
 
typedef fsys fsys_t;
 
typedef dir dir_t;
 
typedef dso dso_t;
 
inline bool is_exists(const char *path)
{
    return fsys::is_exists(path);
}
 
inline bool is_readable(const char *path)
{
    return fsys::is_readable(path);
}
 
inline bool is_writable(const char *path)
{
    return fsys::is_writable(path);
}
 
inline bool is_executable(const char *path)
{
    return fsys::is_executable(path);
}
 
inline bool is_file(const char *path)
{
    return fsys::is_file(path);
}
 
inline bool is_dir(const char *path)
{
    return fsys::is_dir(path);
}
 
inline bool is_link(const char *path)
{
    return fsys::is_link(path);
}
 
inline bool is_device(const char *path)
{
    return fsys::is_device(path);
}
 
} // namespace ucommon
 
#endif