Csocket.h

Go to the documentation of this file.

/*
 * NOTES ...
 * - You should always compile with -Woverloaded-virtual to detect callbacks that may have been redefined since your last update
 * - If you want to use gethostbyname instead of getaddrinfo, the use -DUSE_GETHOSTBYNAME when compiling
 * - To compile with win32 need to link to winsock2, using gcc its -lws2_32
 * - Code is formated with 'astyle --style=ansi -t4 --unpad-paren --pad-paren-in --keep-one-line-blocks'
 */
#ifndef _HAS_CSOCKET_
#define _HAS_CSOCKET_

#include "defines.h" // require this as a general rule, most projects have a defines.h or the like

#include <stdio.h>
#include <fcntl.h>

#ifndef _WIN32

#include <unistd.h>
#include <sys/time.h>
#include <sys/file.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <netdb.h>
#include <sys/select.h>

#else

#include <io.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <time.h>
#include <sys/timeb.h>

#ifdef _MSC_VER
#define strcasecmp _stricmp
#define suseconds_t long
#endif

#ifndef ECONNREFUSED
// these aliases might or might not be defined in errno.h
// already, depending on the WinSDK version.
#define ECONNREFUSED WSAECONNREFUSED
#define EINPROGRESS WSAEINPROGRESS
#define ETIMEDOUT WSAETIMEDOUT
#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
#define ECONNABORTED WSAECONNABORTED
#define ENETUNREACH WSAENETUNREACH
#endif /* ECONNREFUSED */

#endif /* _WIN32 */

#ifdef HAVE_C_ARES
#include <ares.h>
#endif /* HAVE_C_ARES */

#ifdef HAVE_ICU
# include <unicode/ucnv.h>
#endif

#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>

#ifdef HAVE_LIBSSL
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/rand.h>
#endif /* HAVE_LIBSSL */

#ifdef __sun
#include <strings.h>
#include <fcntl.h>
#endif /* __sun */

#include <vector>
#include <list>
#include <iostream>
#include <sstream>
#include <string>
#include <set>
#include <map>

#ifndef CS_STRING
#       ifdef _HAS_CSTRING_
#               define CS_STRING Cstring
#       else
#               define CS_STRING std::string
#       endif   /* _HAS_CSTRING_ */
#endif /* CS_STRING */

#ifndef CS_DEBUG
#ifdef __DEBUG__
#       define CS_DEBUG( f ) std::cerr << __FILE__ << ":" << __LINE__ << " " << f << std::endl
#else
#       define CS_DEBUG(f)      (void)0
#endif /* __DEBUG__ */
#endif /* CS_DEBUG */

#ifndef CS_EXPORT
#define CS_EXPORT
#endif /* CS_EXPORT */

#ifndef PERROR
#ifdef __DEBUG__
#       define PERROR( f ) __Perror( f, __FILE__, __LINE__ )
#else
#       define PERROR( f )      (void)0
#endif /* __DEBUG__ */
#endif /* PERROR */

#ifdef _WIN32
typedef SOCKET cs_sock_t;
#ifdef _WIN64
typedef signed __int64 cs_ssize_t;
#else
typedef signed int cs_ssize_t;
#endif  /* _WIN64 */
#define CS_INVALID_SOCK INVALID_SOCKET
#else
typedef int cs_sock_t;
typedef ssize_t cs_ssize_t;
#define CS_INVALID_SOCK -1
#endif /* _WIN32 */

/* Assume that everything but windows has Unix sockets */
#ifndef _WIN32
#define HAVE_UNIX_SOCKET
#endif

#ifdef CSOCK_USE_POLL
#include <poll.h>
#endif /* CSOCK_USE_POLL */

#ifdef HAVE_UNIX_SOCKET
#include <sys/un.h>
#endif

#ifndef _NO_CSOCKET_NS // some people may not want to use a namespace
namespace Csocket
{
#endif /* _NO_CSOCKET_NS */


class CS_EXPORT CSCharBuffer
{
public:
        CSCharBuffer( size_t iSize )
        {
                m_pBuffer = ( char * )malloc( iSize );
        }
        ~CSCharBuffer()
        {
                free( m_pBuffer );
        }
        char * operator()() { return( m_pBuffer ); }

private:
        char *  m_pBuffer;
};


class CS_EXPORT CSSockAddr
{
public:
        CSSockAddr()
        {
                m_bIsIPv6 = false;
                memset( ( struct sockaddr_in * ) &m_saddr, '\0', sizeof( m_saddr ) );
#ifdef HAVE_IPV6
                memset( ( struct sockaddr_in6 * ) &m_saddr6, '\0', sizeof( m_saddr6 ) );
#endif /* HAVE_IPV6 */
                m_iAFRequire = RAF_ANY;
        }
        virtual ~CSSockAddr() {}


