commoncpp/file.h

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// Common C++.  If you copy code from other releases into a copy of GNU
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef COMMONCPP_FILE_H_
#define COMMONCPP_FILE_H_

#ifndef COMMONCPP_CONFIG_H_
#include <commoncpp/config.h>
#endif

#ifndef COMMONCPP_THREAD_H_
#include <commoncpp/thread.h>
#endif

#ifndef COMMONCPP_EXCEPTION_H_
#include <commoncpp/exception.h>
#endif

#ifndef WIN32
# ifdef __BORLANDC__
#  include <stdio.h>
#  include <sys/types.h>
# else
#  include <fcntl.h>
#  include <cstdio>
# endif
# include <dirent.h>
# include <sys/stat.h>
# include <sys/mman.h>
#else
# if __BORLANDC__ >= 0x0560
#  include <dirent.h>
#  include <sys/stat.h>
# else
#  include <direct.h>
# endif
#endif

NAMESPACE_COMMONCPP

typedef unsigned long pos_t;
#ifndef _MSWINDOWS_
// use a define so that if the sys/types.h header already defines caddr_t
// as it may on BSD systems, we do not break it by redefining again.
#undef  caddr_t
#define caddr_t char *
typedef size_t ccxx_size_t;
#else
typedef DWORD ccxx_size_t;
#endif

#ifndef PATH_MAX
#define PATH_MAX    256
#endif

#ifndef NAME_MAX
#define NAME_MAX    64
#endif

class __EXPORT File
{
public:
    enum Error {
        errSuccess = 0,
        errNotOpened,
        errMapFailed,
        errInitFailed,
        errOpenDenied,
        errOpenFailed,
        errOpenInUse,
        errReadInterrupted,
        errReadIncomplete,
        errReadFailure,
        errWriteInterrupted,
        errWriteIncomplete,
        errWriteFailure,
        errLockFailure,
        errExtended
    };
    typedef enum Error Error;

    enum Access {
#ifndef _MSWINDOWS_
        accessReadOnly = O_RDONLY,
        accessWriteOnly= O_WRONLY,
        accessReadWrite = O_RDWR
#else
        accessReadOnly = GENERIC_READ,
        accessWriteOnly = GENERIC_WRITE,
        accessReadWrite = GENERIC_READ | GENERIC_WRITE
#endif
    };
    typedef enum Access Access;

protected:
    typedef struct _fcb {
        struct _fcb *next;
        caddr_t address;
        ccxx_size_t len;
        off_t pos;
        bool locked;
    } fcb_t;

public:
#ifdef  _MSWINDOWS_
    enum Open {
        openReadOnly, // = FILE_OPEN_READONLY,
        openWriteOnly, // = FILE_OPEN_WRITEONLY,
        openReadWrite, // = FILE_OPEN_READWRITE,
        openAppend, // = FILE_OPEN_APPEND,
        openTruncate // = FILE_OPEN_TRUNCATE
    };
#else
    enum Open {
        openReadOnly = O_RDONLY,
        openWriteOnly = O_WRONLY,
        openReadWrite = O_RDWR,
        openAppend = O_WRONLY | O_APPEND,
#ifdef  O_SYNC
        openSync = O_RDWR | O_SYNC,
#else
        openSync = O_RDWR,
#endif
        openTruncate = O_RDWR | O_TRUNC
    };
    typedef enum Open Open;

/* to be used in future */

#ifndef S_IRUSR
#define S_IRUSR 0400
#define S_IWUSR 0200
#define S_IRGRP 0040
#define S_IWGRP 0020
#define S_IROTH 0004
#define S_IWOTH 0002
#endif

#endif // !WIN32

#ifndef _MSWINDOWS_
    enum Attr {
        attrInvalid = 0,
        attrPrivate = S_IRUSR | S_IWUSR,
        attrGroup = attrPrivate | S_IRGRP | S_IWGRP,
        attrPublic = attrGroup | S_IROTH | S_IWOTH
    };
#else // defined WIN32
    enum Attr {
        attrInvalid=0,
        attrPrivate,
        attrGroup,
        attrPublic
    };
#endif // !WIN32
    typedef enum Attr Attr;

#ifdef  _MSWINDOWS_
    enum Complete {
        completionImmediate, // = FILE_COMPLETION_IMMEDIATE,
        completionDelayed, // = FILE_COMPLETION_DELAYED,
        completionDeferred // = FILE_COMPLETION_DEFERRED
    };

    enum Mapping {
        mappedRead,
        mappedWrite,
        mappedReadWrite
    };
#else
    enum Mapping {
        mappedRead = accessReadOnly,
        mappedWrite = accessWriteOnly,
        mappedReadWrite = accessReadWrite
    };
    enum Complete {
        completionImmediate,
        completionDelayed,
        completionDeferred
    };
#endif
    typedef enum Complete Complete;
    typedef enum Mapping Mapping;

public:
    static const char *getExtension(const char *path);
    static const char *getFilename(const char *path);
    static char *getFilename(const char *path, char *buffer, size_t size = NAME_MAX);
    static char *getDirname(const char *path, char *buffer, size_t size = PATH_MAX);
    static char *getRealpath(const char *path, char *buffer, size_t size = PATH_MAX);
};

class __EXPORT Dir : public File
{
private:
#ifndef _MSWINDOWS_
    DIR *dir;
    struct dirent *save;
    char save_space[sizeof(struct dirent) + PATH_MAX + 1];
    struct dirent *entry;
#else
    HANDLE hDir;
    WIN32_FIND_DATA data, fdata;
    char *name;
#endif

public:
    Dir(const char *name = NULL);

