filedescriptor.h

// Copyright (c) 1999-2018 David Muse
// See the COPYING file for more information.
 
#ifndef RUDIMENTS_FILEDESCRIPTOR_H
#define RUDIMENTS_FILEDESCRIPTOR_H
 
#include <rudiments/private/filedescriptorincludes.h>
 
class listener;
 
class RUDIMENTS_DLLSPEC filedescriptor : public input, public output {
        public:
                filedescriptor();
 
                virtual ~filedescriptor();
 
                virtual bool    close();
 
                int32_t getFileDescriptor();
 
                void    setFileDescriptor(int32_t filedesc);
 
                bool    setIsStream(bool isstream);
 
                bool    getIsStream();
 
                int32_t duplicate();
 
                bool    duplicate(int32_t newfd);
 
                void    setSocketLayer(socketlayer *layer);
 
                socketlayer     *getSocketLayer();
 
                virtual bool    supportsBlockingAndNonBlockingModes();
 
                virtual bool    setNonBlockingMode(bool usenonblockingmode);
 
                virtual bool    getNonBlockingMode();
 
                virtual off64_t getPosition();
 
                virtual off64_t setPositionRelativeToBeginning(off64_t offset);
 
                virtual off64_t setPositionRelativeToCurrent(off64_t offset);
 
                virtual off64_t setPositionRelativeToEnd(off64_t offset);
 
                ssize_t write(uint16_t number);
 
                ssize_t write(uint32_t number);
 
                ssize_t write(uint64_t number);
 
                ssize_t write(int16_t number);
 
                ssize_t write(int32_t number);
 
                ssize_t write(int64_t number);
 
                ssize_t write(float number);
 
                ssize_t write(double number);
 
                ssize_t write(byte_t character);
 
                ssize_t write(char character);
 
                ssize_t write(wchar_t character);
 
                ssize_t writeUcs2(ucs2_t character);
 
                ssize_t write(bool value);
 
                ssize_t write(const byte_t *string);
 
                ssize_t write(const char *string);
 
                ssize_t write(const wchar_t *string);
 
                ssize_t writeUcs2(const ucs2_t *string);
 
                ssize_t write(const byte_t *string, size_t size);
 
                ssize_t write(const char *string, size_t length);
 
                ssize_t write(const wchar_t *string, size_t length);
 
                ssize_t writeUcs2(const ucs2_t *string, size_t length);
 
                ssize_t write(const void *buffer, size_t size);
 
                ssize_t write(uint16_t number, int32_t sec, int32_t usec);
 
                ssize_t write(uint32_t number, int32_t sec, int32_t usec);
 
                ssize_t write(uint64_t number, int32_t sec, int32_t usec);
 
                ssize_t write(int16_t number, int32_t sec, int32_t usec);
 
                ssize_t write(int32_t number, int32_t sec, int32_t usec);
 
                ssize_t write(int64_t number, int32_t sec, int32_t usec);
 
                ssize_t write(float number, int32_t sec, int32_t usec);
 
                ssize_t write(double number, int32_t sec, int32_t usec);
 
                ssize_t write(byte_t character, int32_t sec, int32_t usec);
 
                ssize_t write(char character, int32_t sec, int32_t usec);
 
                ssize_t write(wchar_t character, int32_t sec, int32_t usec);
 
                ssize_t writeUcs2(ucs2_t character, int32_t sec, int32_t usec);
 
                ssize_t write(bool value, int32_t sec, int32_t usec);
 
                ssize_t write(const byte_t *string, int32_t sec, int32_t usec);
 
                ssize_t write(const char *string,
                                        int32_t sec, int32_t usec);
 
                ssize_t write(const wchar_t *string,
                                        int32_t sec, int32_t usec);
 
                ssize_t writeUcs2(const ucs2_t *string,
                                        int32_t sec, int32_t usec);
 
                ssize_t write(const byte_t *string, size_t size,
                                        int32_t sec, int32_t usec);
 
                ssize_t write(const char *string, size_t length,
                                        int32_t sec, int32_t usec);
 
                ssize_t write(const wchar_t *string, size_t length,
                                        int32_t sec, int32_t usec);
 
                ssize_t writeUcs2(const ucs2_t *string, size_t length,
                                                int32_t sec, int32_t usec);
 
                ssize_t write(const void *buffer, size_t size,
                                        int32_t sec, int32_t usec);
 
                ssize_t read(uint16_t *buffer);
 
                ssize_t read(uint32_t *buffer);
 
                ssize_t read(uint64_t *buffer);
 
                ssize_t read(int16_t *buffer);
 
                ssize_t read(int32_t *buffer);
 
                ssize_t read(int64_t *buffer);
 
                ssize_t read(float *buffer);
 
                ssize_t read(double *buffer);
 
                ssize_t read(byte_t *buffer);
 
                ssize_t read(char *buffer);
 
                ssize_t read(wchar_t *buffer);
 
                ssize_t readUcs2(ucs2_t *buffer);
 
                ssize_t read(bool *buffer);
 
                ssize_t read(byte_t *buffer, size_t size);
 
                ssize_t read(char *buffer, size_t length);
 
                ssize_t read(wchar_t *buffer, size_t length);
 
                ssize_t readUcs2(ucs2_t *buffer, size_t length);
 
                ssize_t read(void *buf, size_t size);
 
                ssize_t read(char **buffer, const char *terminator);
 
                ssize_t read(char **buffer,
                                const char *terminator, size_t maxbytes);
 