        enum EAFRequire
        {
            RAF_ANY             = PF_UNSPEC,
#ifdef HAVE_IPV6
            RAF_INET6   = AF_INET6,
#endif /* HAVE_IPV6 */
            RAF_INET    = AF_INET
        };

        void SinFamily();
        void SinPort( uint16_t iPort );
        void SetIPv6( bool b );
        bool GetIPv6() const { return( m_bIsIPv6 ); }

        socklen_t GetSockAddrLen() { return( sizeof( m_saddr ) ); }
        sockaddr_in * GetSockAddr() { return( &m_saddr ); }
        in_addr * GetAddr() { return( &( m_saddr.sin_addr ) ); }
#ifdef HAVE_IPV6
        socklen_t GetSockAddrLen6() { return( sizeof( m_saddr6 ) ); }
        sockaddr_in6 * GetSockAddr6() { return( &m_saddr6 ); }
        in6_addr * GetAddr6() { return( &( m_saddr6.sin6_addr ) ); }
#endif /* HAVE_IPV6 */

        void SetAFRequire( EAFRequire iWhich ) { m_iAFRequire = iWhich; }
        EAFRequire GetAFRequire() const { return( m_iAFRequire ); }

private:
        bool                    m_bIsIPv6;
        sockaddr_in             m_saddr;
#ifdef HAVE_IPV6
        sockaddr_in6    m_saddr6;
#endif /* HAVE_IPV6 */
        EAFRequire              m_iAFRequire;
};


class Csock;


class CS_EXPORT CGetAddrInfo
{
public:
        CGetAddrInfo( const CS_STRING & sHostname, Csock * pSock, CSSockAddr & csSockAddr );
        ~CGetAddrInfo();

        void Init();
        int Process();
        int Finish();

private:
        CS_STRING m_sHostname;
        Csock * m_pSock;
        CSSockAddr & m_csSockAddr;
        struct addrinfo * m_pAddrRes;
        struct addrinfo m_cHints;
        int m_iRet;
};

int CS_GetAddrInfo( const CS_STRING & sHostname, Csock * pSock, CSSockAddr & csSockAddr );

int GetCsockSSLIdx();

#ifdef HAVE_LIBSSL
Csock * GetCsockFromCTX( X509_STORE_CTX * pCTX );
#endif /* HAVE_LIBSSL */


const uint32_t CS_BLOCKSIZE = 4096;
template <class T> inline void CS_Delete( T * & p ) { if( p ) { delete p; p = NULL; } }

#ifdef HAVE_LIBSSL
enum ECompType
{
    CT_NONE     = 0,
    CT_ZLIB     = 1
};

void CSAdjustTVTimeout( struct timeval & tv, long iTimeoutMS );

void SSLErrors( const char *filename, uint32_t iLineNum );

bool InitSSL( ECompType eCompressionType = CT_NONE );

#endif /* HAVE_LIBSSL */

bool InitCsocket();
void ShutdownCsocket();

inline int GetSockError()
{
#ifdef _WIN32
        return( WSAGetLastError() );
#else
        return( errno );
#endif /* _WIN32 */
}

inline void TFD_ZERO( fd_set *set )
{
        FD_ZERO( set );
}

inline void TFD_SET( cs_sock_t iSock, fd_set *set )
{
        FD_SET( iSock, set );
}

inline bool TFD_ISSET( cs_sock_t iSock, fd_set *set )
{
        return( FD_ISSET( iSock, set ) != 0 );
}

inline void TFD_CLR( cs_sock_t iSock, fd_set *set )
{
        FD_CLR( iSock, set );
}

void __Perror( const CS_STRING & s, const char * pszFile, uint32_t iLineNo );


class CS_EXPORT CCron
{
public:
        CCron();
        virtual ~CCron() {}

        void run( timeval & tNow );

        void StartMaxCycles( double dTimeSequence, uint32_t iMaxCycles );
        void StartMaxCycles( const timeval& tTimeSequence, uint32_t iMaxCycles );

        void Start( double dTimeSequence );
        void Start( const timeval& TimeSequence );

        void Stop();

        void Pause();

        void UnPause();

        void Reset();

        timeval GetInterval() const;
        uint32_t GetMaxCycles() const;
        uint32_t GetCyclesLeft() const;

        bool isValid() const;

        const CS_STRING & GetName() const;
        void SetName( const CS_STRING & sName );

        timeval GetNextRun() const { return( m_tTime ); }

public:

        virtual void RunJob();

protected:
        bool            m_bRunOnNextCall; 

private:
        timeval         m_tTime;
        bool            m_bActive, m_bPause;
        timeval         m_tTimeSequence;
        uint32_t                m_iMaxCycles, m_iCycles;
        CS_STRING       m_sName;
};

class CS_EXPORT CSMonitorFD
{
public:
        CSMonitorFD() { m_bEnabled = true; }
        virtual ~CSMonitorFD() {}

