TCP/IP协议UDP类的编写

CUDP类主要包含两个文件，分别为：CUDP.h和CUDP.cpp

CUDP.h代码如下：

/***************************************************
 *作    者:温子祺
 *联系方式:wenziqi@hotmail.com
 *说    明:CUDP.h       
 ***************************************************/
#ifndef __CUDP_H__
 #define __CUDP_H__
 #pragma once

#include "afxsock.h"



 class CUDP
{

 public:

    CUDP(void);
   ~CUDP(void);

   BOOL  Close(void);
   BOOL  Open (CWnd * pPortOwner,
               CHAR * szLocalIP,
               UINT   unLocalPort,
               CHAR * szRemoteIP,
               UINT   unRemotePort,
               UINT   unRecvBufSize,
               UINT   unRecvMsg,
               UINT   unConnectMsg
              );
   UINT  Send(UCHAR *pSendBytes,UINT unSendLen);
   UINT  Recv(UCHAR *pSendBytes);

protected:

    BOOL  Ready(void)const;
    BOOL  InitSocket(void);
    BOOL  CreateThreadAndEvent(void);            //创建线程和事件
static
    DWORD RecvThread(LPVOID lpArg);              //接收线程

private:

    CWnd  *  m_pOwner;
    BOOL     m_bInit;
    UCHAR *  m_szRecvBuf;
    UINT     m_unRecvBufSize;
    SOCKET   m_ClientSocket;

    HANDLE   m_hRecvExitEvent; 
    UINT     m_unRecvLength;
    UINT     m_unRecvMsg;
    UINT     m_unConnectMsg;

    SOCKADDR_IN   m_saRemote;
    SOCKADDR_IN   m_saLocal;

};

#endif

CUDP.CPP代码如下：

/***************************************************
 *作    者:温子祺
 *联系方式:wenziqi@hotmail.com
 *说    明:CUDP.cpp       
 ***************************************************/
#include "StdAfx.h"
#include "CUDP.h"
#include <assert.h>            //使用断言

CUDP::CUDP(void)
{
    m_bInit=FALSE;
    m_pOwner=NULL;
    m_szRecvBuf=NULL;
    m_hRecvExitEvent=NULL;
}

CUDP::~CUDP(void)
{
    m_pOwner=NULL;
    m_szRecvBuf=NULL;
    m_hRecvExitEvent=NULL;
}

BOOL CUDP::Ready(void)const
{
    return m_bInit;
}

BOOL CUDP::Close(void)
{
    if (m_hRecvExitEvent)
    {
        SetEvent(m_hRecvExitEvent);
        Sleep(10);
        CloseHandle(m_hRecvExitEvent);
        m_hRecvExitEvent=NULL;
    }

    m_bInit=FALSE;

    if (INVALID_SOCKET!=m_ClientSocket)
    {
        closesocket(m_ClientSocket);

        if (SOCKET_ERROR==WSACleanup())
        {
            TRACE("SOCKET 释放资源失败.......!");
            return FALSE;

        }

    }

    if (m_szRecvBuf)
    {
        delete []m_szRecvBuf;
        m_szRecvBuf=NULL;
    }

    return TRUE;
}

BOOL CUDP::InitSocket(void)
{
    WSADATA wsa;

    WORD WinSockVersion=MAKEWORD(1,2);

    if (WSAStartup(WinSockVersion,&wsa)!=NULL)
    {
        TRACE("载入Windows Sockets失败...!");

        return FALSE;
    }

    m_ClientSocket=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    if (INVALID_SOCKET==m_ClientSocket)
    {
        TRACE("创建套接字失败...!");

        if (SOCKET_ERROR==WSACleanup())
        {
            TRACE("SOCKET 释放资源失败.......!");
        }

        return FALSE;
    }

    return TRUE;
}