    static bool create(const char *path, Attr attr = attrGroup);
    static bool remove(const char *path);
    static bool setPrefix(const char *path);
    static bool getPrefix(char *path, size_t size = PATH_MAX);

    void open(const char *name);
    void close(void);

    virtual ~Dir();

    const char *getName(void);

    const char *operator++()
        {return getName();};

    const char *operator++(int)
        {return getName();};

    const char *operator*();

    bool rewind(void);

    bool operator!()
#ifndef _MSWINDOWS_
        {return !dir;};
#else
        {return hDir != INVALID_HANDLE_VALUE;};
#endif

    bool isValid(void);
};

class __EXPORT  DirTree
{
private:
    char path[PATH_MAX + 1];
    Dir *dir;
    unsigned max, current, prefixpos;

protected:
    virtual bool filter(const char *file, struct stat *ino);

public:
    DirTree(const char *prefix, unsigned maxdepth);

    DirTree(unsigned maxdepth);

    virtual ~DirTree();

    void open(const char *prefix);

    void close(void);

    char *getPath(void);

    unsigned perform(const char *prefix);
};

class __EXPORT RandomFile : protected Mutex, public File
{
private:
    Error errid;
    char *errstr;

protected:
#ifndef _MSWINDOWS_
    int fd;
    // FIXME: WIN32 as no access member
    Access access;
#else
    HANDLE fd;
#endif
    char *pathname;

    struct {
        unsigned count : 16;
        bool thrown : 1;
        bool initial : 1;
#ifndef _MSWINDOWS_
        bool immediate : 1;
#endif
        bool temp : 1;
    } flags;

    RandomFile(const char *name = NULL);

    RandomFile(const RandomFile &rf);

    Error error(Error errid, char *errstr = NULL);

    inline Error error(char *err)
        {return error(errExtended, err);};

    inline void setError(bool enable)
        {flags.thrown = !enable;};

#ifndef _MSWINDOWS_

    Error setCompletion(Complete mode);
#endif

    inline void setTemporary(bool enable)
        {flags.temp = enable;};

    virtual Attr initialize(void);

    void final(void);

public:
    virtual ~RandomFile();

    bool initial(void);

    off_t getCapacity(void);

    virtual Error restart(void);

    inline Error getErrorNumber(void)
        {return errid;};

    inline char *getErrorString(void)
        {return errstr;};

    bool operator!(void);
};

class __EXPORT SharedFile : public RandomFile
{
private:
    fcb_t fcb;
    Error open(const char *path);

public:
    SharedFile(const char *path);

    SharedFile(const SharedFile &file);

    virtual ~SharedFile();

    Error restart(void)
        {return open(pathname);};

    Error fetch(caddr_t address = NULL, ccxx_size_t length = 0, off_t position = -1);

    Error update(caddr_t address = NULL, ccxx_size_t length = 0, off_t position = -1);

    Error clear(ccxx_size_t length = 0, off_t pos = -1);

    Error append(caddr_t address = NULL, ccxx_size_t length = 0);

    off_t getPosition(void);

    bool operator++(void);
    bool operator--(void);
};

class __EXPORT MappedFile : public RandomFile
{
private:
    fcb_t fcb;
    int prot;
#ifdef  _MSWINDOWS_
    HANDLE map;
    char mapname[64];
#endif

public:
    MappedFile(const char *fname, Access mode);

    MappedFile(const char *fname, Access mode, size_t size);

    MappedFile(const char *fname, pos_t offset, size_t size, Access mode);

    virtual ~MappedFile();

    // FIXME: not use library function in header ??
    void sync(void);

    void sync(caddr_t address, size_t len);

    void update(size_t offset = 0, size_t len = 0);

    void update(caddr_t address, size_t len);

    void release(caddr_t address, size_t len);

    inline caddr_t fetch(size_t offset = 0)
        {return ((char *)(fcb.address)) + offset;};

    caddr_t fetch(off_t pos, size_t len);

    bool lock(void);

    void unlock(void);

    size_t pageAligned(size_t size);
};


class __EXPORT DSO
{
private:
    const char *err;
    static Mutex mutex;
    static DSO *first;
    static DSO *last;
    DSO *next, *prev;
    const char *id;
    void *image;

    typedef ucommon::dso::addr_t addr_t;

protected:
    void loader(const char *filename, bool resolve);

public:
    DSO(const char *filename)
        {loader(filename, true);};

    DSO(const char *filename, bool resolve)
        {loader(filename, resolve);};

    inline const char *getError(void)
        {return err;};

    virtual ~DSO();

    addr_t operator[](const char *sym);

    static void dynunload(void);

    static DSO *getObject(const char *name);

    bool isValid(void);

    static void setDebug(void);
};

bool __EXPORT isDir(const char *path);
bool __EXPORT isFile(const char *path);
#ifndef WIN32

bool __EXPORT isDevice(const char *path);
#else

inline bool isDevice(const char *path)
{ return false; }
#endif

bool __EXPORT canAccess(const char *path);
bool __EXPORT canModify(const char *path);
time_t __EXPORT lastModified(const char *path);
time_t __EXPORT lastAccessed(const char *path);

#ifdef  COMMON_STD_EXCEPTION

class DirException : public IOException
{
public:
    DirException(const String &str) : IOException(str) {};
};

class __EXPORT DSOException : public IOException
{
public:
    DSOException(const String &str) : IOException(str) {};
};

class __EXPORT FileException : public IOException
{
public:
    FileException(const String &str) : IOException(str) {};
};

#endif

END_NAMESPACE

#endif

---