        virtual bool GatherFDsForSelect( std::map< cs_sock_t, short > & miiReadyFds, long & iTimeoutMS );

        virtual bool FDsThatTriggered( const std::map< cs_sock_t, short > & miiReadyFds ) { return( true ); }

        virtual bool CheckFDs( const std::map< cs_sock_t, short > & miiReadyFds );

        void Add( cs_sock_t iFD, short iMonitorEvents ) { m_miiMonitorFDs[iFD] = iMonitorEvents; }
        void Remove( cs_sock_t iFD ) { m_miiMonitorFDs.erase( iFD ); }
        void DisableMonitor() { m_bEnabled = false; }

        bool IsEnabled() const { return( m_bEnabled ); }

protected:
        std::map< cs_sock_t, short > m_miiMonitorFDs;
        bool m_bEnabled;
};


class CS_EXPORT CSockCommon
{
public:
        CSockCommon() {}
        virtual ~CSockCommon();

        void CleanupCrons();
        void CleanupFDMonitors();

        const std::vector<CCron *> & GetCrons() const { return( m_vcCrons ); }
        virtual void Cron();

        virtual void AddCron( CCron * pcCron );
        virtual void DelCron( const CS_STRING & sName, bool bDeleteAll = true, bool bCaseSensitive = true );
        virtual void DelCron( uint32_t iPos );
        virtual void DelCronByAddr( CCron * pcCron );

        void CheckFDs( const std::map< cs_sock_t, short > & miiReadyFds );
        void AssignFDs( std::map< cs_sock_t, short > & miiReadyFds, struct timeval * tvtimeout );

        void MonitorFD( CSMonitorFD * pMonitorFD ) { m_vcMonitorFD.push_back( pMonitorFD ); }

protected:
        std::vector<CCron *>            m_vcCrons;
        std::vector<CSMonitorFD *>      m_vcMonitorFD;
};


#ifdef HAVE_LIBSSL
typedef int ( *FPCertVerifyCB )( int, X509_STORE_CTX * );
#endif /* HAVE_LIBSSL */


class CS_EXPORT Csock : public CSockCommon
{
public:
        Csock( int iTimeout = 60 );
        Csock( const CS_STRING & sHostname, uint16_t uPort, int itimeout = 60 );

        virtual Csock *GetSockObj( const CS_STRING & sHostname, uint16_t iPort );

        virtual ~Csock();

        virtual void Dereference();
        virtual void Copy( const Csock & cCopy );

        enum ETConn
        {
            OUTBOUND                    = 0,            
            LISTENER                    = 1,            
            INBOUND                             = 2                     
        };

        enum EFRead
        {
            READ_EOF                    = 0,            
            READ_ERR                    = -1,           
            READ_EAGAIN                 = -2,           
            READ_CONNREFUSED    = -3,           
            READ_TIMEDOUT               = -4            
        };

        enum EFSelect
        {
            SEL_OK                              = 0,            
            SEL_TIMEOUT                 = -1,           
            SEL_EAGAIN                  = -2,           
            SEL_ERR                             = -3            
        };

        enum ESSLMethod
        {
            TLS                                 = 0,
            SSL23                               = TLS,
            SSL2                                = 2,
            SSL3                                = 3,
            TLS1                                = 4,
            TLS11                               = 5,
            TLS12                               = 6
        };

        enum EDisableProtocol
        {
                EDP_None                = 0, 
                EDP_SSLv2               = 1, 
                EDP_SSLv3               = 2, 
                EDP_TLSv1               = 4, 
                EDP_TLSv1_1             = 8, 
                EDP_TLSv1_2             = 16, 
                EDP_SSL                 = (EDP_SSLv2|EDP_SSLv3)
        };

        enum ECONState
        {
            CST_START           = 0,
            CST_DNS                     = CST_START,
            CST_BINDVHOST       = 1,
            CST_DESTDNS         = 2,
            CST_CONNECT         = 3,
            CST_CONNECTSSL      = 4,
            CST_OK                      = 5
        };

        enum ECloseType
        {
            CLT_DONT                    = 0, 
            CLT_NOW                             = 1, 
            CLT_AFTERWRITE              = 2, 
            CLT_DEREFERENCE             = 3      
        };

        Csock & operator<<( const CS_STRING & s );
        Csock & operator<<( std::ostream & ( *io )( std::ostream & ) );
        Csock & operator<<( int32_t i );
        Csock & operator<<( uint32_t i );
        Csock & operator<<( int64_t i );
        Csock & operator<<( uint64_t i );
        Csock & operator<<( float i );
        Csock & operator<<( double i );

        virtual bool Connect();

#ifdef HAVE_UNIX_SOCKET

        virtual bool ConnectUnix( const CS_STRING & sPath );

        virtual bool ListenUnix( const CS_STRING & sBindFile, int iMaxConns = SOMAXCONN, uint32_t iTimeout = 0 );
#endif

