sh_socket.cpp

rsa算法打的一个包

BOOL SH_Socket::SetSockOpt(int level,int optname,const char FAR* optval,int optlen)
{
    BOOL bRet = FALSE;
    if(m_hSocket != SOCKET_ERROR)
    {
        int err = setsockopt(m_hSocket,level,optname,optval,optlen);
        if(err == SOCKET_ERROR)
        {
           SH_SocketSetLastError("SetSockOpt");
        }
        else
            bRet = TRUE;
    }
    return bRet;
}

BOOL SH_Socket::GetSockOpt(int level,int optname,char FAR* optval,int FAR* optlen)
{
    BOOL bRet = FALSE;
    if(m_hSocket != SOCKET_ERROR)
    {
        int err = getsockopt(m_hSocket,level,optname,optval,optlen);
        if(err == SOCKET_ERROR)
        {
           SH_SocketSetLastError("GetSockOpt");
        }
        else
            bRet = TRUE;
    }
    return bRet;
}

BOOL SH_Socket::Listen(int backlog)
{
    BOOL bRet = FALSE;

    if(m_hSocket != INVALID_SOCKET)
    {
        int err = listen(m_hSocket,backlog);

        if(err == SOCKET_ERROR)
        {
           SH_SocketSetLastError("Listen");
        }
        else
            bRet = TRUE;
    }
    return bRet;
}

SOCKET SH_Socket::Accept(struct sockaddr_in *pSockAddr)
{
    SOCKET hSocket = INVALID_SOCKET;

    if(m_hSocket != INVALID_SOCKET && pSockAddr != NULL)
    {
        int addrlen = sizeof(struct sockaddr);
        
        hSocket = accept(m_hSocket,
                        (struct sockaddr*)pSockAddr,
                        &addrlen);

        if(hSocket == INVALID_SOCKET)
        {
           SH_SocketSetLastError("Accept");
        }
    }
    return hSocket;
}

BOOL SH_Socket::Block()
{
    BOOL  bRet = FALSE;
    DWORD opt = 0;

    bRet = Ioctl(FIONBIO,&opt);
    m_bBlock = TRUE;
    return bRet;
}

BOOL SH_Socket::Unblock()
{
    BOOL  bRet = FALSE;
    DWORD opt = 1;

    bRet = Ioctl(FIONBIO,&opt);
    m_bBlock = FALSE;
    return bRet;
}

BOOL SH_Socket::ConnectEx(const struct sockaddr_in * pSockAddr,int ms)
{
    DWORD          opt = 1;
    fd_set         write_set;
    struct timeval tv;
    int            sock_len,sock_err;
    BOOL           bRet = FALSE;
    
    if(m_hSocket == INVALID_SOCKET || pSockAddr == NULL)
        return FALSE;

    if(!Ioctl(FIONBIO,&opt)) 
        return FALSE;
    
    if(!Connect(pSockAddr))
    {
        int err = WSAGetLastError();

        if(err == WSAEALREADY)
        {
            bRet = TRUE;
            goto CONNECTEX_ERROR_HANDLER;
        }
        else if(err != WSAEWOULDBLOCK)
        {
            goto CONNECTEX_ERROR_HANDLER;
        }
    }

   	FD_ZERO(&write_set);
	FD_SET(m_hSocket,&write_set);

	/*I will set connection timer-out 200 million seconds */
	tv.tv_sec = ms/1000;
	tv.tv_usec = (ms%1000)*1000L;

	if(Select(m_hSocket+1,NULL,&write_set,NULL,&tv))
	{
		sock_len = sizeof(int);
		if(GetSockOpt(SOL_SOCKET,SO_ERROR,(char*)&sock_err,&sock_len)>0)
		{
		    if(sock_err ==0)
		    {
                bRet = TRUE;/*OK*/
		    }
        }
	}
	else
	{
        SH_SocketSetLastError("ConnectEx");
	}
CONNECTEX_ERROR_HANDLER:
    /*Restore opt*/
    Ioctl(FIONBIO,&opt);
    return bRet;
}

BOOL SH_Socket::Connect(const struct sockaddr_in * pSockAddr)
{
    BOOL bRet = FALSE;

    if(m_hSocket != INVALID_SOCKET && pSockAddr != NULL)
    {
        int err = connect(m_hSocket,
                          (const struct sockaddr*)pSockAddr,
                          sizeof(struct sockaddr));

        if( err == SOCKET_ERROR)
        {
            SH_SocketSetLastError("Connect");
        }
        else
            bRet = TRUE;

    }
    return bRet;
}
BOOL SH_Socket::Connect(DWORD ip, WORD port)
{
    struct sockaddr_in addr;

    memset(&addr,0,sizeof(struct sockaddr_in));

    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(port);
    addr.sin_addr.s_addr = ip;

    return Connect(&addr);
}

