file.h

Go to the documentation of this file.

// Copyright (C) 1999-2002 Open Source Telecom Corporation.
//
// 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 General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// As a special exception to the GNU General Public License, permission is
// granted for additional uses of the text contained in its release
// of Common C++.
//
// The exception is that, if you link the Common C++ library with other
// files to produce an executable, this does not by itself cause the
// resulting executable to be covered by the GNU General Public License.
// Your use of that executable is in no way restricted on account of
// linking the Common C++ library code into it.
//
// 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 Common C++.  If you copy code from other releases into a copy of
// 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 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 CCXX_FILE_H_
#define CCXX_FILE_H_

#ifndef CCXX_CONFIG_H_
#include <cc++/config.h>
#endif

#ifndef CCXX_MISSING_H_
#include <cc++/missing.h>
#endif

#ifndef CCXX_THREAD_H_
#include <cc++/thread.h>
#endif

#ifndef CCXX_EXCEPTION_H_
#include <cc++/exception.h>
#endif

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

#ifdef  HAVE_SHL_LOAD
#include <dl.h>
#endif

#ifdef  HAVE_MACH_DYLD
#include <mach-o/dyld.h>
#endif

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

typedef unsigned long pos_t;
#ifndef WIN32
// 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
#ifndef __BORLANDC__
typedef LONG off_t;
#endif
typedef void* caddr_t;
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,
                errExtended
        };
        typedef enum Error Error;

        enum Access
        {
#ifndef WIN32
                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  WIN32
        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 WIN32
        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  WIN32
        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 WIN32
        DIR *dir;
#ifdef  HAVE_READDIR_R
        struct dirent *save;
        char save_space[sizeof(struct dirent) + PATH_MAX + 1];
#endif
        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 WIN32
                {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 *path, struct stat *ino);

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

        DirTree(unsigned depth);

        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 WIN32
        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 WIN32
                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 WIN32

        Error setCompletion(Complete mode);
#endif

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

        virtual Attr initialize(void)
                {return attrPublic;};

        void final(void);

public:
        virtual ~RandomFile()
                {final();};

        bool initial(void);

        off_t getCapacity(void);

        virtual Error restart(void)
                {return errOpenFailed;};

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

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

        bool operator!(void);
};

class __EXPORT ThreadFile : public RandomFile
{
private:
        ThreadKey state;
        fcb_t *first;
        fcb_t *getFCB(void);
        Error open(const char *path);

public:
        ThreadFile(const char *path);

        virtual ~ThreadFile();

        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 append(caddr_t address = NULL, ccxx_size_t length = 0);

        off_t getPosition(void);

        bool operator++(void);
        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  WIN32
        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;
#ifdef  HAVE_MODULES
        static Mutex mutex;
        static DSO *first;
        static DSO *last;
        DSO *next, *prev;
        const char *id;
#if     defined(HAVE_MACH_DYLD)
        NSModule oModule;
#elif   defined(HAVE_SHL_LOAD)
        shl_t image;
#elif   defined(WIN32)
        HINSTANCE hImage;
#else
        void *image;
#endif
        void loader(const char *filename, bool resolve);
#endif

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

        DSO(const char *filename, bool resolve)
                {loader(filename, resolve);};
#else
        DSO(const char *filename)
                {throw this;};
        DSO(const char *filename, bool resolve)
                {throw this;};
#endif

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

#ifdef  HAVE_MODULES
        virtual ~DSO();
#endif

#ifdef  HAVE_MODULES
        void* operator[](const char *sym);
#else
        void *operator[](const char *)
                {return NULL;};
#endif

#ifdef  HAVE_MODULES
        static void dynunload(void);
#else
        static void dynunload(void)
                {return;};
#endif

        static DSO *getObject(const char *name);

        bool isValid(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

#ifdef  CCXX_NAMESPACES
}
#endif

#endif

---