        virtual bool Listen( uint16_t iPort, int iMaxConns = SOMAXCONN, const CS_STRING & sBindHost = "", uint32_t iTimeout = 0, bool bDetach = false );

        virtual cs_sock_t Accept( CS_STRING & sHost, uint16_t & iRPort );

        virtual bool AcceptSSL();

        virtual bool SSLClientSetup();

        virtual bool SSLServerSetup();

        virtual bool ConnectSSL();

        bool StartTLS();

        virtual bool Write( const char *data, size_t len );

        virtual bool Write( const CS_STRING & sData );

        virtual cs_ssize_t Read( char *data, size_t len );
        CS_STRING GetLocalIP() const;
        CS_STRING GetRemoteIP() const;

        virtual bool IsConnected() const;
        virtual void SetIsConnected( bool b );

        cs_sock_t & GetRSock();
        const cs_sock_t & GetRSock() const;
        void SetRSock( cs_sock_t iSock );
        cs_sock_t & GetWSock();
        const cs_sock_t & GetWSock() const;
        void SetWSock( cs_sock_t iSock );

        void SetSock( cs_sock_t iSock );
        cs_sock_t & GetSock();
        const cs_sock_t & GetSock() const;

        void CallSockError( int iErrno, const CS_STRING & sDescription = "" );
        virtual void ResetTimer();

        void PauseRead();
        void UnPauseRead();
        bool IsReadPaused() const;
        enum
        {
            TMO_READ    = 1,
            TMO_WRITE   = 2,
            TMO_ACCEPT  = 4,
            TMO_ALL             = TMO_READ|TMO_WRITE|TMO_ACCEPT
        };

        void SetTimeout( int iTimeout, uint32_t iTimeoutType = TMO_ALL );
        void SetTimeoutType( uint32_t iTimeoutType );
        int GetTimeout() const;
        uint32_t GetTimeoutType() const;

        virtual bool CheckTimeout( time_t iNow );

        virtual void PushBuff( const char *data, size_t len, bool bStartAtZero = false );

        CS_STRING & GetInternalReadBuffer();

        CS_STRING & GetInternalWriteBuffer();

        void SetMaxBufferThreshold( uint32_t iThreshold );
        uint32_t GetMaxBufferThreshold() const;

        int GetType() const;
        void SetType( int iType );

        const CS_STRING & GetSockName() const;
        void SetSockName( const CS_STRING & sName );

        const CS_STRING & GetHostName() const;
        void SetHostName( const CS_STRING & sHostname );


        uint64_t GetStartTime() const;
        void ResetStartTime();

        uint64_t GetBytesRead() const;
        void ResetBytesRead();

        uint64_t GetBytesWritten() const;
        void ResetBytesWritten();

        double GetAvgRead( uint64_t iSample = 1000 ) const;

        double GetAvgWrite( uint64_t iSample = 1000 ) const;

        uint16_t GetRemotePort() const;

        uint16_t GetLocalPort() const;

        uint16_t GetPort() const;
        void SetPort( uint16_t iPort );

        void Close( ECloseType eCloseType = CLT_NOW );
        ECloseType GetCloseType() const { return( m_eCloseType ); }
        bool IsClosed() const { return( GetCloseType() != CLT_DONT ); }

        void NonBlockingIO();

        bool GetSSL() const;
        void SetSSL( bool b );

#ifdef HAVE_LIBSSL
        void DisableSSLProtocols( u_int uDisableOpts ) { m_uDisableProtocols = uDisableOpts; }
        void DisableSSLCompression() { m_bNoSSLCompression = true; }
        void FollowSSLCipherServerPreference() { m_bSSLCipherServerPreference = true; }
        void SetCipher( const CS_STRING & sCipher );
        const CS_STRING & GetCipher() const;

        void SetDHParamLocation( const CS_STRING & sDHParamFile );
        const CS_STRING & GetDHParamLocation() const;
        void SetKeyLocation( const CS_STRING & sKeyFile );
        const CS_STRING & GetKeyLocation() const;
        void SetPemLocation( const CS_STRING & sPemFile );
        const CS_STRING & GetPemLocation() const;
        void SetPemPass( const CS_STRING & sPassword );
        const CS_STRING & GetPemPass() const;

        void SetSSLMethod( int iMethod );
        int GetSSLMethod() const;

        void SetSSLObject( SSL *ssl, bool bDeleteExisting = false );
        SSL * GetSSLObject() const;
        void SetCTXObject( SSL_CTX *sslCtx, bool bDeleteExisting = false );
        SSL_SESSION * GetSSLSession() const;

        void SetCertVerifyCB( FPCertVerifyCB pFP ) { m_pCerVerifyCB = pFP; }
#endif /* HAVE_LIBSSL */

        bool HasWriteBuffer() const;
        void ClearWriteBuffer();

