sh_socket.cpp

rsa算法打的一个包

// SH_Socket.cpp: implementation of the SH_Socket class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SH_Socket.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#include "SH_Hash.h"

//////////////////////////////////////////////////////////////////////
// Global function
//////////////////////////////////////////////////////////////////////
#define WM_SOCKET_MESSAGE (WM_USER+2005)

#ifdef _DEBUG
#define SH_SocketSetLastError(STR) do{ \
                                TRACE("SH_Socket#%s failed.Error no is %d\n",(STR),WSAGetLastError());\
                             }while(0)
#else
#define SH_SocketSetLastError(STR) do{}while(0) 
#endif

static HWND                                  SH_SocketWnd = NULL;
static UINT                                  SH_SocketTimer;
static SH_Hash<SOCKET,SH_Socket*>            SH_SocketList;

static LRESULT     SH_SocketMessageHandler(HWND,UINT,WPARAM,LPARAM);

static SH_Socket * SH_SocketFindBySocket(SOCKET hSocket)
{
    SH_Socket * pSocket = NULL;

    if(SH_SocketList.Search(hSocket,(SH_Socket*&)pSocket))
    {
        return pSocket;
    }
    else
        return NULL;
}

static void SH_SocketAddToList(SH_Socket * pSocket)
{
    if(pSocket && pSocket->GetSocket()!= INVALID_SOCKET)
    {
        SH_SocketList.Add(pSocket->GetSocket(),pSocket);
    }
}

static void SH_SocketRemoveFromList(SOCKET hSocket)
{
    if(hSocket != INVALID_SOCKET)
    {
        SH_SocketList.Remove(hSocket);
    }
}

