Enter your search terms GNU-Darwin Web Submit search form

file.h Go to the documentation of this file. // Copyright (C) 1999-2000 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_THREAD_H__ #include <cc++/thread.h> #else #ifdef __CCXX_NAMESPACE_H__ #include <cc++/macros.h> #endif #endif #include <stdio.h> #include <dirent.h> #include <sys/stat.h> #include <sys/mman.h> #include <iostream.h> #include <fstream.h> typedef unsigned long pos_t; typedef struct _fcb { struct _fcb *next; caddr_t address; size_t len; off_t pos; } fcb_t; 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 typedef enum { 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 } fileattr_t; typedef enum { 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 } fileerror_t; typedef enum { FILE_ACCESS_READONLY = O_RDONLY, FILE_ACCESS_WRITEONLY= O_WRONLY, FILE_ACCESS_READWRITE = O_RDWR } fileaccess_t; #define FILE_MAPPED_READ FILE_ACCESS_READONLY #define FILE_MAPPED_WRITE FILE_ACCESS_WRITEONLY #define FILE_MAPPED_RDWR FILE_ACCESS_READWRITE typedef enum { FILE_COMPLETION_IMMEDIATE, FILE_COMPLETION_DELAYED, FILE_COMPLETION_DEFERRED } filecomplete_t; class fifostream : public fstream { private: char *pathname; public: fifostream(); fifostream(const char *fname, long access = (long)FILE_ATTR_GROUP); ~fifostream(); void open(const char *fname, long access = (long)FILE_ATTR_GROUP); void close(void); }; class FIFOSession : public Thread, public fstream { private: char *pathname; public: FIFOSession(const char *session, long access = (long)FILE_ATTR_GROUP, Semaphore *start = NULL, int pri = 0, int stack = 0); ~FIFOSession(); }; class Dir { private: DIR *dir; public: Dir(const char *name); ~Dir(); char *getName(void); bool operator!() {return !dir;}; bool isValid(void); }; class RandomFile : public Mutex { private: fileerror_t errid; char *errstr; protected: int fd; fileaccess_t access; char *pathname; struct { unsigned count : 16; bool thrown : 1; bool initial : 1; 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;}; fileerror_t setCompletion(filecomplete_t mode); 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 ThreadFile : public RandomFile { private: ThreadKey state; fcb_t *first; fcb_t *getFCB(void); fileerror_t Open(const char *path); public: ThreadFile(const char *path); ~ThreadFile(); fileerror_t Restart(void) {return Open(pathname);}; fileerror_t Fetch(caddr_t address = NULL, size_t length = 0, off_t position = - 1); fileerror_t Update(caddr_t address = NULL, size_t length = 0, off_t position = -1); fileerror_t Append(caddr_t address = NULL, size_t length = 0); off_t getPosition(void); bool operator++(void); bool operator--(void); }; class SharedFile : public RandomFile { private: fcb_t fcb; fileerror_t Open(const char *path); public: SharedFile(const char *path); SharedFile(const SharedFile &file); ~SharedFile(); fileerror_t Restart(void) {return Open(pathname);}; fileerror_t Fetch(caddr_t address = NULL, size_t length = 0, off_t position = - 1); fileerror_t Update(caddr_t address = NULL, size_t length = 0, off_t position = -1); fileerror_t Clear(size_t length = 0, off_t pos = -1); fileerror_t Append(caddr_t address = NULL, size_t length = 0); off_t getPosition(void); bool operator++(void); bool operator--(void); }; class 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); }; class Pipe { private: int fd[2]; int objcount; int objsize; protected: inline int getSize(void) {return objsize;}; inline void endSender(void) {close(fd[1]);}; inline void endReceiver(void) {close(fd[0]);}; Pipe(int size = 512, int count = 1); ~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) {return ::read(fd[0], (char *)buf, len);}; int Write(void *buf, int len) {return ::write(fd[1], (char *)buf, len);}; public: bool operator!(); inline int Recv(void *addr) {return ::read(fd[0], (char *)addr, objsize);}; inline int Send(void *addr) {return ::write(fd[1], (char *)addr, objsize);}; bool isValid(void); }; class DSO { private: #ifdef HAVE_MODULES static Mutex mutex; static DSO *first, *last; DSO *next, *prev; void *image; #endif public: #ifdef HAVE_MODULES DSO(char *filename); #else DSO(char *filename) {throw this;}; #endif char *getError(void); #ifdef HAVE_MODULES ~DSO(); #endif #ifdef HAVE_MODULES void *operator[](const char *); #else void *operator[](const char *) {return NULL;}; #endif #ifdef HAVE_MODULES friend void dynunload(void); #else friend void dynunload(void) {return;}; #endif bool isValid(void); }; bool isDir(const char *path); bool isFile(const char *path); bool isDevice(const char *path); bool canAccess(const char *path); bool canModify(const char *path); #ifdef __CCXX_NAMESPACE_H__ #undef __CCXX_NAMESPACE_H__ #include <cc++/namespace.h> #endif #endif