        bool SslIsEstablished() const;

        bool ConnectInetd( bool bIsSSL = false, const CS_STRING & sHostname = "" );

        bool ConnectFD( int iReadFD, int iWriteFD, const CS_STRING & sName, bool bIsSSL = false, ETConn eDirection = INBOUND );

#ifdef HAVE_LIBSSL
        X509 *GetX509() const;

        CS_STRING GetPeerPubKey() const;
        long GetPeerFingerprint( CS_STRING & sFP ) const;

        uint32_t GetRequireClientCertFlags() const;
        void SetRequiresClientCert( bool bRequiresCert );
        void SetRequireClientCertFlags( uint32_t iRequireClientCertFlags ) { m_iRequireClientCertFlags = iRequireClientCertFlags; }
#endif /* HAVE_LIBSSL */

        virtual void SetParentSockName( const CS_STRING & sParentName );
        const CS_STRING & GetParentSockName() const;

        virtual void SetRate( uint32_t iBytes, uint64_t iMilliseconds );

        uint32_t GetRateBytes() const;
        uint64_t GetRateTime() const;

        virtual void Connected() {}
        virtual void Disconnected() {}
        virtual void Timeout() {}
        virtual void ReadData( const char *data, size_t len ) {}
        virtual void ReadLine( const CS_STRING & sLine ) {}
        void EnableReadLine();
        void DisableReadLine();
        bool HasReadLine() const { return( m_bEnableReadLine ); }

        virtual void ReachedMaxBuffer();
        virtual void SockError( int iErrno, const CS_STRING & sDescription ) {}
        virtual bool ConnectionFrom( const CS_STRING & sHost, uint16_t iPort ) { return( true ); }

        virtual void Listening( const CS_STRING & sBindIP, uint16_t uPort ) {}

        virtual void ConnectionRefused() {}
        virtual void ReadPaused() {}

#ifdef HAVE_LIBSSL

        virtual void SSLFinishSetup( SSL * pSSL ) {}
        virtual bool SNIConfigureServer( const CS_STRING & sHostname, CS_STRING & sPemFile, CS_STRING & sPemPass ) { return( false ); }
        virtual bool SNIConfigureClient( CS_STRING & sHostname );
        SSL_CTX * SetupServerCTX();

        virtual void SSLHandShakeFinished() {}
        virtual int VerifyPeerCertificate( int iPreVerify, X509_STORE_CTX * pStoreCTX ) { return( 1 ); }
#endif /* HAVE_LIBSSL */


        time_t GetTimeSinceLastDataTransaction( time_t iNow = 0 ) const;

        time_t GetLastCheckTimeout() const { return( m_iLastCheckTimeoutTime ); }

        time_t GetNextCheckTimeout( time_t iNow = 0 ) const;

        virtual int GetPending() const;

        // Connection State Stuff
        ECONState GetConState() const { return( m_eConState ); }
        void SetConState( ECONState eState ) { m_eConState = eState; }

        bool CreateSocksFD();

        void CloseSocksFD();

        const CS_STRING & GetBindHost() const { return( m_sBindHost ); }
        void SetBindHost( const CS_STRING & sBindHost ) { m_sBindHost = sBindHost; }

        enum EDNSLType
        {
            DNS_VHOST, 
            DNS_DEST 
        };

        int DNSLookup( EDNSLType eDNSLType );

        bool SetupVHost();

        bool GetIPv6() const { return( m_bIsIPv6 ); }
        void SetIPv6( bool b )
        {
                m_bIsIPv6 = b;
                m_address.SetIPv6( b );
                m_bindhost.SetIPv6( b );
        }

        void SetAFRequire( CSSockAddr::EAFRequire iAFRequire )
        {
                m_address.SetAFRequire( iAFRequire );
                m_bindhost.SetAFRequire( iAFRequire );
        }

        bool AllowWrite( uint64_t & iNOW ) const;


        void SetSkipConnect( bool b ) { m_bSkipConnect = b; }

        virtual int GetAddrInfo( const CS_STRING & sHostname, CSSockAddr & csSockAddr );

        virtual int ConvertAddress( const struct sockaddr_storage * pAddr, socklen_t iAddrLen, CS_STRING & sIP, uint16_t * piPort ) const;

#ifdef HAVE_C_ARES
        CSSockAddr * GetCurrentAddr() const { return( m_pCurrAddr ); }
        void SetAresFinished( int status ) { m_pCurrAddr = NULL; m_iARESStatus = status; }
        ares_channel GetAresChannel() const { return( m_pARESChannel ); }
#endif /* HAVE_C_ARES */

