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_THREAD_H_
#include <cc++/thread.h>
#endif

#include <iostream>
#include <fstream>

#ifndef WIN32
#include <cstdio>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/mman.h>
#else
#include <direct.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
typedef LONG off_t;
typedef void* caddr_t;
typedef DWORD ccxx_size_t;
#endif

class File
{
public:
        enum Error
        {
                errSuccess = 0,
                errNotOpened,
                errMmapFailed,
                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;
        } fcb_t;

#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, // = FILE_MAPPED_READ
                mappedWrite, // = FILE_MAPPED_WRITE,
                mappedReadWrite // = FILE_MAPPED_RDWR
        };
#else
        enum Mapping
        {
                mappedRead = accessReadOnly,
                mappedWrite = accessWriteOnly,
                mappedReadWrite = accessReadWrite
        };
        enum Complete
        {
                completionImmediate,
                completionDelayed,
                completionDeferred
        };
#endif
        typedef enum Complete Complete;
        typedef enum Mapping Mapping;
};

#ifndef WIN32

class fifostream : public std::fstream, public File
{
private:
        char *pathname;

public:
        fifostream();

        fifostream(const char *fname, long access = (long)attrGroup);

        virtual ~fifostream();

        void open(const char *fname, long access = (long)attrGroup);

        void close(void);
};
#endif // !WIN32

#ifndef WIN32

class FIFOSession : public Thread, public std::fstream, public File
{
private:
        char *pathname;

public:
        FIFOSession(const char *session, long access = (long)attrGroup, int pri = 0, int stack = 0);
        virtual ~FIFOSession();
};
#endif // !WIN32

class CCXX_CLASS_EXPORT Dir
{
private:
#ifndef WIN32
        DIR *dir;
#else
        HANDLE hDir;
        WIN32_FIND_DATA data;
        char *name;
#endif

public:
        Dir(const char *name);
        virtual ~Dir();

        char *getName(void);

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

        bool isValid(void);
};

class CCXX_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();

        RandomFile(const RandomFile &rf);

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

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

        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 CCXX_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 CCXX_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);
};

#ifndef WIN32

class CCXX_CLASS_EXPORT MappedFile : public RandomFile
{
private:
        fcb_t fcb;
        int prot;

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

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

        // FIXME: not use library function in header ??
        inline void sync(void)
                {msync(fcb.address, fcb.len, MS_SYNC);};

        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);
};
#endif // !WIN32

class CCXX_CLASS_EXPORT Pipe
{
protected:
#ifndef WIN32
        int fd[2];
#else
        HANDLE fd[2];
#endif
        int objcount;
        int objsize;

        inline int getSize(void)
                {return objsize;};

        inline void endSender(void)
#ifndef WIN32
                {close(fd[1]);};
#else
                {CloseHandle(fd[1]); fd[1] = NULL; };
#endif

        inline void endReceiver(void)
#ifndef WIN32
                {close(fd[0]);};
#else
                {CloseHandle(fd[0]); fd[0] = NULL; };
#endif

        Pipe(int size = 512, int count = 1);

        virtual ~Pipe();

        Pipe(const Pipe &orig);

        Pipe &operator=(const Pipe &orig);

        /* depreciated methods */
        void sender(void)
                {endReceiver();};

        void receiver(void)
                {endSender();};

        int read(void *buf, int len)
#ifndef WIN32
                {return ::read(fd[0], (char *)buf, len);};
#else
                {DWORD dwLen; return ReadFile(fd[0],buf,len,&dwLen,NULL) ? dwLen : (DWORD)-1; };
#endif

        int write(void *buf, int len)
#ifndef WIN32
                {return ::write(fd[1], (char *)buf, len);};
#else
                {DWORD dwLen; return WriteFile(fd[1],buf,len,&dwLen,NULL) ? dwLen : (DWORD)-1; };
#endif

public:
        bool operator!();

#ifndef WIN32
        inline int receive(void *addr)
                {return ::read(fd[0], (char *)addr, objsize);};
#else
        int receive(void *addr);
#endif

#ifndef WIN32
        inline int send(void *addr)
                {return ::write(fd[1], (char *)addr, objsize);};
#else
        int send(void *addr);
#endif

        bool isValid(void);
};

class DSO
{
private:
#ifdef  HAVE_MODULES
        static Mutex mutex;
        static DSO *first, *last;
        DSO *next, *prev;
#if     defined(HAVE_MACH_DYLD)
        NSModule oModule;
        char *err;      
#elif   defined(HAVE_SHL_LOAD)
        char *err;
        shl_t image;
#elif   defined(WIN32)
        char *err;
        HINSTANCE hImage;
#else
        void *image;
#endif
        CCXX_MEMBER_EXPORT(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

        char *getError(void);

#ifdef  HAVE_MODULES
        CCXX_MEMBER_EXPORT(virtual) ~DSO();
#endif

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

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

        CCXX_MEMBER_EXPORT(bool) isValid(void);
};

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

bool isDevice(const char *path);
#else

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

bool canAccess(const char *path);
bool canModify(const char *path);

#ifdef  COMMON_STD_EXCEPTION

class DirException : public IOException
{
public:
        DirException(std::string str) : IOException(str) {};
};

class DSOException : public IOException
{
public:
        DSOException(std::string str) : IOException(str) {};
};

class FIFOException : public IOException
{
public:
        FIFOException(std::string str) : IOException(str) {};
};

class PipeException : public IOException
{
public:
        PipeException(std::string str) : IOException(str) {};
};

class FileException : public IOException
{
public:
        FileException(std::string str) : IOException(str) {};
};

#endif

#ifdef  CCXX_NAMESPACES
};
#endif

#endif

---