D:/Zythum/DinoKod/Network/Socket.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : Socket.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 09/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Error.h"
#include "Common/Console.h"
#include "Common/Lzw.h"
#include "Network/InetAddr.h"
#include "Network/Socket.h"

//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
KSocket::KSocket()
{
        m_hSocket                       = INVALID_SOCKET;
        m_bConnected            = false;
        m_nBytesSent            = 0;
        m_nBytesReceived        = 0;
        m_nRealBytesSent        = 0;
        m_nRealBytesReceived= 0;
        m_bCompress                     = false;
        m_bAttached                     = false;
}

//---------------------------------------------------------------------------------------------------------------------
KSocket::~KSocket()
{
        if( m_hSocket != INVALID_SOCKET )
        {
                Close();
        }
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Create( KNSOCKETTYPE Type )
{
        switch( Type )
        {
        case KNST_TCP:
                m_hSocket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
                break;
        case KNST_UDP:
                m_hSocket = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
                break;
        default:
                KError::FatalError( NULL, " KSocket::Create(...) : Unknown socket type %i", Type );
                return false;
        }

        if( m_hSocket == INVALID_SOCKET )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Create(...) : Cannot create socket"  );
                return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Close()
{
        if( !m_bAttached )
        {
                if( closesocket( m_hSocket ) == SOCKET_ERROR )
                {
                        KError::FatalError( NULL, GetLastError(), "KSocket::Close(...) : Cannot close socket"  );
                        return false;
                }
        }

        Detach();

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Attach( SOCKET hSocket )
{
        if( m_hSocket != INVALID_SOCKET )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Attach(...) : Socket already attached"  );
                return false;
        }

        m_hSocket = hSocket;

        m_bAttached = true;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Detach()
{
        if( m_hSocket == INVALID_SOCKET )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Detach(...) : Socket already detached"  );
                return false;
        }

        m_hSocket = INVALID_SOCKET;

        m_bAttached = false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Bind( KInetAddr& Addr )
{
        sockaddr_in     in;
        
        in.sin_port             = htons(Addr.GetPort());
        in.sin_addr             = Addr.GetInAddr();
        in.sin_family   = AF_INET;

        if( bind( m_hSocket, (const sockaddr*)&in, sizeof( in ) ) == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Bind() : bind failed"  );
                return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::SelectRead()
{
        fd_set  fdset;
        
        FD_ZERO( &fdset );
        FD_SET( m_hSocket, &fdset );
        
        timeval tv;
        tv.tv_sec       = 0;
        tv.tv_usec      = 0;

        // Test for message received.
        int res = select( (int)m_hSocket + 1, &fdset, NULL, NULL, &tv );
        switch ( res  )
        {
                case  0:
                        return false;
                case -1:
                        KError::FatalError( NULL, GetLastError(), "KSocket::SelectRead(...) : select failed"  );
                        return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::SelectWrite()
{
        fd_set  fdset;
        
        FD_ZERO( &fdset );
        FD_SET( m_hSocket, &fdset );
        
        timeval tv;
        tv.tv_sec       = 0;
        tv.tv_usec      = 0;

        // Test for message received.
        int res = select( (int)m_hSocket + 1, NULL, &fdset, NULL, &tv );
        switch ( res  )
        {
                case  0:
                        return false;
                case -1:
                        KError::FatalError( NULL, GetLastError(), "KSocket::SelectWrite(...) : select failed"  );
                        return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::SelectExcept()
{
        fd_set  fdset;
        
        FD_ZERO( &fdset );
        FD_SET( m_hSocket, &fdset );
        
        timeval tv;
        tv.tv_sec       = 0;
        tv.tv_usec      = 0;

        // Test for message received.
        int res = select( (int)m_hSocket + 1, NULL, NULL, &fdset, &tv );
        switch ( res  )
        {
                case  0:
                        return false;
                case -1:
                        KError::FatalError( NULL, GetLastError(), "KSocket::SelectExcept(...) : select failed"  );
                        return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Connect( KInetAddr& Addr )
{
        sockaddr_in     in;
        
        in.sin_port             = htons(Addr.GetPort());
        in.sin_addr             = Addr.GetInAddr();
        in.sin_family   = AF_INET;

        if( connect( m_hSocket, (const sockaddr*)&in, sizeof( in ) ) == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Connect() : connect failed"  );
                return false;
        }

        m_bConnected = true;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Disconnect()
{
        if( shutdown( m_hSocket, 2 ) == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Disconnect() : shutdown failed"  );
                return false;
        }

        m_bConnected = false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Listen()
{
        if( listen( m_hSocket, SOMAXCONN ) == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Listen() : listen failed"  );
                return false;
        }
        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Accept( KSocket& AcceptedSocket, KInetAddr& Addr )
{
        sockaddr_in     in;
        SOCKET          hSocket;
        
        in.sin_port             = htons(Addr.GetPort());
        in.sin_addr             = Addr.GetInAddr();
        in.sin_family   = AF_INET;

        s32             Length = sizeof( in );
        
        if( ( hSocket = accept( m_hSocket, (sockaddr*)&in, (int*)&Length ) ) == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Accept() : accept failed"  );
                return false;
        }
        
        AcceptedSocket.Attach( hSocket );
        AcceptedSocket.SetConnected( true );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Send( void* pBuffer, s32 Size )
{
        s32     result;
        
        // Envoie le buffer
        result = send( m_hSocket, (char*)pBuffer, Size, 0 );
        if( result == SOCKET_ERROR )
        {
                u32             Error = GetLastError();
                
                if( Error == WSAECONNRESET )
                {
                        // Socket distante déconnectée
                        Disconnect();
                        OnClose();
                        return false;
                }
                
                KError::FatalError( NULL, Error, "KSocket::Send() : send failed"  );
                return false;
        }

        if( result != Size )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Send() : %i of %i bytes sent.", result, Size  );
                return false;
        }

        m_nBytesSent            += Size;
        m_nRealBytesSent        += Size;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::Receive( void* pBuffer, s32 Size, u32* pBytesRead )
{
        s32     Result;
        
        Result = recv( m_hSocket, (char*)pBuffer, Size, 0 );
        if( Result == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::Receive() : recv failed"  );
                return false;
        }

        *pBytesRead = Result;
        m_nBytesReceived                += *pBytesRead;
        m_nRealBytesReceived    += *pBytesRead;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::SendTo( KInetAddr& Addr, void* pBuffer, u32 Size )
{
        sockaddr_in     in;
        
        in.sin_port             = htons(Addr.GetPort());
        in.sin_addr             = Addr.GetInAddr();
        in.sin_family   = AF_INET;

        // Compresse les données si necessaire
        char*   pBufferToSend   = (char*)pBuffer;
        u32             SizeToSend              = Size;
        u8              pOut[1024];
        s32             OutSize = sizeof( pOut );

        if( m_bCompress )
        {
                g_Lzw.Compress( (u8*)pBuffer, Size, pOut, &OutSize );
                pBufferToSend   = (char*)pOut;
                SizeToSend              = OutSize;
        }

//      g_Console << "SendTo : " << Size << KENDL;
        // Envoie le packet
        if( sendto( m_hSocket, (char*)pBufferToSend, SizeToSend, 0, (const sockaddr*)&in, sizeof( in ) ) == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::SendTo() : sendto failed"  );
                return false;
        }

        m_nBytesSent            += SizeToSend;
        m_nRealBytesSent        += Size;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::ReceiveFrom( KInetAddr& Addr, void* pBuffer, u32 Size, u32* pBytesRead )
{
        sockaddr_in     in;
        s32                     InLenght = sizeof( in );
        s32                     Result;
        char            pBufferToReceive[1024];
        
        Result = recvfrom( m_hSocket, (char*)pBufferToReceive, sizeof( pBufferToReceive ), 0, (sockaddr*)&in, (int*)&InLenght );
        if( Result == SOCKET_ERROR )
        {
                if( GetLastError() == WSAECONNRESET )
                        return false;

                KError::FatalError( NULL, GetLastError(), "KSocket::ReceiveFrom() : receivefrom failed"  );
                return false;
        }

        // Décompresse les données si necessaire
        u8              pOut[1024];
        s32             OutSize = Size;

        if( m_bCompress )
        {
                g_Lzw.Expand( (u8*)pBufferToReceive, Result, pOut, &OutSize );
                memcpy( pBuffer, pOut, OutSize);                
                *pBytesRead = OutSize;
        }
        else
        {
                memcpy( pBuffer, pBufferToReceive, Result );
                *pBytesRead = Result;
        }

        Addr.SetInAddr( in.sin_addr );
        Addr.SetPort( ntohs(in.sin_port) );

        m_nBytesReceived                += Result;
        m_nRealBytesReceived    += *pBytesRead;

//      g_Console << "Received : " << *pBytesRead << KENDL;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::AsyncSelect()
{
        fd_set  ReadFds;
        fd_set  WriteFds;
        fd_set  ExceptFds;
        
        FD_ZERO( &ReadFds );
        FD_ZERO( &WriteFds );
        FD_ZERO( &ExceptFds );
        FD_SET( m_hSocket, &ReadFds );
        FD_SET( m_hSocket, &WriteFds );
        FD_SET( m_hSocket, &ExceptFds );
        
        timeval tv;
        tv.tv_sec       = 0;
        tv.tv_usec      = 0;

        int res = select( (int)m_hSocket + 1, &ReadFds, &WriteFds, &ExceptFds, &tv );
        switch ( res  )
        {
                case  0:
                        return false;
                case -1:
                        KError::FatalError( NULL, GetLastError(), "KSocket::AsyncSelect(...) : select failed"  );
                        return false;
        }

        KError::Warning( NULL, "KSocket::AsyncSelect()" );

        // Read
        if( FD_ISSET( m_hSocket, &ReadFds ) )
        {
                BOOL    bAccept = false;
                int             Size;

                Size = sizeof( bAccept );
                getsockopt( m_hSocket, SOL_SOCKET, SO_ACCEPTCONN, (char*)&bAccept, &Size );

                if( bAccept )
                {
                        // SERVEUR
                        OnAccept();
                }
                else
                {
                        // CLIENT
                        int             Result;
                        char    Data;

                        // Si result == 0, c est un evenement Close sinon c'est un Read
                        Result = recv( m_hSocket, &Data, 1, MSG_PEEK );
                        if( ( Result == SOCKET_ERROR ) && ( GetLastError() != WSAEMSGSIZE ) )
                        {
                                KError::FatalError( NULL, GetLastError(), "KSocket::AsyncSelect(...) : recv failed"  );
                                return false;
                        }

                        if( !Result )
                        {
                                OnClose();
                                Disconnect();
                        }
                        else
                                OnRead();
                }
        }
        // Write
        if( FD_ISSET( m_hSocket, &WriteFds ) )
        {
                OnWrite();
        }
        // Except
        if( FD_ISSET( m_hSocket, &ExceptFds ) )
        {
                OnOOB();
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KSocket::OnAccept()
{
        KError::Warning( NULL, "KSocket::OnAccept()" );
/*
        static KSocket          Socket;
        KInetAddr       Addr;
        Accept( Socket, Addr );
        while( Socket.IsConnected() )
        {
                Socket.AsyncSelect();
        }*/
}

//---------------------------------------------------------------------------------------------------------------------
void KSocket::OnRead()
{
/*      char    pBuffer[1024];
        Receive( pBuffer, 1024 );*/
        KError::Warning( NULL, "KSocket::OnRead()" );
}

//---------------------------------------------------------------------------------------------------------------------
void KSocket::OnWrite()
{
        KError::Warning( NULL, "KSocket::OnWrite()" );
}

//---------------------------------------------------------------------------------------------------------------------
void KSocket::OnClose()
{
        KError::Warning( NULL, "KSocket::OnClose()" );
}

//---------------------------------------------------------------------------------------------------------------------
void KSocket::OnOOB()
{
        KError::Warning( NULL, "KSocket::OnOOB()" );
}

//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
bool KSocket::StartNetwork()
{
        WORD    Version = MAKEWORD( 2, 2 ); 
        WSADATA wsaData;
        
        if( WSAStartup( Version, &wsaData ) != 0 )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::StartNetwork() : Cannot start network"  );
                return false;
        }

//      g_Console << "Winsock v" << LOBYTE( wsaData.wVersion ) << "." << HIBYTE( wsaData.wVersion ) << KENDL;
        
        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::StopNetwork()
{
        if( WSACleanup() == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::StopNetwork() : Cannot stop network"  );
                return false;
        }
        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::GetHostName( char* pBuffer, s32 Size )
{
        if( gethostname( pBuffer, Size ) == SOCKET_ERROR )
        {
                KError::FatalError( NULL, GetLastError(), "KSocket::GetHostName() : gethostname failed"  );
                return false;
        }
        return true;
}

//---------------------------------------------------------------------------------------------------------------------
hostent* KSocket::GetHostByName( char* pName )
{
        return gethostbyname( pName );
}

//---------------------------------------------------------------------------------------------------------------------
hostent* KSocket::GetHostByAddr( KInetAddr& Addr )
{
        char*   pAddr = Addr.GetpAddress();
        in_addr in;

        in.S_un.S_addr = inet_addr( pAddr );
        
        return gethostbyaddr( (char*)&in, (int)sizeof( in ), AF_INET );
}

//---------------------------------------------------------------------------------------------------------------------
bool KSocket::GetAddrByName( KStr& sHostName, KInetAddr& Addr )
{
        // Recupere l'IP de l'host
        HOSTENT*        pHostent;

        pHostent = KSocket::GetHostByName( sHostName );
        if( !pHostent || !pHostent->h_addr_list[0] )
                return false;
        
        Addr.SetAddress( *((u32*)(pHostent->h_addr_list[0])) );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KSocket::EnableBroadcast( bool bEnable )
{
        setsockopt( m_hSocket, SOL_SOCKET, SO_BROADCAST, (char*)&bEnable, sizeof( bEnable ) );
}

---