        int GetMaxConns() const { return( m_iMaxConns ); }

#ifdef HAVE_ICU
        void SetEncoding( const CS_STRING & sEncoding );
        CS_STRING GetEncoding() const { return m_sEncoding; }
        virtual void IcuExtToUCallback(
                UConverterToUnicodeArgs* toArgs,
                const char* codeUnits,
                int32_t length,
                UConverterCallbackReason reason,
                UErrorCode* err );
        virtual void IcuExtFromUCallback(
                UConverterFromUnicodeArgs* fromArgs,
                const UChar* codeUnits,
                int32_t length,
                UChar32 codePoint,
                UConverterCallbackReason reason,
                UErrorCode* err );
#endif /* HAVE_ICU */

private:
        Csock( const Csock & cCopy ) : CSockCommon() {}
        void ShrinkSendBuff();
        void IncBuffPos( size_t uBytes );

        // NOTE! if you add any new members, be sure to add them to Copy()
        uint16_t        m_uPort;
        cs_sock_t       m_iReadSock, m_iWriteSock;
        int             m_iTimeout, m_iConnType, m_iMethod, m_iTcount, m_iMaxConns;
        bool            m_bUseSSL, m_bIsConnected;
        bool            m_bsslEstablished, m_bEnableReadLine, m_bPauseRead;
        CS_STRING       m_shostname, m_sbuffer, m_sSockName, m_sDHParamFile, m_sKeyFile, m_sPemFile, m_sCipherType, m_sParentName;
        CS_STRING       m_sSend, m_sPemPass;
        ECloseType      m_eCloseType;

        // initialized lazily
        mutable uint16_t        m_iRemotePort, m_iLocalPort;
        mutable CS_STRING       m_sLocalIP, m_sRemoteIP;

        uint64_t        m_iMaxMilliSeconds, m_iLastSendTime, m_iBytesRead, m_iBytesWritten, m_iStartTime;
        uint32_t        m_iMaxBytes, m_iMaxStoredBufferLength, m_iTimeoutType;
        size_t          m_iLastSend, m_uSendBufferPos;

        CSSockAddr      m_address, m_bindhost;
        bool            m_bIsIPv6, m_bSkipConnect;
        time_t          m_iLastCheckTimeoutTime;

#ifdef HAVE_LIBSSL
        CS_STRING       m_sSSLBuffer;
        SSL     *               m_ssl;
        SSL_CTX *       m_ssl_ctx;
        uint32_t        m_iRequireClientCertFlags;
        u_int           m_uDisableProtocols;
        bool            m_bNoSSLCompression;
        bool            m_bSSLCipherServerPreference;

        FPCertVerifyCB          m_pCerVerifyCB;

        void FREE_SSL();
        void FREE_CTX();
        bool ConfigureCTXOptions( SSL_CTX * pCTX );

#endif /* HAVE_LIBSSL */

        cs_sock_t CreateSocket( bool bListen = false, bool bUnix = false );
        void Init( const CS_STRING & sHostname, uint16_t uPort, int iTimeout = 60 );

        // Connection State Info
        ECONState               m_eConState;
        CS_STRING               m_sBindHost;
        uint32_t                m_iCurBindCount, m_iDNSTryCount;
#ifdef HAVE_C_ARES
        void FreeAres();
        ares_channel    m_pARESChannel;
        CSSockAddr      *       m_pCurrAddr;
        int                             m_iARESStatus;
#endif /* HAVE_C_ARES */

#ifdef HAVE_ICU
        UConverter* m_cnvInt;
        UConverter* m_cnvExt;
        bool m_cnvTryUTF8;
        bool m_cnvSendUTF8;
        CS_STRING m_sEncoding;
#endif
};

class CS_EXPORT CSConnection
{
public:
        CSConnection( const CS_STRING & sHostname, uint16_t iPort, int iTimeout = 60 )
        {
                m_sHostname = sHostname;
                m_iPort = iPort;
                m_iTimeout = iTimeout;
                m_bIsSSL = false;
#ifdef HAVE_LIBSSL
                m_sCipher = "HIGH";
#endif /* HAVE_LIBSSL */
                m_iAFrequire = CSSockAddr::RAF_ANY;
        }
        virtual ~CSConnection() {}

        const CS_STRING & GetHostname() const { return( m_sHostname ); }
        const CS_STRING & GetSockName() const { return( m_sSockName ); }
        const CS_STRING & GetBindHost() const { return( m_sBindHost ); }
        uint16_t GetPort() const { return( m_iPort ); }
        int GetTimeout() const { return( m_iTimeout ); }
        bool GetIsSSL() const { return( m_bIsSSL ); }
        CSSockAddr::EAFRequire GetAFRequire() const { return( m_iAFrequire ); }

#ifdef HAVE_LIBSSL
        const CS_STRING & GetCipher() const { return( m_sCipher ); }
        const CS_STRING & GetPemLocation() const { return( m_sPemLocation ); }
        const CS_STRING & GetKeyLocation() const { return( m_sKeyLocation ); }
        const CS_STRING & GetDHParamLocation() const { return( m_sDHParamLocation ); }
        const CS_STRING & GetPemPass() const { return( m_sPemPass ); }
#endif /* HAVE_LIBSSL */

