---

file.h

Go to the documentation of this file.

// Copyright (C) 1999-2001 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  __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

typedef struct _fcb
{
        struct _fcb *next;
        caddr_t address;
        ccxx_size_t len;
        off_t pos;
} fcb_t;

#ifndef WIN32
enum
{
        FILE_OPEN_READONLY = O_RDONLY,
        FILE_OPEN_WRITEONLY = O_WRONLY,
        FILE_OPEN_READWRITE = O_RDWR,
        FILE_OPEN_APPEND = O_WRONLY | O_APPEND,

#ifdef  O_SYNC
        FILE_OPEN_SYNC = O_RDWR | O_SYNC,
#else
        FILE_OPEN_SYNC = O_RDWR,
#endif
        FILE_OPEN_TRUNCATE = O_RDWR | O_TRUNC
};

/* 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 fileattr_t
{
        FILE_ATTR_INVALID = 0,
        FILE_ATTR_PRIVATE = S_IRUSR | S_IWUSR,
        FILE_ATTR_GROUP = FILE_ATTR_PRIVATE | S_IRGRP | S_IWGRP,
        FILE_ATTR_PUBLIC = FILE_ATTR_GROUP | S_IROTH | S_IWOTH
};
typedef enum fileattr_t fileattr_t;
#else // defined WIN32
typedef enum{
        FILE_ATTR_INVALID=0,
        FILE_ATTR_PRIVATE,
        FILE_ATTR_GROUP,
        FILE_ATTR_PUBLIC
} fileattr_t;
#endif // !WIN32

enum fileerror_t
{
        FILE_SUCCESS = 0,
        FILE_NOT_OPENED,
        FILE_MAP_FAILED,
        FILE_INIT_FAILED,
        FILE_OPEN_DENIED,
        FILE_OPEN_FAILED,
        FILE_OPEN_INUSE,
        FILE_READ_INTERRUPTED,
        FILE_READ_INCOMPLETE,
        FILE_READ_FAILURE,
        FILE_WRITE_INTERRUPTED,
        FILE_WRITE_INCOMPLETE,
        FILE_WRITE_FAILURE,
        FILE_EXTENDED_ERROR
};
typedef enum fileerror_t fileerror_t;

enum fileaccess_t
{
#ifndef WIN32
        FILE_ACCESS_READONLY = O_RDONLY,
        FILE_ACCESS_WRITEONLY= O_WRONLY,
        FILE_ACCESS_READWRITE = O_RDWR
#else
        FILE_ACCESS_READONLY = GENERIC_READ,
        FILE_ACCESS_WRITEONLY = GENERIC_WRITE,
        FILE_ACCESS_READWRITE = GENERIC_READ | GENERIC_WRITE
#endif
};
typedef enum fileaccess_t fileaccess_t;

#ifndef WIN32
#define FILE_MAPPED_READ        FILE_ACCESS_READONLY
#define FILE_MAPPED_WRITE       FILE_ACCESS_WRITEONLY
#define FILE_MAPPED_RDWR        FILE_ACCESS_READWRITE

enum filecomplete_t
{
        FILE_COMPLETION_IMMEDIATE,
        FILE_COMPLETION_DELAYED,
        FILE_COMPLETION_DEFERRED
};
typedef enum filecomplete_t filecomplete_t;
#endif

// FIXME: add class fifostream  for posix compatibility
#ifndef WIN32

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

public:
        fifostream();

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

        virtual ~fifostream();

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

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

// FIXME: add class FIFOSession for posix compatibility
#ifndef WIN32

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

public:
        FIFOSession(const char *session, long access = (long)FILE_ATTR_GROUP, 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 : public Mutex
{
private:
        fileerror_t errid;
        char *errstr;

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

        struct
        {
                unsigned count : 16;
                bool thrown : 1;
                bool initial : 1;
                // FIXME: win32 don't use immediate
                bool immediate : 1;
                bool temp : 1;
        } flags;

        RandomFile();

        RandomFile(const RandomFile &rf);

        fileerror_t Error(fileerror_t errid, char *errstr = NULL);
        
        inline fileerror_t Error(char *errstr)
                {return Error(FILE_EXTENDED_ERROR, errstr);};

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

        // FIXME: add fileerror_t setCompletion(filecomplete_t mode); for posix compatibility
#ifndef WIN32

        fileerror_t setCompletion(filecomplete_t mode);
#endif

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

        virtual fileattr_t Initialize(void)
                {return FILE_ATTR_PUBLIC;};

        void Final(void);

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

        bool Initial(void);

        off_t getCapacity(void);

        virtual fileerror_t Restart(void)
                {return FILE_OPEN_FAILED;};

        inline fileerror_t 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);
        fileerror_t Open(const char *path);

public:
        ThreadFile(const char *path);

        virtual ~ThreadFile();

        fileerror_t Restart(void)
                {return Open(pathname);};

        fileerror_t Fetch(caddr_t address = NULL, ccxx_size_t length = 0, off_t position = -1);

        fileerror_t Update(caddr_t address = NULL, ccxx_size_t length = 0, off_t position = -1);

        fileerror_t 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;
        fileerror_t Open(const char *path);

public:
        SharedFile(const char *path);

        SharedFile(const SharedFile &file);

        virtual ~SharedFile();

        fileerror_t Restart(void)
                {return Open(pathname);};

        fileerror_t Fetch(caddr_t address = NULL, ccxx_size_t length = 0, off_t position = -1);

        fileerror_t Update(caddr_t address = NULL, ccxx_size_t length = 0, off_t position = -1);

        fileerror_t Clear(ccxx_size_t length = 0, off_t pos = -1);

        fileerror_t Append(caddr_t address = NULL, ccxx_size_t length = 0);

        off_t getPosition(void);

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

// FIXME: add MappedFile for posix compatibility
#ifndef WIN32

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

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

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

        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
{
private:
#ifndef WIN32
        int fd[2];
#else
        HANDLE fd[2];
#endif
        int objcount;
        int objsize;

protected:
        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 : -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 : -1; };
#endif

public:
        bool operator!();

#ifndef WIN32
        inline int Recv(void *addr)
                {return ::read(fd[0], (char *)addr, objsize);};
#else
        int Recv(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;
#ifndef WIN32
        void *image;
#else
        char *err;
        HINSTANCE hImage;
#endif
        CCXX_MEMBER_EXPORT(void) loader(const char *filename, bool resolve);
#endif

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

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

#ifndef WIN32
        char *getError(void);
#else
        inline char *getError(void)
                {return err;};
#endif

#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
        friend CCXX_EXPORT(void) dynunload(void);
#else
        friend 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  __NAMESPACES__
};
#endif

#endif

---