static LRESULT SH_SocketMessageHandler(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
    SH_Socket *   pSocket = NULL;
    
    if(uMsg == WM_SOCKET_MESSAGE)
    {
        pSocket = SH_SocketFindBySocket((SOCKET)wParam);
        
        if(pSocket == NULL) return 0;
        
        switch(WSAGETSELECTEVENT(lParam))
        {
            case FD_READ:
                return pSocket->OnRead(WSAGETSELECTERROR(lParam));
                break;
            case FD_WRITE:
                return pSocket->OnWrite(WSAGETSELECTERROR(lParam));
                break;
            case FD_OOB:
                return pSocket->OnReadOOB(WSAGETSELECTERROR(lParam));
                break;
            case FD_CONNECT:
                return pSocket->OnConnect(WSAGETSELECTERROR(lParam));
                break;
            case FD_CLOSE:
                return pSocket->OnClose(WSAGETSELECTERROR(lParam));
                break;
            case FD_ACCEPT:
                return pSocket->OnAccept(WSAGETSELECTERROR(lParam));
                break;
            default:
         	    return (int)(DefWindowProc(hwnd, uMsg, wParam, lParam));
        }
    }
    else if(uMsg == WM_TIMER)
    {
        /*TODO:Add your code here*/
        SH_Position pos;
        SOCKET      hSocket;    
        pos = SH_SocketList.GetStartPosition();

        while(pos)
        {
            SH_SocketList.GetNextAssoc(pos,hSocket,(SH_Socket*&)pSocket);

            if(pSocket) pSocket->OnTimer();
        }
    }
 	return (int)(DefWindowProc(hwnd, uMsg, wParam, lParam));
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

SH_Socket::SH_Socket()
{
    m_hSocket   = INVALID_SOCKET;
    m_nFamily   = AF_INET;
    m_nType     = SOCK_STREAM;
    m_nProtocol = 0;

    m_bBlock    = TRUE;
}

SH_Socket::~SH_Socket()
{
    Close();
}
BOOL SH_Socket::Initialize(void)
{
    int     err;
    WSADATA WsaData;

    err = WSAStartup(MAKEWORD(0x2,0x2),&WsaData);

    if(err == SOCKET_ERROR)
    {
        SH_SocketSetLastError("SH_SocketInit");
        return FALSE;
    }

    if ( LOBYTE( WsaData.wVersion ) != 2 || HIBYTE( WsaData.wVersion ) != 2 )
    {
        WSACleanup();
        SH_SocketSetLastError("SH_SocketInit");
        return FALSE; 
    }

    /*Create wnd for WSAAsyncSelect*/
    SH_SocketWnd = CreateWindow("STATIC","WND_SOCKET_",0,0,0,0,0,NULL,NULL,AfxGetInstanceHandle(),NULL);
    ASSERT(SH_SocketWnd != NULL || SH_SocketWnd != INVALID_HANDLE_VALUE);
    ::SetWindowLong(SH_SocketWnd,GWL_WNDPROC,(LONG)SH_SocketMessageHandler);

    SH_SocketTimer = ::SetTimer(SH_SocketWnd,0x01,100,NULL);
    ASSERT(SH_SocketTimer != 0);

    SH_SocketList.Create(100);
    return TRUE;
}

BOOL SH_Socket::Uninitialize(void)
{
    int err;

    SH_SocketList.RemoveAll();
    
    ::KillTimer(SH_SocketWnd,0x01);
    
    err = WSACleanup();
    
    return (err != SOCKET_ERROR);
}

SOCKET SH_Socket::GetSocket() const
{
    return m_hSocket;
}

BOOL SH_Socket::Open(int family, int type, int protocol)
{
    m_nFamily   = family;
    m_nType     = type;
    m_nProtocol = protocol;

    return Open();
}

BOOL SH_Socket::Open()
{
    m_hSocket = socket(m_nFamily,m_nType,m_nProtocol);

    if(m_hSocket != INVALID_SOCKET)
    {
        return TRUE;
    }
    else
    {
        SH_SocketSetLastError("Open");
        return FALSE;
    }
}

void SH_Socket::Close()
{
    if(m_hSocket != INVALID_SOCKET)
    {
        SH_SocketRemoveFromList(m_hSocket);
        closesocket(m_hSocket);
        m_hSocket = INVALID_SOCKET;
    }
}

void SH_Socket::Shutdown(int how)
{
    if(m_hSocket != INVALID_SOCKET)
    {
        int err = shutdown(m_hSocket,how);
        if(err == SOCKET_ERROR)
        {
           SH_SocketSetLastError("Shutdown");
        }
    }
}

int SH_Socket::Recv(char *pRecvBuf, int nBufLen,int flag)
{
    int nRecvLen = 0;

    if(m_hSocket != INVALID_SOCKET)
    {
        nRecvLen = recv(m_hSocket,pRecvBuf,nBufLen,flag);

        if(nRecvLen == SOCKET_ERROR)
        {
            SH_SocketSetLastError("Recv");
        }
    }
    return nRecvLen;
}

int SH_Socket::Recv(char *pRecvBuf, int nBufLen)
{
    return Recv(pRecvBuf,nBufLen,0);
}

int SH_Socket::PseudoRecv(char *pRecvBuf, int nBufLen)
{
    return Recv(pRecvBuf,nBufLen,MSG_PEEK);
}

int SH_Socket::OOBRecv(char *pRecvBuf, int nBufLen)
{
    return Recv(pRecvBuf,nBufLen,MSG_OOB);
}

int SH_Socket::RecvFrom(char *pRecvBuf, int nBufLen,struct sockaddr * addr,int flag)
{
    int nRecvLen = 0;
    int addr_len = sizeof(struct sockaddr);
    if(m_hSocket != INVALID_SOCKET && IsBadWritePtr(addr,sizeof(struct sockaddr)) == FALSE)
    {
        nRecvLen = recvfrom(m_hSocket,pRecvBuf,nBufLen,flag,addr,&addr_len);

        if(nRecvLen == SOCKET_ERROR)
        {
            SH_SocketSetLastError("Recv");
        }
    }
    return nRecvLen;
}

int SH_Socket::RecvFrom(char *pRecvBuf, int nBufLen,struct sockaddr * addr)
{
    return RecvFrom(pRecvBuf,nBufLen,addr,0);
}

int SH_Socket::Send(const char *pSendBuf, int nBufLen,int flags)
{
    int nSendLen = 0;

    if(m_hSocket != INVALID_SOCKET)
    {
        nSendLen = send(m_hSocket,pSendBuf,nBufLen,flags);
    }

    return nSendLen;
}

int SH_Socket::Send(const char *pSendBuf, int nBufLen)
{
    int nSendLen = 0;

    if(m_hSocket != INVALID_SOCKET)
    {
        nSendLen = send(m_hSocket,pSendBuf,nBufLen,0);
    }

    return nSendLen;
}

int SH_Socket::SendTo(const char *pSendBuf, int nBufLen,struct sockaddr * addr,int flags)
{
    int nSendLen = 0;

    if(m_hSocket != INVALID_SOCKET)
    {
        nSendLen = sendto(m_hSocket,pSendBuf,nBufLen,flags,addr,sizeof(struct sockaddr));
        if(nSendLen == SOCKET_ERROR)
        {
            SH_SocketSetLastError("SendTo");
        }

    }

    return nSendLen;
}

int SH_Socket::SendTo(const char *pSendBuf, int nBufLen,struct sockaddr * addr)
{
    int nSendLen = 0;

    if(m_hSocket != INVALID_SOCKET)
    {
        nSendLen = sendto(m_hSocket,pSendBuf,nBufLen,0,addr,sizeof(struct sockaddr));
        if(nSendLen == SOCKET_ERROR)
        {
            SH_SocketSetLastError("SendTo");
        }
    }

    return nSendLen;
}

BOOL SH_Socket::Ioctl(DWORD cmd,DWORD FAR * argp)
{
    BOOL bRet = FALSE;

    if(m_hSocket != SOCKET_ERROR)
    {
        int err = ioctlsocket(m_hSocket,cmd,argp);
        if(err == SOCKET_ERROR)
        {
           SH_SocketSetLastError("Ioctl");
        }
        else
            bRet = TRUE;
    }
    return bRet;
}