        void SetHostname( const CS_STRING & s ) { m_sHostname = s; }
        void SetSockName( const CS_STRING & s ) { m_sSockName = s; }
        void SetBindHost( const CS_STRING & s ) { m_sBindHost = s; }
        void SetPort( uint16_t i ) { m_iPort = i; }
        void SetTimeout( int i ) { m_iTimeout = i; }
        void SetIsSSL( bool b ) { m_bIsSSL = b; }
        void SetAFRequire( CSSockAddr::EAFRequire iAFRequire ) { m_iAFrequire = iAFRequire; }

#ifdef HAVE_LIBSSL
        void SetCipher( const CS_STRING & s ) { m_sCipher = s; }
        void SetPemLocation( const CS_STRING & s ) { m_sPemLocation = s; }
        void SetPemPass( const CS_STRING & s ) { m_sPemPass = s; }
#endif /* HAVE_LIBSSL */

protected:
        CS_STRING       m_sHostname, m_sSockName, m_sBindHost;
        uint16_t        m_iPort;
        int                     m_iTimeout;
        bool            m_bIsSSL;
        CSSockAddr::EAFRequire  m_iAFrequire;
#ifdef HAVE_LIBSSL
        CS_STRING       m_sDHParamLocation, m_sKeyLocation, m_sPemLocation, m_sPemPass, m_sCipher;
#endif /* HAVE_LIBSSL */
};

class CS_EXPORT CSSSLConnection : public CSConnection
{
public:
        CSSSLConnection( const CS_STRING & sHostname, uint16_t iPort, int iTimeout = 60 ) :
                CSConnection( sHostname, iPort, iTimeout )
        {
                SetIsSSL( true );
        }
};


class CS_EXPORT CSListener
{
public:
        CSListener( uint16_t iPort, const CS_STRING & sBindHost = "", bool bDetach = false )
        {
                m_iPort = iPort;
                m_sBindHost = sBindHost;
                m_bIsSSL = false;
                m_iMaxConns = SOMAXCONN;
                m_iTimeout = 0;
                m_iAFrequire = CSSockAddr::RAF_ANY;
                m_bDetach = bDetach;
#ifdef HAVE_LIBSSL
                m_sCipher = "HIGH";
                m_iRequireCertFlags = 0;
#endif /* HAVE_LIBSSL */
        }
        virtual ~CSListener() {}

        void SetDetach( bool b ) { m_bDetach = b; }
        bool GetDetach() const { return( m_bDetach ); }
        uint16_t GetPort() const { return( m_iPort ); }
        const CS_STRING & GetSockName() const { return( m_sSockName ); }
        const CS_STRING & GetBindHost() const { return( m_sBindHost ); }
        bool GetIsSSL() const { return( m_bIsSSL ); }
        int GetMaxConns() const { return( m_iMaxConns ); }
        uint32_t GetTimeout() const { return( m_iTimeout ); }
        CSSockAddr::EAFRequire GetAFRequire() const { return( m_iAFrequire ); }
#ifdef HAVE_LIBSSL
        const CS_STRING & GetCipher() const { return( m_sCipher ); }
        const CS_STRING & GetDHParamLocation() const { return( m_sDHParamLocation ); }
        const CS_STRING & GetKeyLocation() const { return( m_sKeyLocation ); }
        const CS_STRING & GetPemLocation() const { return( m_sPemLocation ); }
        const CS_STRING & GetPemPass() const { return( m_sPemPass ); }
        uint32_t GetRequireClientCertFlags() const { return( m_iRequireCertFlags ); }
#endif /* HAVE_LIBSSL */

