vsocket.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vsocket_h
#define vsocket_h

#include "vinstant.h"
#include "vstring.h"

// This pulls in any platform-specific declarations and includes:
#include "vsocket_platform.h"

typedef Vu32 VNetAddr;    

class VNetworkInterfaceInfo {
    public:
        VNetworkInterfaceInfo() : mFamily(0), mName(), mAddress() {}
        ~VNetworkInterfaceInfo() {}
        int mFamily;        
        VString mName;      
        VString mAddress;   
};
typedef std::vector<VNetworkInterfaceInfo> VNetworkInterfaceList;

class VSocketConnectionStrategy;

class VSocket {
    public:

        static void setPreferredNetworkInterface(const VString& interfaceName);
        static void setPreferredLocalIPAddressPrefix(const VString& addressPrefix);
        static void getLocalHostIPAddress(VString& ipAddress, bool refresh = false);
        static VNetworkInterfaceList enumerateNetworkInterfaces() { return VSocket::_platform_enumerateNetworkInterfaces(); }
        static VNetAddr ipAddressStringToNetAddr(const VString& ipAddress);
        static void netAddrToIPAddressString(VNetAddr netAddr, VString& ipAddress);
        static VStringVector resolveHostName(const VString& hostName);
        static bool isIPv4NumericString(const VString& ipAddress);
        static bool isIPv6NumericString(const VString& ipAddress);
        static bool isIPNumericString(const VString& ipAddress);

        VSocket();
        VSocket(VSocketID id);
        virtual ~VSocket();

        virtual void connectToIPAddress(const VString& ipAddress, int portNumber);
        virtual void connectToHostName(const VString& hostName, int portNumber);
        virtual void connectToHostName(const VString& hostName, int portNumber, const VSocketConnectionStrategy& connectionStrategy);

        void setSockID(VSocketID id);
        virtual void setHostIPAddressAndPort(const VString& hostIPAddress, int portNumber);

        // --------------- These are the various utility and accessor methods.

        VSocketID getSockID() const;
        VString getHostIPAddress() const;
        int getPortNumber() const;
        const VString& getName() const { return mSocketName; }
        void close();
        void setLinger(int val);
        void clearReadTimeOut();
        void setReadTimeOut(const struct timeval& timeout);
        void clearWriteTimeOut();
        void setWriteTimeOut(const struct timeval& timeout);
        void setDefaultSockOpt();
        Vs64 numBytesRead() const;
        Vs64 numBytesWritten() const;
        VDuration getIdleTime() const;

        // --------------- These are the pure virtual methods that only a platform
        // subclass can implement.

        virtual int available() { return this->_platform_available(); }
        virtual int read(Vu8* buffer, int numBytesToRead);
        virtual int write(const Vu8* buffer, int numBytesToWrite);
        virtual void flush();
        virtual void discoverHostAndPort();
        virtual void closeRead();
        virtual void closeWrite();
        virtual void setSockOpt(int level, int name, void* valuePtr, int valueLength);
        void setIntSockOpt(int level, int name, int value);

        static const VSocketID kNoSocketID = V_NO_SOCKET_ID_CONSTANT; 
        static const int kDefaultBufferSize = 65535;    
        static const int kDefaultServiceType = 0x08;    
        static const int kDefaultNoDelay = 1;           

    protected:

        virtual void _connectToIPAddress(const VString& ipAddress, int portNumber);
        virtual void _listen(const VString& bindAddress, int backlog);

        VSocketID       mSocketID;              
        VString         mHostIPAddress;         
        int             mPortNumber;            
        bool            mReadTimeOutActive;     
        struct timeval  mReadTimeOut;           
        bool            mWriteTimeOutActive;    
        struct timeval  mWriteTimeOut;          
        bool            mRequireReadAll;        
        Vs64            mNumBytesRead;          
        Vs64            mNumBytesWritten;       
        VInstant        mLastEventTime;         
        VString         mSocketName;            

        static VString gPreferredNetworkInterfaceName;
        static VString gPreferredLocalIPAddressPrefix;
        static VString gCachedLocalHostIPAddress;

    protected: // will be private when complete

        static bool gStaticInited;          
        static bool _platform_staticInit(); 
    
        static VNetworkInterfaceList _platform_enumerateNetworkInterfaces();
        static VString _platform_addrinfoToIPAddressString(const VString& hostName, const struct addrinfo* info);
        static bool _platform_isSocketIDValid(VSocketID socketID);
        int _platform_available();
};

class VSocketInfo {
    public:

        VSocketInfo(const VSocket& socket);
        virtual ~VSocketInfo() {}

        VSocketID   mSocketID;          
        VString     mHostIPAddress;     
        int         mPortNumber;        
        Vs64        mNumBytesRead;      
        Vs64        mNumBytesWritten;   
        VDuration   mIdleTime;          
};

typedef std::vector<VSocketInfo> VSocketInfoVector;

class VSocketConnectionStrategy {

    public:
        VSocketConnectionStrategy() : mDebugIPAddresses() {}
        virtual ~VSocketConnectionStrategy() {}

        virtual void connect(const VString& hostName, int portNumber, VSocket& socketToConnect) const = 0;

        // For testing purposes, you can inject a specific set of IP addresses, which
        // will cause the hostName supplied with connect() to be ignored. You could supply
        // specific bad IP addresses or slow-to-succeed IP addresses, in order to see
        // what happens. Our unit tests do this.
        void injectDebugIPAddresses(const VStringVector debugIPAddresses) { mDebugIPAddresses = debugIPAddresses; }

    protected:

        VStringVector mDebugIPAddresses; 
};

class VSocketConnectionStrategySingle : public VSocketConnectionStrategy {

    public:
        VSocketConnectionStrategySingle() {}
        virtual ~VSocketConnectionStrategySingle() {}

        // VSocketConnectionStrategy implementation:
        virtual void connect(const VString& hostName, int portNumber, VSocket& socketToConnect) const;
};

class VSocketConnectionStrategyLinear : public VSocketConnectionStrategy {

    public:
        VSocketConnectionStrategyLinear(const VDuration& timeout);
        virtual ~VSocketConnectionStrategyLinear() {}

        // VSocketConnectionStrategy implementation:
        virtual void connect(const VString& hostName, int portNumber, VSocket& socketToConnect) const;

    private:
        const VDuration mTimeout;
};

class VSocketConnectionStrategyThreaded : public VSocketConnectionStrategy {

    public:
        VSocketConnectionStrategyThreaded(const VDuration& timeoutInterval, int maxNumThreads = 4);
        virtual ~VSocketConnectionStrategyThreaded() {}

        // VSocketConnectionStrategy implementation:
        virtual void connect(const VString& hostName, int portNumber, VSocket& socketToConnect) const;

    private:

        VDuration   mTimeoutInterval;
        int         mMaxNumThreads;
};

#endif /* vsocket_h */