                ssize_t read(uint16_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(uint32_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(uint64_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(int16_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(int32_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(int64_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(float *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(double *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(byte_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(char *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(wchar_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t readUcs2(ucs2_t *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(bool *buffer, int32_t sec, int32_t usec);
 
                ssize_t read(byte_t *buffer, size_t size,
                                        int32_t sec, int32_t usec);
 
                ssize_t read(char *buffer, size_t length,
                                        int32_t sec, int32_t usec);
 
                ssize_t read(wchar_t *buffer, size_t length,
                                        int32_t sec, int32_t usec);
 
                ssize_t readUcs2(ucs2_t *buffer, size_t length,
                                        int32_t sec, int32_t usec);
 
                ssize_t read(void *buf, size_t size,
                                        int32_t sec, int32_t usec);
 
                ssize_t read(char **buffer, const char *terminator,
                                        int32_t sec, int32_t usec);
 
                ssize_t read(char **buffer,
                                const char *terminator, size_t maxbytes,
                                int32_t sec, int32_t usec);
 
                ssize_t read(char **buffer,
                                const char *terminator, size_t maxbytes,
                                char escapechar, int32_t sec, int32_t usec);
 
 
                int32_t waitForNonBlockingRead(int32_t sec, int32_t usec);
 
                int32_t waitForNonBlockingWrite(int32_t sec, int32_t usec);
 
 
                void    setRetryInterruptedReads(bool retry);
 
                bool    getRetryInterruptedReads();
 
                void    setRetryInterruptedWrites(bool retry);
 
                bool    getRetryInterruptedWrites();
 
                void    setRetryInterruptedWaits(bool retry);
 
                bool    getRetryInterruptedWaits();
 
                void    setRetryInterruptedFcntl(bool retry);
 
                bool    getRetryInterruptedFcntl();
 
                void    setRetryInterruptedIoctl(bool retry);
 
                bool    getRetryInterruptedIoctl();
 
 
                void    setAllowShortReads(bool allow);
 
                bool    getAllowShortReads();
 
                void    setAllowShortWrites(bool allow);
 
                bool    getAllowShortWrites();
 
 
                virtual bool    passFileDescriptor(int32_t fd);
 
                virtual bool    passFileDescriptor(int32_t fd,
                                                int32_t sec, int32_t usec);
 
                virtual bool    receiveFileDescriptor(int32_t *fd);
 
                virtual bool    receiveFileDescriptor(int32_t *fd,
                                                int32_t sec, int32_t usec);
 
                static bool     supportsPassAndReceiveFileDescriptor();
 
 
                virtual bool    passSocket(int32_t sock);
 
                virtual bool    passSocket(int32_t sock,
                                                int32_t sec, int32_t usec);
 
                virtual bool    receiveSocket(int32_t *sock);
 
                virtual bool    receiveSocket(int32_t *sock,
                                                int32_t sec, int32_t usec);
 
                static bool     supportsPassAndReceiveSocket();
 
 
                void    setTranslateByteOrder(bool translate);
 
                bool    getTranslateByteOrder();
 
                virtual int32_t fCntl(int32_t command, long arg);
 
                virtual int32_t ioCtl(int32_t command, void *arg);
 
                bool    setNaglesAlgorithmEnabled(bool enabled);
 
                bool    getNaglesAlgorithmEnabled();
 
                bool    setSocketWriteBufferSize(int32_t size);
 
                bool    getSocketWriteBufferSize(int32_t *size);
 
                bool    setSocketReadBufferSize(int32_t size);
 
                bool    getSocketReadBufferSize(int32_t *size);
 
                bool    disableIPv4();
 
                bool    enableIPv4();
 
                const char      *getType();
 
                char    *getPeerAddress();
 
 
                bool    setWriteBufferSize(size_t size);
 
                size_t  getWriteBufferSize();
 
                bool    flushWriteBuffer(int32_t sec, int32_t usec);
 
 
                bool    setReadBufferSize(size_t size);
 
                size_t  getReadBufferSize();
 
                void    setMmapBufferingEnabled(bool enabled);
 
                bool    getMmapBufferingEnabled();
 
                bool    isCurrentBlockMmapBuffered();
 
                off64_t getCurrentBlockOffset();
 
                bool    setCloseOnExec(bool close);
 
                bool    getCloseOnExec();
 
                static bool     createPipe(filedescriptor *readfd,
                                                filedescriptor *writefd);
 
                static  uint16_t        convertHostToNet(uint16_t value);
 
                static  uint32_t        convertHostToNet(uint32_t value);
 
                static  uint64_t        convertHostToNet(uint64_t value);
 
                static  uint16_t        convertNetToHost(uint16_t value);
 
                static  uint32_t        convertNetToHost(uint32_t value);
 
                static  uint64_t        convertNetToHost(uint64_t value);
 
                static  uint16_t        convertHostToLittleEndian(
                                                        uint16_t value);
 
                static  uint32_t        convertHostToLittleEndian(
                                                        uint32_t value);
 
                static  uint64_t        convertHostToLittleEndian(
                                                        uint64_t value);
 
                static  uint16_t        convertLittleEndianToHost(
                                                        uint16_t value);
 
                static  uint32_t        convertLittleEndianToHost(
                                                        uint32_t value);
 
                static  uint64_t        convertLittleEndianToHost(
                                                        uint64_t value);
 
        #include <rudiments/private/filedescriptor.h>
};
 
#include <rudiments/private/filedescriptorinlines.h>
 
#endif