        void SetPort( uint16_t iPort ) { m_iPort = iPort; }
        void SetSockName( const CS_STRING & sSockName ) { m_sSockName = sSockName; }
        void SetBindHost( const CS_STRING & sBindHost ) { m_sBindHost = sBindHost; }
        void SetIsSSL( bool b ) { m_bIsSSL = b; }
        void SetMaxConns( int i ) { m_iMaxConns = i; }
        void SetTimeout( uint32_t i ) { m_iTimeout = i; }
        void SetAFRequire( CSSockAddr::EAFRequire iAFRequire ) { m_iAFrequire = iAFRequire; }

#ifdef HAVE_LIBSSL
        void SetCipher( const CS_STRING & s ) { m_sCipher = s; }
        void SetPemLocation( const CS_STRING & s ) { m_sPemLocation = s; }
        void SetKeyLocation( const CS_STRING & s ) { m_sKeyLocation = s; }
        void SetDHParamLocation( const CS_STRING & s ) { m_sDHParamLocation = s; }
        void SetPemPass( const CS_STRING & s ) { m_sPemPass = s; }
        void SetRequiresClientCert( bool b ) { m_iRequireCertFlags = ( b ? SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT : 0 ); }
        void SetRequireClientCertFlags( unsigned int iRequireCertFlags ) { m_iRequireCertFlags = iRequireCertFlags; }
#endif /* HAVE_LIBSSL */
private:
        uint16_t        m_iPort;
        CS_STRING       m_sSockName, m_sBindHost;
        bool            m_bIsSSL;
        bool            m_bDetach;
        int                     m_iMaxConns;
        uint32_t        m_iTimeout;
        CSSockAddr::EAFRequire  m_iAFrequire;

#ifdef HAVE_LIBSSL
        CS_STRING       m_sDHParamLocation, m_sKeyLocation, m_sPemLocation, m_sPemPass, m_sCipher;
        uint32_t                m_iRequireCertFlags;
#endif /* HAVE_LIBSSL */
};

#ifdef HAVE_LIBSSL
class CSSSListener : public CSListener
{
public:
        CSSSListener( uint16_t iPort, const CS_STRING & sBindHost = "" ) :
                CSListener( iPort, sBindHost )
        {
                SetIsSSL( true );
        }
};
#endif /* HAVE_LIBSSL */

class CS_EXPORT CSocketManager : public std::vector<Csock *>, public CSockCommon
{
public:
        CSocketManager();
        virtual ~CSocketManager();
        virtual void clear();
        virtual void Cleanup();

        virtual Csock * GetSockObj( const CS_STRING & sHostname, uint16_t uPort, int iTimeout = 60 );

        enum EMessages
        {
            SUCCESS                     = 0,    
            SELECT_ERROR        = -1,   
            SELECT_TIMEOUT      = -2,   
            SELECT_TRYAGAIN     = -3    
        };

        void Connect( const CSConnection & cCon, Csock * pcSock = NULL );

        virtual bool Listen( const CSListener & cListen, Csock * pcSock = NULL, uint16_t * piRandPort = NULL );


        bool HasFDs() const;

        virtual void Loop();

        void DynamicSelectLoop( uint64_t iLowerBounds, uint64_t iUpperBounds, time_t iMaxResolution = 3600 );

        virtual void AddSock( Csock * pcSock, const CS_STRING & sSockName );

        virtual Csock * FindSockByRemotePort( uint16_t iPort );

        virtual Csock * FindSockByLocalPort( uint16_t iPort );

        virtual Csock * FindSockByName( const CS_STRING & sName );

        virtual Csock * FindSockByFD( cs_sock_t iFD );

        virtual std::vector<Csock *> FindSocksByName( const CS_STRING & sName );

        virtual std::vector<Csock *> FindSocksByRemoteHost( const CS_STRING & sHostname );

        int GetErrno() const { return( m_errno ); }

        uint64_t GetSelectTimeout() const { return( m_iSelectWait ); }
        void  SetSelectTimeout( uint64_t iTimeout ) { m_iSelectWait = iTimeout; }

        virtual void DelSockByAddr( Csock * pcSock );

        virtual void DelSock( size_t iPos );

        virtual bool SwapSockByIdx( Csock * pNewSock, size_t iOrginalSockIdx );

        virtual bool SwapSockByAddr( Csock * pNewSock, Csock * pOrigSock );

        uint64_t GetBytesRead() const;

        uint64_t GetBytesWritten() const;

        enum ECheckType
        {
            ECT_Read = 1,
            ECT_Write = 2
        };

        void FDSetCheck( cs_sock_t iFd, std::map< cs_sock_t, short > & miiReadyFds, ECheckType eType );
        bool FDHasCheck( cs_sock_t iFd, std::map< cs_sock_t, short > & miiReadyFds, ECheckType eType );

protected:

        virtual int Select( std::map< cs_sock_t, short > & miiReadyFds, struct timeval *tvtimeout );

private:
        void Select( std::map<Csock *, EMessages> & mpeSocks );

        timeval GetDynamicSleepTime( const timeval& tNow, const timeval& tMaxResolution ) const;

        virtual void SelectSock( std::map<Csock *, EMessages> & mpeSocks, EMessages eErrno, Csock * pcSock );

        // Connection State Functions

        // members
        EMessages               m_errno;
        uint64_t                m_iCallTimeouts;
        uint64_t                m_iBytesRead;
        uint64_t                m_iBytesWritten;
        uint64_t                m_iSelectWait;
};


template<class T>
class TSocketManager : public CSocketManager
{
public:
        TSocketManager() : CSocketManager() {}
        virtual ~TSocketManager() {}
        virtual T * GetSockObj( const CS_STRING & sHostname, uint16_t uPort, int iTimeout = 60 )
        {
                return( new T( sHostname, uPort, iTimeout ) );
        }
};

#ifndef _NO_CSOCKET_NS
}
#endif /* _NO_CSOCKET_NS */

#endif /* _HAS_CSOCKET_ */