BOOL CUDP::Open(CWnd * pPortOwner,
                CHAR * szLocalIP,
                UINT   unLocalPort,
                CHAR * szRemoteIP,
                UINT   unRemotePort,
                UINT   unRecvBufSize,
                UINT   unRecvMsg,
                UINT   unConnectMsg)
{
    assert(NULL != pPortOwner);

    m_pOwner  = pPortOwner;

    if (Ready())
    {
        Close();
    }

    

    if (!InitSocket())
    {
        return FALSE;
    }

    SOCKADDR_IN saLocal,saRemote;

    saLocal.sin_family       =AF_INET;

    if (*szLocalIP)
    {
         saLocal.sin_addr.s_addr=inet_addr(szLocalIP);
    }
    else
    {
         saLocal.sin_addr.s_addr=htonl(INADDR_ANY);     //客户端地址:全范围
    }

    saLocal.sin_port         =htons(unLocalPort);    //客户端端口


    saRemote.sin_family       =AF_INET;
    saRemote.sin_addr.s_addr  =inet_addr(szRemoteIP);//服务器端IP
    saRemote.sin_port         =htons(unRemotePort);  //服务器端端口    

    memcpy(&m_saLocal, &saLocal ,sizeof(SOCKADDR_IN));
    memcpy(&m_saRemote,&saRemote,sizeof(SOCKADDR_IN));

    //-----------------------服务器一定要绑定(客户端不一定要绑定)--------------
    if (SOCKET_ERROR==bind(m_ClientSocket,(PSOCKADDR)&saLocal,sizeof(SOCKADDR_IN)))
    {
        TRACE("绑定IP失败...!");

        closesocket(m_ClientSocket);

        if (SOCKET_ERROR==WSACleanup())
        {
            TRACE("SOCKET 释放资源失败.......!");
        }

        return FALSE;
    }

    if (!CreateThreadAndEvent())
    {
        return FALSE;
    }

    m_unRecvBufSize=unRecvBufSize;

    if (!m_szRecvBuf)
    {
        m_szRecvBuf=new UCHAR[unRecvBufSize];
    }

    m_unRecvMsg=unRecvMsg;
    m_unConnectMsg=unConnectMsg;
    m_bInit=TRUE;

    return TRUE;

}

BOOL CUDP::CreateThreadAndEvent(void)
{
    m_hRecvExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);        /* 创建串口接收线程退出事件*/

    if (NULL==m_hRecvExitEvent)
    {
        return FALSE;
    }

    ResetEvent(m_hRecvExitEvent);                                    //设置线程没有退出

    HANDLE hRecvThread=NULL;
    DWORD  dwThreadID =0;

    // 创建串口接收线程
    hRecvThread=CreateThread(0, 
                             0, 
     (LPTHREAD_START_ROUTINE)RecvThread, 
                             this, 
                             0, 
                            &dwThreadID);

    if (NULL==hRecvThread)
    {
        return FALSE;
    }

    CloseHandle(hRecvThread);
    hRecvThread=NULL;    

    return TRUE;
}

DWORD CUDP::RecvThread(LPVOID lpArg)
{

    assert(lpArg != NULL);

    CUDP *pArg= (CUDP *)(lpArg);

    assert(pArg !=  NULL);

    INT rt= 0;
    INT nSizeOfSockAddIn=0; 

    while (1)
    {
        if(WaitForSingleObject(pArg->m_hRecvExitEvent,0)==WAIT_OBJECT_0)  
        {
            break;
        }

        if (pArg->Ready())
        {
            nSizeOfSockAddIn=sizeof(SOCKADDR_IN);

            //recv函数:阻塞线程,不占CPU资源
            rt=recvfrom(pArg-> m_ClientSocket,
                (CHAR *)(pArg->m_szRecvBuf),
                pArg->m_unRecvBufSize,
                0,
                (SOCKADDR *)&pArg->m_saRemote,
                &nSizeOfSockAddIn);

            if (SOCKET_ERROR==rt ||NULL==rt)
            {
                TRACE(_T("TCPRecvThread:网络接收数据线程出现套接字错误...!"));

                ::SendMessage((pArg->m_pOwner)->m_hWnd,
                    pArg->m_unConnectMsg,
                    0,
                    0);
                break;
            }
            else if (rt>0)
            {

                pArg->m_unRecvLength=rt;

                ::SendMessage((pArg->m_pOwner)->m_hWnd,
                    pArg->m_unRecvMsg,
                    0,
                    0);

            }
        }

        Sleep(1);
    }


    Sleep(10);

    return 0;
}


UINT CUDP::Send(UCHAR *pSendBytes,UINT unSendLen)
{
    INT rt=0;
    UINT cnt=0;

    assert(pSendBytes != NULL);
    assert(unSendLen  != NULL);


    while (cnt<unSendLen)
    {
        rt=sendto(m_ClientSocket,
            (CHAR *)(pSendBytes+cnt),
            (unSendLen-cnt),
            0,
(sockaddr *)&m_saRemote,
            sizeof(m_saRemote));

        if (SOCKET_ERROR==rt)
        {
            TRACE("TCPSend:网络发送数据出现套接字错误...!");

            return 0;
        }

        cnt+=rt;

        if (cnt<unSendLen)
        {
            Sleep(1000);
        }
    }

    return cnt;
}

UINT CUDP::Recv(UCHAR *szRecvBuf)
{
    if (NULL == szRecvBuf)
    {
        return 0;
    }

    if (!Ready())
    {
        return 0;
    }

    memcpy(szRecvBuf,m_szRecvBuf,m_unRecvBufSize);

    return m_unRecvLength;
}