socket.cpp

一个普通的mount工具,能过CIFS协议来挂载盘符

#ifndef WINNT

#include <portable.h>
#include <__trace.h>

#else

#define	WIN_KERNEL_MODE

extern "C"
{
#include <ntddk.h>
}

#include <KWin32.h>
#include <unisock.h>

#endif

#include "socket.hpp"

#ifndef WINNT

ClServerSocket::ClServerSocket( const char * szServerIP, int nPort )
{
    struct sockaddr_in LocalAddress;

    LocalAddress.sin_family = AF_INET;
    LocalAddress.sin_addr.s_addr = ::inet_addr( szServerIP? szServerIP: "127.0.0.1" );
    LocalAddress.sin_port = ::htons( nPort );

    m_Socket = ::socket( AF_INET, SOCK_STREAM, 0 ); // TCP socket
    if ( m_Socket == INVALID_SOCKET )
    {
        TRACE_PRINTF( ("ClServerSocket::ClServerSocket( %s, %d ) Failed to create socket\n", szServerIP, nPort) );
        throw XFailedToCreate();
    }

    if ( ::bind( m_Socket, (struct sockaddr*)&LocalAddress, sizeof(LocalAddress) ) == SOCKET_ERROR )
    {
        TRACE_PRINTF( ("ClServerSocket::ClServerSocket( %s, %d ) Failed to bind socket\n", szServerIP, nPort) );
        throw XFailedToCreate();
    }

    if ( ::listen( m_Socket, 5 ) == SOCKET_ERROR ) 
    {
        TRACE_PRINTF( ("ClServerSocket::ClServerSocket( %s, %d ) Failed to begin listenning\n", szServerIP, nPort) );
        throw XFailedToCreate();
    }
}

ClServerSocket::~ClServerSocket()
{
    ::closesocket( m_Socket );
}

int ClServerSocket::Do(void)
{
    while( TRUE )
    {
        struct sockaddr ConnectingClient;
        int nAddrLength = sizeof(ConnectingClient);

        St_Connection * pstConnection = new St_Connection;

        pstConnection->m_pServer = this;
        pstConnection->m_Client = ::accept( m_Socket, &ConnectingClient, &nAddrLength );
        if ( pstConnection->m_Client == INVALID_SOCKET )
        {
            delete pstConnection;
            TRACE_PRINTF( ("ClServerSocket::Do Failed\n") );
            return -1;
        }

        AddConnection( pstConnection );
        pstConnection->m_hThread = ::CreateThread( 
            NULL, 0, ConnectionThread, pstConnection, 0, &pstConnection->m_dwThread );
    }

    return 0;
}

void ClServerSocket::AddConnection( St_Connection * pstConnection )
{
    ClMutualExclusiveAccess AccessNow(m_ConnectionsLock);

    m_lstConnections.add( pstConnection );
}

BOOL ClServerSocket::RemoveConnection( ClWinSocket Connection )
{
    ClMutualExclusiveAccess AccessNow(m_ConnectionsLock);

    for( ST_ListContainerIt<St_Connection> it = m_lstConnections;
         it; it ++ )
    {
        if( (*it)->m_Client == Connection )
        {
            it.remove();
            return TRUE;
        }
    }

    return FALSE;
}

BOOL ClServerSocket::QueryConnection( ClWinSocket Connection, St_Connection & Info )
{
    ClMutualExclusiveAccess AccessNow(m_ConnectionsLock);

    for( ST_ListContainerIt<St_Connection> it = m_lstConnections;
         it; it ++ )
    {
        if( (*it)->m_Client == Connection )
        {
            Info = **it;
            return TRUE;
        }
    }

    return FALSE;
}

DWORD WINAPI ClServerSocket::ConnectionThread( LPVOID pParameter )
{
    St_Connection * pstConnection = (St_Connection *)pParameter;
    ClServerSocket * pServer = pstConnection->m_pServer;
    ClWinSocket Client = pstConnection->m_Client;
    pServer->OnConnect( Client );
    ::closesocket( Client );

    pServer->RemoveConnection( Client );

    return 0;
}

#endif

ClClientSocket::ClClientSocket()
{
    m_Socket = ::socket( AF_INET, SOCK_STREAM, 0 );
    if( m_Socket < 0 )
    {
        TRACE_PRINTF( ("ClClientSocket::ClClientSocket() Failed\n") );
    }
}

ClClientSocket::~ClClientSocket()
{
	if( m_Socket >= 0 )
	{
		::closesocket( m_Socket );
	}
}

namespace namWinSocket
{
    BOOL GetSocketAddress( LPCSTR szIPAddress, struct sockaddr_in & SocketAddress )
    {
        ULONG uInetAddr = ::inet_addr( szIPAddress );
	    memset( &SocketAddress, 0, sizeof(SocketAddress) );
        SocketAddress.sin_family = AF_INET;
        SocketAddress.sin_addr.S_un.S_addr = uInetAddr;

        return TRUE;
    }

    BOOL ReceiveStream( SOCKET Socket, PVOID pBuffer, size_t n )
    {
        size_t nTotal = 0;
        size_t nRemain = n;
        
        while( nRemain )
        {
            int nReceived = ::recv( Socket, (LPSTR)pBuffer, nRemain, 0 );
            if( nReceived == 0 )
            {
		        TRACE_PRINTF( ("namWinSocket::ReceiveStream: The connection is disconnected\n") );
		        return FALSE;
            }

	        if( nReceived == SOCKET_ERROR )
	        {
		        TRACE_PRINTF( ("namWinSocket::ReceiveStream: Failed to receive %d bytes data\n", n) );
		        return FALSE;
	        }


            nRemain -= nReceived;
            nTotal += nReceived;
            pBuffer = (BYTE *)pBuffer + nReceived;
        }

        return TRUE;
    }

    BOOL SendStream( SOCKET Socket, PVOID pBuffer, size_t n )
    {
        int nSent = ::send( Socket, (LPCSTR)pBuffer, n, 0 );

        if( nSent == SOCKET_ERROR )
        {
		    TRACE_PRINTF( ("namWinSocket::SendStream: Failed to send %d bytes data\n", n) );
            return FALSE;
        }

        if( (size_t)nSent != n )
        {
		    TRACE_PRINTF( ("namWinSocket::SendStream: Failed to send %d bytes data, sent %d bytes\n", n, nSent) );
            return FALSE;
        }
        return TRUE;
    }
    
};  //  namespace WinSocket

BOOL ClClientSocket::connect( const char * szServerIP, int nPort )
{
    struct sockaddr_in ServerAddr;
    if( !namWinSocket::GetSocketAddress( szServerIP, ServerAddr ) )
    {
        TRACE_PRINTF( ("ClClientSocket::connect( %s, %d ): Failed to get socket address\n", szServerIP, nPort) );
        return FALSE;
    }
    ServerAddr.sin_port = htons( nPort );

    if( ::connect( m_Socket, (struct sockaddr*)&ServerAddr, sizeof(ServerAddr) ) != 0 )
    {
        TRACE_PRINTF( ("ClClientSocket::connect( %s, %d ): Failed to connect\n", szServerIP, nPort) );
        return FALSE;
    }

    return TRUE;
}

BOOL ClClientSocket::connect( struct sockaddr_in SocketAddr, int nPort )
{
    SocketAddr.sin_port = ::htons( nPort );
    if( ::connect( m_Socket, (struct sockaddr*)&SocketAddr, sizeof(SocketAddr) ) != 0 ) 
    {
        TRACE_PRINTF( ("ClClientSocket::connect( , %d ): Failed to connect\n", nPort) );
        return FALSE;
    }

    return TRUE;
}