BOOL SH_Socket::Connect(LPCTSTR pszAddress, WORD port)
{
    DWORD              ip;
    struct sockaddr_in addr;

    if(pszAddress == NULL)
        ip = INADDR_ANY;
    else
        ip = inet_addr(pszAddress);

    memset(&addr,0,sizeof(struct sockaddr_in));

    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(port);
    addr.sin_addr.s_addr = ip;

    return Connect(&addr);
}

BOOL SH_Socket::Bind(const struct sockaddr_in * pSockAddr)
{
    BOOL bRet = FALSE;
    if(m_hSocket != INVALID_SOCKET && pSockAddr != NULL)
    {
        int err = bind(m_hSocket,
                       (const struct sockaddr*)pSockAddr,
                       sizeof(struct sockaddr));
        
        if( err == SOCKET_ERROR)
        {
            SH_SocketSetLastError("Bind");
        }
        else
            bRet = TRUE;

    }
    return bRet;
}
BOOL SH_Socket::Bind(DWORD ip, WORD port)
{
    struct sockaddr_in addr;

    memset(&addr,0,sizeof(struct sockaddr_in));

    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(port);
    addr.sin_addr.s_addr = ip;

    return Bind(&addr);
}
BOOL SH_Socket::Bind(LPCTSTR pszAddress, WORD port)
{
    DWORD              ip;
    struct sockaddr_in addr;

    if(pszAddress == NULL)
        ip = INADDR_ANY;
    else
        ip = inet_addr(pszAddress);

    memset(&addr,0,sizeof(struct sockaddr_in));

    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(port);
    addr.sin_addr.s_addr = ip;

    return Bind(&addr);
}

BOOL SH_Socket::IsBlock()
{
    return m_bBlock;
}
int SH_Socket::Select(int nfds,fd_set FAR* readfds,fd_set FAR* writefds,fd_set FAR* exceptfds,const struct timeval FAR* timeout)
{
    if(m_hSocket == INVALID_SOCKET)
        return FALSE;

    int err = select(nfds,readfds,writefds,exceptfds,timeout);

    if(err == SOCKET_ERROR)
    {
        SH_SocketSetLastError("Select");
        return FALSE;
    }
    else
        return TRUE;
}

BOOL SH_Socket::IoctlEx(DWORD cmd,LPVOID FAR pInBuf,DWORD InLen,LPVOID FAR pOutBuf,DWORD OutLen,LPDWORD lpcbBytesReturned,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
    if(m_hSocket != INVALID_SOCKET)
    {
        int err = WSAIoctl(m_hSocket,
                           cmd,
                           pInBuf,
                           InLen,
                           pOutBuf,
                           OutLen,
                           lpcbBytesReturned,
                           lpOverlapped,
                           lpCompletionRoutine);

        if(err == SOCKET_ERROR) 
        {
            SH_SocketSetLastError("IoctlEx");
            return FALSE;
        }
        else
            return TRUE;
    }
    return FALSE;

}
BOOL SH_Socket::IoctlEx(DWORD cmd,LPVOID FAR pInBuf,DWORD InLen)
{
    DWORD dwBytesReturn;
    return IoctlEx(cmd,pInBuf,InLen,NULL,0,&dwBytesReturn,NULL,NULL);
}

BOOL SH_Socket::SelectEx(LONG lEvent)
{
    if(m_hSocket != INVALID_SOCKET)
    {
        int err = WSAAsyncSelect(m_hSocket,GetSafeHwnd(),WM_SOCKET_MESSAGE,lEvent);

        if(err != SOCKET_ERROR)
        {
            SH_Socket * pSocket = NULL;

            pSocket = SH_SocketFindBySocket(GetSocket());
            if(pSocket == NULL)
            {
                if(lEvent)
                    SH_SocketAddToList(this);
            }
            else if(lEvent == 0)
            {
                SH_SocketRemoveFromList(GetSocket());
            }
            return TRUE;
        }


        SH_SocketSetLastError("SelectEx");
    }
    return FALSE;
}

HWND SH_Socket::GetSafeHwnd()
{
    return ::SH_SocketWnd;
}

WORD SH_Socket::CheckSum(WORD * pSendData, int nSize)
{
    DWORD dwCheckSum = 0;
    while(nSize > 1) 
    {
        dwCheckSum+=*pSendData++;
        nSize -=sizeof(WORD);
    }
    if(nSize ) 
    {
        dwCheckSum += *(BYTE*)pSendData;
    }
    dwCheckSum  = (dwCheckSum >> 16) + (dwCheckSum & 0xffff);
    dwCheckSum += (dwCheckSum >>16);

    return (WORD)(~dwCheckSum);
}