TCPIP编程

一：Winsock编程流程

1：对于任何基于Winsock的编程首先我们必须要初始化Winsock DLL库。

int WSAStarup( WORD wVersionRequested , LPWSADATA lpWsAData )wVersionRequested是我们要求使用的Winsock的版本。

调用这个接口函数可以帮我们初始化Winsock。

2：然后我们必须创建一个套接字(socket)。

SOCKET socket( int af , int type , int protocol )；

套接字可以说是Winsock通讯的核心.Winsock通讯的所有数据传输,都是通过套接字来完成的,套接字包含了两个信息,一个是IP地址,一个是Port端口号,使用这两个信息,我们就可以确定网络中的任何一个通讯节点.

3：当我们调用了socket()接口函数创建了一个套接字后,我们必须把套接字与你需要进行通讯的地址建立联系,我们可以通过绑定函数来实现这种联系.

int bind(SOCKET s , const struct sockaddr FAR* name , int namelen ) ;

struct sockaddr_in

{

short sin_family ;

u_short sin_prot ;

struct in_addr sin_addr ;

char sin_sero[8] ;

}

就包含了我们需要建立连接的本地的地址,包括,地址族,ip和端口信息.sin_family字段我们必须把他设为AF_INET,这是告诉Winsock使用的是IP地址族.sin_prot 就是我们要用来通讯的端口号.sin_addr就是我们要用来通讯的ip地址信息。

4：在这里,必须还得提一下有关'大头(big-endian)'小头(little-endian)'.因为各种不同的计算机处理数据时的方法是不一样的,Intel 86处理器上是用'小头'形势来表示多字节的编号,就是把低字节放在前面,把高字节放在后面,而互联网标准却正好相反,所以,我们必须把主机字节转换成网络字节的顺序.Winsock API提供了几个函数.

把主机字节转化成网络字节的函数;

u_long htonl( u_long hostlong );

u_short htons( u_short hostshort );

把网络字节转化成主机字节的函数;

u_long ntohl( u_long netlong ) ;

u_short ntohs( u_short netshort ) ;

这样,我们设置ip地址,和port端口时,就必须把主机字节转化成网络字节后,才能用bind()函数来绑定套接字和地址。

5：当绑定完成之后,服务器端必须建立一个监听的队列来接收客户端的连接请求.

int listen( SOCKET s ,int backlog );

这个函数可以让我们把套接字转成监听模式.

如果客户端有了连接请求,我们还必须使用

int accept( SOCKET s , struct sockaddr FAR* addr , int FAR* addrlen );

来接受客户端的请求.

6：客户端的建立的流程则是初始化WinSock ,然后创建socket套接字,再使用

int connect( SOCKET s , const struct sockaddr FAR* name , int namelen ) ;

来连接服务端。

7：下面是一个最简单的创建服务器端和客户端的例子:

服务器端的创建 :

WSADATA wsd ;

SOCKET sListen ;

SOCKET sclient ;

UINT port = 800 ;

int iAddrSize ;

struct sockaddr_in local , client ;

WSAStartup( 0x11 , &wsd );

sListen = socket ( AF_INET , SOCK_STREAM , IPPOTO_IP ) ;

local.sin_family = AF_INET ;

local.sin_addr = htonl( INADDR_ANY ) ;

local.sin_port = htons( port ) ;

bind( sListen , (struct sockaddr*)&local , sizeof( local ) ) ;

listen( sListen , 5 ) ;

sClient = accept( sListen , (struct sockaddr*)&client , &iAddrSize ) ;

客户端的创建:

WSADATA wsd ;

SOCKET sClient ;

UINT port = 800 ;

char szIp[] = "127.0.0.1" ;

int iAddrSize ;

struct sockaddr_in server ;

WSAStartup( 0x11 , &wsd );

sClient = socket ( AF_INET , SOCK_STREAM , IPPOTO_IP ) ;

server.sin_family = AF_INET ;

server.sin_addr = inet_addr( szIp ) ;

server.sin_port = htons( port );

connect( sClient , (struct sockaddr*)&server , sizeof( server ) ) ;

8：当服务器端和客户端建立连接以后,无论是客户端,还是服务器端都可以使用

int send( SOCKET s , const char FAR* buf , int len , int flags );

int recv( SOCKET s , char FAR* buf , int len , int flags );

函数来接收和发送数据,因为,TCP连接是双向的.

9：当要关闭通讯连结的时候，任何一方都可以调用

int shutdown( SOCKET s , int how ) ;

来关闭套接字的指定功能。再调用

int closesocket( SOCKET s) ;

来关闭套接字句柄。这样一个通讯过程就算完成了。

注意：上面的代码没有任何检查函数返回值,如果你作网络编程就一定要检查任何一个Winsock API函数的调用结果,因为很多时候函数调用并不一定成功.上面介绍的函数,返回值类型是int的话,如果函数调用失败的话,返回的都是SOCKET_ERROR.

二：简单的TCPIP通讯，客户端发送什么，服务端就显示什么。

1：客户端

#include <iostream>

#include <WINSOCK2.H>

#pragma comment (lib,"ws2_32.lib")

int main()

{

WSADATA wsaData; //用于填充套接字库版本的有关信息

SOCKET ServerSocket = NULL; //服务器套接字（用于同服务器IPv4地址绑定）

SOCKADDR_IN ServerSocketAddr; //服务器的IPv4地址

int port = 9999; //要连接服务器的端口

char buf[1024]; //存储消息用

int MessageLen = 0; //返回的消息长度

//加载Winsock 2.2版本

if(WSAStartup(MAKEWORD(2,2),&wsaData) !=0)

{

std::cout<<"WSAStartup failed"<<std::endl;

return 1;

}

//创建套接字

if((ServerSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) == INVALID_SOCKET)

std::cout<<"Create ServerSocket failed with error"<<" "<<WSAGetLastError()<<std::endl;

//填写服务器IPv4信息

ServerSocketAddr.sin_family = AF_INET;

ServerSocketAddr.sin_port = htons(port);

ServerSocketAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

//连接服务器

if(connect(ServerSocket,(SOCKADDR*)&ServerSocketAddr,sizeof(ServerSocketAddr)) ==SOCKET_ERROR)

std::cout<<"Connecting failed with error"<<" "<<WSAGetLastError()<<std::endl;

else

std::cout<<"Connect successing!"<<std::endl;

//发送数据，直到数据内容为"exit"则退出程序

while(strcmp(buf,"exit") != 0)

{

std::cout<<"Please input:"<<std::endl;

std::cin>>buf;

if((MessageLen = send(ServerSocket,buf,strlen(buf),0)) == INVALID_SOCKET)

std::cout<<"Send data failed with error"<<" "<<WSAGetLastError()<<std::endl;

else

std::cout<<"Send"<<" "<<MessageLen<<" "<<"byte"<<"datas"<<std::endl;;

}

closesocket(ServerSocket);

WSACleanup();

return 0;

}

2：服务端

#include <WINSOCK2.H>

#include <iostream>

#pragma comment (lib,"WS2_32.LIB")

int main()

{

WSADATA wsaData; //在加载Winsock DLL版本时被用来填充该库版本的有关信息

SOCKET ListeningSocket; //用于监听的套接字

SOCKET NewConnection = NULL; //accept函数反回的套接字，用于同connect方（客户端）连系。

SOCKADDR_IN ServerAddr; //本地（服务器）IPv4地址

SOCKADDR_IN ClientAddr; //connect方IPv4地址

int port = 9999; //本地打要打开的端口

int ClientAddrLen = sizeof(ClientAddr); //connect方IPv4地址的长度

int BufLen = 0; //接收到的信息的长度

char buf[50]; //用于存储信息

/*加载.2版本的Winsock*/

if(WSAStartup(MAKEWORD(2,2),&wsaData))

{

std::cout<<"WSAStartup failed"<<std::endl;

return 1;

}

std::cout<<"WSAStartup successing!"<<std::endl;

/*创建套接字*/

if((ListeningSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) == INVALID_SOCKET)

{

std::cout<<"Create ListenSocket failed with error"<<" "<<WSAGetLastError()<<std::endl;

return 1;

}

std::cout<<"Create ListenSocket successing!"<<std::endl;

/*设置服务器IPv4地址*/

ServerAddr.sin_family = AF_INET;

ServerAddr.sin_port = htons(port);

ServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);

/*绑定套接字与地址信息*/

if(bind(ListeningSocket,(SOCKADDR*)&ServerAddr,sizeof(ServerAddr)) == SOCKET_ERROR)

{

std::cout<<"Bind failed with error"<<" "<<WSAGetLastError()<<std::endl;

return 1;

}

std::cout<<"Bind successing!"<<std::endl;

/*开始监听*/

if(listen(ListeningSocket,3) == SOCKET_ERROR)

{

std::cout<<"Listen failed with error"<<" "<<WSAGetLastError()<<std::endl;

return 1;

}

else

std::cout<<"Listening..."<<std::endl;

/*接受连接*/

if((NewConnection = accept(ListeningSocket,(SOCKADDR*)&ClientAddr,&ClientAddrLen)) == INVALID_SOCKET)

std::cout<<"Accept failed with error"<<" "<<WSAGetLastError()<<std::endl;

else

std::cout<<"Accept successing!"<<std::endl;

/*接收并显示数据*/

while(strcmp(buf,"exit"))

{

BufLen = recv(NewConnection,buf,sizeof(buf),0);

buf[BufLen] = '/0';

std::cout<<buf<<std::endl;

}

/*关闭套接字*/

closesocket(ListeningSocket);

closesocket(NewConnection);

WSACleanup();

return 0;

}

三：负责的TCPIP通讯

1：客户端Socket通讯类

//定义连接断开事件

typedef void (CALLBACK* ONDISCONNECT)(void* pOwner);

//定义当有数据接收事件

typedef void (CALLBACK* ONREAD)(void* pOwner,const char * buf,DWORD dwBufLen );

//定义Socket错误事件

typedef void (CALLBACK* ONERROR)(void* pOwner,int nErrorCode);

class CTCPClient_CE

{

public:

CTCPClient_CE(void);

~CTCPClient_CE(void);

public:

//远程主机IP地址

CString m_remoteHost;

//远程主机端口

int m_port;

/*--以下客户端通讯事件--*/

//连接断开事件，回调函数

ONDISCONNECT OnDisConnect;

//接收数据事件，回调函数

ONREAD OnRead;

//发生错误事件，回调函数

ONERROR OnError;

private:

//通讯Socket句柄

SOCKET m_socket;

//通讯线程退出事件句柄

HANDLE m_exitThreadEvent;

//通讯线程句柄

HANDLE m_tcpThreadHandle;

//父对象句柄

void * m_pOwner;

//接收缓冲区

char m_recvBuf[4096];

private:

//通讯线程函数

static DWORD SocketThreadFunc(LPVOID lparam);

public:

//用于打开客户端socket

BOOL Open(void * pOwner);

public:

//用于关闭客户端socket

BOOL Close();

public:

//用于建立与TCP服务器连接

BOOL Connect();

public:

//向服务器端发送数据

BOOL SendData(const char * buf , DWORD dwBufLen);

};

//构造函数

CTCPClient_CE::CTCPClient_CE()

{

//初始化socket环境

WSADATA wsd;

WSAStartup(MAKEWORD(2,2),&wsd);

//置空缓冲区

ZeroMemory(m_recvBuf,4096);

OnDisConnect = NULL; //连接断开事件，回调函数

OnRead = NULL; //接收数据事件，回调函数

OnError = NULL; //发生错误事件，回调函数

//创建线程退出事件句柄

m_exitThreadEvent = CreateEvent(NULL,FALSE,FALSE,L"EVENT_TCP_CLIENT_THREAD");

}

//析构函数

CTCPClient_CE::~CTCPClient_CE()

{

//关闭线程退出事件句柄

CloseHandle(m_exitThreadEvent);

//释放socket资源

WSACleanup();

}

/*------------------------------------------------------------------

【函数介绍】: 此线程用于监听TCP客户端通讯的事件，例如当接收到数据、

连接断开和通讯过程发生错误等事件

【入口参数】: lparam:无类型指针，可以通过此参数，向线程中传入需要用到的资源。

在这里我们将CTCPClient_CE类实例指针传进来

【出口参数】: (无)

【返回 值】: 返回值没有特别的意义，在此我们将返回值设为。

------------------------------------------------------------------*/

DWORD CTCPClient_CE::SocketThreadFunc(LPVOID lparam)

{

CTCPClient_CE *pSocket;

//得到CTCPClient_CE实例指针

pSocket = (CTCPClient_CE*)lparam;

//定义读事件集合

fd_set fdRead;

int ret;

//定义事件等待时间

TIMEVAL aTime;

aTime.tv_sec = 1;

aTime.tv_usec = 0;

while (TRUE)

{

//收到退出事件，结束线程

if (WaitForSingleObject(pSocket->m_exitThreadEvent,0) == WAIT_OBJECT_0)

{

break;

}

//置空fdRead事件为空

FD_ZERO(&fdRead);

//给客户端socket设置读事件

FD_SET(pSocket->m_socket,&fdRead);

//调用select函数，判断是否有读事件发生

ret = select(0,&fdRead,NULL,NULL,&aTime);

if (ret == SOCKET_ERROR)

{

if (pSocket->OnError)

{

//触发错误事件

pSocket->OnError(pSocket->m_pOwner,1);

}

if (pSocket->OnDisConnect)

{

//触发连接断开事件

pSocket->OnDisConnect(pSocket->m_pOwner);

}

//关闭客户端socket

closesocket(pSocket->m_socket);

break;

}

if (ret > 0)

{

//发生读事件

if (FD_ISSET(pSocket->m_socket,&fdRead))

{

ZeroMemory(pSocket->m_recvBuf,4096);

//接收数据

int recvLen = recv(pSocket->m_socket,pSocket->m_recvBuf, 4096,0);

if (recvLen == SOCKET_ERROR)

{

int iError = WSAGetLastError();

if (pSocket->OnError)

{

//触发socket错误事件

pSocket->OnError(pSocket->m_pOwner,iError);

}

if (pSocket->OnDisConnect)

{

//触发与服务器断开事件

pSocket->OnDisConnect(pSocket->m_pOwner);

}

//关闭客户端socket

closesocket(pSocket->m_socket);

break;

}

else if (recvLen == 0)

{

if (pSocket->OnDisConnect)

{

//触发与服务器端断开事件

pSocket->OnDisConnect(pSocket->m_pOwner);

}

//关闭客户端socket

closesocket(pSocket->m_socket);

break;

}

else

{

if (pSocket->OnRead)

{

//触发数据接收事件

pSocket->OnRead(pSocket->m_pOwner,pSocket->m_recvBuf,recvLen);

}

}

}

}

}

TRACE(L"客户端线程退出/n");

return 0;

}

/*-----------------------------------------------------------------

【函数介绍】: 用于打开客户端socket

【入口参数】: pOwner 用于指定父对象

【出口参数】: (无)

【返回 值】: TRUE:打开成功;FALSE:打开失败

-----------------------------------------------------------------*/

BOOL CTCPClient_CE::Open(void * pOwner)

{

//复位线程退出事件

ResetEvent(m_exitThreadEvent);

//存储父对象指针

m_pOwner = pOwner;

//创建TCP套接字

m_socket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

if (m_socket == SOCKET_ERROR)

{

return FALSE;

}

//创建通讯线程

m_tcpThreadHandle = CreateThread(NULL,0,SocketThreadFunc,this,0,NULL);

if (m_tcpThreadHandle == NULL)

{

closesocket(m_socket);

return FALSE;

}

return TRUE;

}

/*----------------------------------------------------------------

【函数介绍】: 用于关闭客户端socket

【入口参数】: (无)

【出口参数】: (无)

【返回 值】: TRUE:关闭成功;FALSE:关闭失败

-----------------------------------------------------------------*/

BOOL CTCPClient_CE::Close()

{

//发送通讯线程结束事件

SetEvent(m_exitThreadEvent);

//等待秒，如果读线程没有退出，则强制退出

if (WaitForSingleObject(m_tcpThreadHandle,1000) == WAIT_TIMEOUT)

{

TerminateThread(m_tcpThreadHandle,0);

TRACE(L"强制终止客户端线程/n");

}

m_tcpThreadHandle = NULL;

//关闭Socket，释放资源

int err = closesocket(m_socket);

if (err == SOCKET_ERROR)

{

return FALSE;

}

return TRUE;

}

/*-----------------------------------------------------------------

【函数介绍】: 用于建立与TCP服务器连接

【入口参数】: (无)

【出口参数】: (无)

【返回 值】: TRUE:建立连接成功;FALSE:建立连接失败

------------------------------------------------------------------*/

BOOL CTCPClient_CE::Connect()

{

struct sockaddr_in addr;

int err;

addr.sin_family = AF_INET;

addr.sin_port = htons(m_port);

//此处要将双字节转换成单字节

char ansiRemoteHost[255];

ZeroMemory(ansiRemoteHost,255);

WideCharToMultiByte(CP_ACP,WC_COMPOSITECHECK,m_remoteHost,wcslen(m_remoteHost)

,ansiRemoteHost,wcslen(m_remoteHost),NULL,NULL);

addr.sin_addr.s_addr=inet_addr(ansiRemoteHost);

//此时采用同步连接方式,connect直接返回成功或是失败

err = connect(m_socket,(struct sockaddr *)&addr,sizeof(addr));

if (err == SOCKET_ERROR)

{

return FALSE;

}

//设置通讯模式为异步模式

DWORD ul= 1;

ioctlsocket(m_socket,FIONBIO,&ul);

return TRUE;

}

/*-----------------------------------------------------------------

【函数介绍】: 向服务器端发送数据

【入口参数】: buf:待发送的数据

dwBufLen:待发送的数据长度

【出口参数】: (无)

【返回 值】: TRUE:发送数据成功;FALSE:发送数据失败

------------------------------------------------------------------*/

BOOL CTCPClient_CE::SendData(const char * buf , DWORD dwBufLen)

{

int nBytes = 0;

int nSendBytes=0;

while (nSendBytes < dwBufLen)

{

nBytes = send(m_socket,buf+nSendBytes,dwBufLen-nSendBytes,0);

if (nBytes==SOCKET_ERROR )

{

int iErrorCode = WSAGetLastError();

//触发socket的Error事件

if (OnError)

{

OnError(m_pOwner,iErrorCode);

}

//触发与服务器端断开连接事件

if (OnDisConnect)

{

OnDisConnect(m_pOwner);

}

//关闭socket

Close();

return FALSE;

}

//累计发送的字节数

nSendBytes = nSendBytes + nBytes;

if (nSendBytes < dwBufLen)

{

Sleep(1000);

}

}

return TRUE;

}

2：客户端的操作

#include "TCPClient_CE.h"

//定义TCP 客户端接收到数据消息

#define WM_RECV_TCP_DATA WM_USER + 101

//定义TCP客户端连接断开消息

#define WM_TCP_CLIENT_DISCONNECT WM_USER + 102

ON_MESSAGE(WM_RECV_TCP_DATA,OnRecvTCPData)

ON_MESSAGE(WM_TCP_CLIENT_DISCONNECT,OnClientDisconnect)

//TCP接收数据处理函数

afx_msg LONG OnRecvTCPData(WPARAM wParam,LPARAM lParam);

//客户端连接断开消息函数

afx_msg LONG OnClientDisconnect(WPARAM wParam,LPARAM lParam);

private:

//定义CTCPClient_CE对象

CTCPClient_CE m_tcpClient;

private://回调函数

//连接断开事件处理函数

static void CALLBACK OnDisConnect(void* pOwner);

//当有数据接收事件处理函数

static void CALLBACK OnRead(void* pOwner,const char * buf,DWORD dwBufLen );

//Socket错误事件处理函数

static void CALLBACK OnError(void* pOwner,int nErrorCode);

private:

//得到本地的IP地址

CString GetLocalIP();

//连接断开事件

void CALLBACK CClientDlg::OnDisConnect(void* pOwner)

{

//得到父对象指针

CClientDlg* pThis = (CClientDlg*)pOwner;

//发送消息表示客户端连接断开

pThis->PostMessage(WM_TCP_CLIENT_DISCONNECT,0,0);

}

//数据接收事件

void CALLBACK CClientDlg::OnRead(void* pOwner,const char * buf,DWORD dwBufLen )

{

BYTE *pRecvBuf = NULL; //接收缓冲区

//得到父对象指针

CClientDlg* pThis = (CClientDlg*)pOwner;

//将接收的缓冲区拷贝到pRecvBuf种

pRecvBuf = new BYTE[dwBufLen];

CopyMemory(pRecvBuf,buf,dwBufLen);

//发送异步消息，表示收到TCP数据，消息处理完，应释放内存

pThis->PostMessage(WM_RECV_TCP_DATA,WPARAM(pRecvBuf),dwBufLen);

}

//Socket错误事件

void CALLBACK CClientDlg::OnError(void* pOwner,int nErrorCode)

{

TRACE(L"客户端socket发生错误");

}

//TCP接收数据处理函数

LONG CClientDlg::OnRecvTCPData(WPARAM wParam,LPARAM lParam)

{

CString strOldRecv = L"";

CString strRecv = L"";

//接收到的BUF

CHAR *pBuf = (CHAR*)wParam;

//接收到的BUF长度

DWORD dwBufLen = lParam;

//接收框

CEdit *pEdtRecvMsg = (CEdit*)GetDlgItem(IDC_EDT_RECV);

ASSERT(pEdtRecvMsg != NULL);

//得到接收框中的历史文本

pEdtRecvMsg->GetWindowTextW(strOldRecv);

//

strRecv = CString(pBuf);

//将新接收到的文本添加到接收框中

strOldRecv = strOldRecv + strRecv + L"/r/n";

pEdtRecvMsg->SetWindowTextW(strOldRecv);

//释放内存

delete[] pBuf;

pBuf = NULL;

return 0;

}

//客户端连接断开消息函数

LONG CClientDlg::OnClientDisconnect(WPARAM wParam,LPARAM lParam)

{

//得到状态栏标签

CStatic * pStatus = (CStatic *)GetDlgItem(IDC_LBL_CONNSTATUS);

ASSERT(pStatus != NULL);

pStatus->SetWindowText(_T("连接断开"));

return 0;

}

void CClientDlg::OnBnClickedBtnConn()

{

// TODO: Add your control notification handler code here

UpdateData(TRUE);

CStatic *pStatus = (CStatic*)GetDlgItem(IDC_LBL_CONNSTATUS);

ASSERT(pStatus != NULL);

//设置m_tcpClient属性

m_tcpClient.m_remoteHost = m_remoteHost;

m_tcpClient.m_port = m_remotePort;

m_tcpClient.OnDisConnect = OnDisConnect;

m_tcpClient.OnRead = OnRead;

m_tcpClient.OnError = OnError;

//打开客户端socket

m_tcpClient.Open(this);

//建立与服务器端连接

if (m_tcpClient.Connect())

{

pStatus->SetWindowText(L"建立连接");

UpdateData(FALSE);

}

else

{

AfxMessageBox(_T("建立连接失败"));

pStatus->SetWindowText(L"连接断开");

return;

}

}

void CClientDlg::OnBnClickedBtnDisconn()

{

// TODO: Add your control notification handler code here

CStatic *pStatus = (CStatic*)GetDlgItem(IDC_LBL_CONNSTATUS);

ASSERT(pStatus != NULL);

//关闭客户端套接字

if (m_tcpClient.Close())

{

pStatus->SetWindowText(L"连接断开");

}

else

{

AfxMessageBox(_T("连接断开失败"));

}

}

void CClientDlg::OnBnClickedBtnSenddata()

{

// TODO: Add your control notification handler code here

CString strSendData;

char * sendBuf;

int sendLen=0;

CEdit *pEdtSend = (CEdit*)GetDlgItem(IDC_EDT_SEND);

pEdtSend->GetWindowTextW(strSendData);

//设置发送缓冲区

sendLen = strSendData.GetLength()*2 + 2;

sendBuf = new char[sendLen];

ZeroMemory(sendBuf,sendLen);

wcstombs(sendBuf,strSendData,sendLen);

sendLen = strlen(sendBuf)+1;

//发送数据

if (!m_tcpClient.SendData(sendBuf,sendLen))

{

AfxMessageBox(_T("发送失败"));

}

//释放内存

delete[] sendBuf;

sendBuf = NULL;

}

//得到本地的IP地址

CString CClientDlg::GetLocalIP()

{

HOSTENT *LocalAddress;

char *Buff;

TCHAR *wBuff;

CString strReturn = _T("");

//创建新的缓冲区

Buff = new char[256];

wBuff = new TCHAR[256];

//置空缓冲区

memset(Buff, '/0', 256);

memset(wBuff, TEXT('/0'), 256*sizeof(TCHAR));

//得到本地计算机名

if (gethostname(Buff, 256) == 0)

{

//转换成双字节字符串

mbstowcs(wBuff, Buff, 256);

//得到本地地址

LocalAddress = gethostbyname(Buff);

//置空buff

memset(Buff, '/0', 256);

//组合本地IP地址

sprintf(Buff, "%d.%d.%d.%d/0", LocalAddress->h_addr_list[0][0] & 0xFF,

LocalAddress->h_addr_list[0][1] & 0x00FF, LocalAddress->h_addr_list[0][2] & 0x0000FF, LocalAddress->h_addr_list[0][3] & 0x000000FF);

//置空wBuff

memset(wBuff, TEXT('/0'), 256*sizeof(TCHAR));

//转换成双字节字符串

mbstowcs(wBuff, Buff, 256);

//设置返回值

strReturn = wBuff;

}

else

{

}

//释放Buff缓冲区

delete[] Buff;

Buff = NULL;

//释放wBuff缓冲区

delete[] wBuff;

wBuff = NULL;

return strReturn;

}

3：服务端Socket操作1

class CTCPCustom_CE

{

public:

CTCPCustom_CE(void);

~CTCPCustom_CE(void);

private:

//通讯线程函数

static DWORD SocketThreadFunc(PVOID lparam);

public:

//打开socket，创建通讯线程

BOOL Open(CTCPServer_CE *pTCPServer);

//关闭socket，关闭线程，释放Socket资源

BOOL Close();

public:

//发送数据

BOOL SendData(const char * buf , DWORD dwBufLen);

public:

CTCPServer_CE * m_pTCPServer_CE; //引用TCP服务端监听Socket

CString m_RemoteHost; //远程主机IP地址

DWORD m_RemotePort; //远程主机端口号

SOCKET m_socket; //通讯Socket句柄

private:

HANDLE m_exitThreadEvent; //通讯线程退出事件句柄

HANDLE m_tcpThreadHandle; //通讯线程句柄

};

CTCPCustom_CE::CTCPCustom_CE(void)

{

}

CTCPCustom_CE::~CTCPCustom_CE(void)

{

}

/*----------------------------------------------------------------

【函数介绍】: 此线程用于监听与客户端连接的socket通讯的事件，例如当接收到数据、

连接断开和通讯过程发生错误等事件

【入口参数】: lparam:无类型指针，可以通过此参数，向线程中传入需要用到的资源。

在这里我们将CTCPCustom_CE类实例指针传进来

【出口参数】: (无)

【返回 值】: 返回值没有特别的意义，在此我们将返回值设为。

-----------------------------------------------------------------*/

DWORD CTCPCustom_CE::SocketThreadFunc(PVOID lparam)

{

CTCPCustom_CE *pSocket;

//得到CTCPCustom类实例指针

pSocket = (CTCPCustom_CE*)lparam;

//定义读事件集合

fd_set fdRead;

int ret;

TIMEVAL aTime;

aTime.tv_sec = 1;

aTime.tv_usec = 0;

while (TRUE)

{

//收到退出事件，结束线程

if (WaitForSingleObject(pSocket->m_exitThreadEvent,0) == WAIT_OBJECT_0)

{

break;

}

//置空读事件集合

FD_ZERO(&fdRead);

//给pSocket设置读事件

FD_SET(pSocket->m_socket,&fdRead);

//调用select函数，判断是否有读事件发生

ret = select(0,&fdRead,NULL,NULL,&aTime);

if (ret == SOCKET_ERROR)

{

if (pSocket->m_pTCPServer_CE->OnClientError)

{

//触发错误事件

pSocket->m_pTCPServer_CE->OnClientError(pSocket->m_pTCPServer_CE->m_pOwner,pSocket,1);

}

//关闭socket

closesocket(pSocket->m_socket);

break;

}

if (ret > 0)

{

//判断是否读事件

if (FD_ISSET(pSocket->m_socket,&fdRead))

{

char recvBuf[1024];

int recvLen;

ZeroMemory(recvBuf,1024);

recvLen = recv(pSocket->m_socket,recvBuf, 1024,0);

if (recvLen == SOCKET_ERROR)

{

int nErrorCode = WSAGetLastError();

//触发与客户端端连接的Socket错误

if (pSocket->m_pTCPServer_CE->OnClientError)

{

pSocket->m_pTCPServer_CE->OnClientError(pSocket->m_pTCPServer_CE->m_pOwner,pSocket,nErrorCode);

}

//触发与客户端端连接的Socket关闭事件

if (pSocket->m_pTCPServer_CE->OnClientClose)

{

pSocket->m_pTCPServer_CE->OnClientClose(pSocket->m_pTCPServer_CE->m_pOwner,pSocket);

}

//关闭socket

closesocket(pSocket->m_socket);

//移出客户端

pSocket->m_pTCPServer_CE->RemoteClient(pSocket);

break;

}

//表示连接已经从容关闭

else if (recvLen == 0)

{

if (pSocket->m_pTCPServer_CE->OnClientClose)

{

pSocket->m_pTCPServer_CE->OnClientClose(pSocket->m_pTCPServer_CE->m_pOwner,pSocket);

}

//关闭socket

closesocket(pSocket->m_socket);

//移出客户端

pSocket->m_pTCPServer_CE->RemoteClient(pSocket);

break;

}

else

{

//触发与客户端端连接的Socket读事件

if (pSocket->m_pTCPServer_CE->OnClientRead)

{

pSocket->m_pTCPServer_CE->OnClientRead(pSocket->m_pTCPServer_CE->m_pOwner,pSocket,recvBuf,recvLen);

}

}

}

}

}

TRACE(L"客户端线程退出/n");

return 0;

}

/*-----------------------------------------------------------------

【函数介绍】: 打开socket，创建通讯线程

【入口参数】: pTCPServer指向服务器端监听socket

【出口参数】: (无)

【返回 值】: TRUE:打开成功;FALSE:打开失败

------------------------------------------------------------------*/

BOOL CTCPCustom_CE::Open(CTCPServer_CE *pTCPServer)

{

CString strEvent;

strEvent.Format(L"EVENT_CLIENT_THREAD_EXIT %d",m_socket);

//创建线程退出事件

m_exitThreadEvent = CreateEvent(NULL,FALSE,FALSE,strEvent);

//创建通讯线程

m_tcpThreadHandle = CreateThread(NULL,0,SocketThreadFunc,this,0,NULL);

if (m_tcpThreadHandle == NULL)

{

closesocket(m_socket);

return FALSE;

}

//设置通讯模式为异步模式

DWORD ul= 1;

ioctlsocket(m_socket,FIONBIO,&ul);

m_pTCPServer_CE = pTCPServer;

return TRUE;

}

/*-----------------------------------------------------------------

【函数介绍】: 关闭socket，关闭线程，释放Socket资源

【入口参数】: (无)

【出口参数】: (无)

【返回 值】: TRUE:成功关闭;FALSE:关闭失败

------------------------------------------------------------------*/

BOOL CTCPCustom_CE::Close()

{

//发送通讯线程结束事件

SetEvent(m_exitThreadEvent);

//等待秒，如果读线程没有退出，则强制退出

if (WaitForSingleObject(m_tcpThreadHandle,1000) == WAIT_TIMEOUT)

{

TerminateThread(m_tcpThreadHandle,0);

TRACE(L"强制终止客户端线程/n");

}

m_tcpThreadHandle = NULL;

//关闭句柄

CloseHandle(m_exitThreadEvent);

//关闭Socket，释放资源

int err = closesocket(m_socket);

if (err == SOCKET_ERROR)

{

return FALSE;

}

TRACE(L"客户端对象被成功关闭/n");

return TRUE;

}

/*-----------------------------------------------------------------

【函数介绍】: 向客户端发送数据

【入口参数】: buf:待发送的数据

dwBufLen:待发送的数据长度

【出口参数】: (无)

【返回 值】: TRUE:发送数据成功;FALSE:发送数据失败

------------------------------------------------------------------*/

BOOL CTCPCustom_CE::SendData(const char * buf , DWORD dwBufLen)

{

int nBytes = 0;

int nSendBytes=0;

while (nSendBytes < dwBufLen)

{

nBytes = send(m_socket,buf+nSendBytes,dwBufLen-nSendBytes,0);

if (nBytes==SOCKET_ERROR )

{

int iErrorCode = WSAGetLastError();

//触发socket的Error事件

if (m_pTCPServer_CE->OnClientError)

{

m_pTCPServer_CE->OnClientError(m_pTCPServer_CE->m_pOwner,this,iErrorCode);

}

//触发与服务器端断开连接事件

if (m_pTCPServer_CE->OnClientClose)

{

m_pTCPServer_CE->OnClientClose(m_pTCPServer_CE->m_pOwner,this);

}

//关闭socket

Close();

return FALSE;

}

nSendBytes = nSendBytes + nBytes;

if (nSendBytes < dwBufLen)

{

Sleep(1000);

}

}

return TRUE;

}

4：Socket操作类2

class CTCPCustom_CE;

class CTCPServer_CE;

//定义客户端连接建立事件

typedef void (CALLBACK* ONCLIENTCONNECT)(void* pOwner,CTCPCustom_CE*);

//定义客户端SOCKET关闭事件

typedef void (CALLBACK* ONCLIENTCLOSE)(void* pOwner,CTCPCustom_CE*);

//定义客户端当有数据接收事件

typedef void (CALLBACK* ONCLIENTREAD)(void* pOwner,CTCPCustom_CE*,const char * buf,DWORD dwBufLen );

//定义客户端Socket错误事件

typedef void (CALLBACK* ONCLIENTERROR)(void* pOwner,CTCPCustom_CE*,int nErrorCode);

//定义服务器端Socket错误事件

typedef void (CALLBACK* ONSERVERERROR)(void* pOwner,CTCPServer_CE*,int nErrorCode);

class CTCPServer_CE

{

public:

CTCPServer_CE(void);

~CTCPServer_CE(void);

public:

int m_LocalPort; //设置服务端口号

void * m_pOwner; //父对象句柄

private:

SOCKET m_ServerSocket; //TCP服务监听socket

HANDLE m_serverThreadHandle; //通讯线程句柄

HANDLE m_exitThreadEvent; //通讯线程退出事件句柄

public: //定义事件

//客户端连接建立事件，回调函数

ONCLIENTCONNECT OnClientConnect;

//客户端连接断开事件，回调函数

ONCLIENTCLOSE OnClientClose;

//客户端接收数据事件，回调函数

ONCLIENTREAD OnClientRead;

//客户端发生错误事件，回调函数

ONCLIENTERROR OnClientError;

//服务器端发生错误事件,回调函数

ONSERVERERROR OnServerError;

private:

//TCP服务器监听线程函数

static DWORD SocketThreadFunc(PVOID lparam);

public:

//删除客户端对象

void RemoteClient(CTCPCustom_CE *pClient /*客户端对象*/);

public:

//打开TCP服务

int Open();

public:

//关闭TCP服务

int Close();

public:

//发送数据

BOOL SendData(CTCPCustom_CE* pCustomCE, const char * buf , DWORD dwBufLen);

};

#include "TCPServer_CE.h"

#include "TCPCustom_CE.h"

#include <afxtempl.h>

//存储客户端Socket句柄

CPtrList m_ListClientSocket;

//构造函数

CTCPServer_CE::CTCPServer_CE()

{

//创建线程退出事件句柄

m_exitThreadEvent = CreateEvent(NULL,FALSE,FALSE,L"EVENT_SERVER_THREAD_QUIT");

//客户端连接建立事件，回调函数

OnClientConnect = NULL;

//客户端连接断开事件，回调函数

OnClientClose = NULL;

//客户端接收数据事件，回调函数

OnClientRead = NULL;

//客户端发生错误事件，回调函数

OnClientError = NULL;

//服务器端发生错误事件,回调函数

OnServerError = NULL;

}

//析构函数

CTCPServer_CE::~CTCPServer_CE()

{

//关闭线程退出事件句柄

CloseHandle(m_exitThreadEvent);

}

/*-----------------------------------------------------------------

【函数介绍】: 此线程用于检测监听套接字事件。

【入口参数】: lparam:无类型指针，可以通过此参数，向线程中传入需要用到的资源。

在这里我们将CTCPServer_CE类实例指针传进来

【出口参数】: (无)

【返回 值】: 返回值没有特别的意义，在此我们将返回值设为。

------------------------------------------------------------------*/

DWORD CTCPServer_CE::SocketThreadFunc(PVOID lparam)

{

CTCPServer_CE *pSocket;

//得到CTCPServer_CE实例指针

pSocket = (CTCPServer_CE*)lparam;

//定义读事件集合

fd_set fdRead;

int ret;

TIMEVAL aTime;

aTime.tv_sec = 1;

aTime.tv_usec = 1;

while (TRUE)

{

//收到退出事件，结束线程

if (WaitForSingleObject(pSocket->m_exitThreadEvent,0) == WAIT_OBJECT_0)

{

break;

}

FD_ZERO(&fdRead);

FD_SET(pSocket->m_ServerSocket,&fdRead);

//监听事件

ret = select(0,&fdRead,NULL,NULL,&aTime);

if (ret == SOCKET_ERROR)

{

//触发错误事件

int iErrorCode = WSAGetLastError();

//触发服务器socket的错误事件

if (pSocket->OnServerError)

{

pSocket->OnServerError(pSocket->m_pOwner,pSocket,iErrorCode);

}

//关闭服务器套接字

closesocket(pSocket->m_ServerSocket);

break;

}

if (ret > 0)

{

//判断是否读事件

if (FD_ISSET(pSocket->m_ServerSocket,&fdRead))

{

//如果调用了Listen，则表示触发了OnAccept事件

SOCKADDR_IN clientAddr;

CTCPCustom_CE * pClientSocket = new CTCPCustom_CE();

int namelen = sizeof(clientAddr);

//等待，创建与客户端连接的套接字

pClientSocket->m_socket = accept(pSocket->m_ServerSocket, (struct sockaddr *)&clientAddr, &namelen);

//接收到客户端连接

if (pClientSocket->m_socket)

{

pClientSocket->m_RemoteHost = inet_ntoa(clientAddr.sin_addr);

pClientSocket->m_RemotePort = ntohs(clientAddr.sin_port);

//触发与客户端建立连接事件

if (pSocket->OnClientConnect)

{

pSocket->OnClientConnect(pSocket->m_pOwner,pClientSocket);

}

//打开pClientSocket服务线程

pClientSocket->Open(pSocket);

//添加到客户端连接队列中

m_ListClientSocket.AddTail(pClientSocket);

}

else

{

//失败，释放内存

delete pClientSocket;

pClientSocket = NULL;

}

}

}

}

//

TRACE(L"服务器端线程退出/n");

return 0;

}

//删除客户端

void CTCPServer_CE::RemoteClient(CTCPCustom_CE *pClient /*客户端对象*/)

{

POSITION posPrior;

POSITION pos = m_ListClientSocket.GetHeadPosition();

while (pos != NULL)

{

posPrior = pos;

CTCPCustom_CE *pTcpCustom = (CTCPCustom_CE*)m_ListClientSocket.GetNext(pos);

if (pTcpCustom == pClient)

{

//释放内存

delete pTcpCustom;

pTcpCustom = NULL;

m_ListClientSocket.RemoveAt(posPrior);

TRACE(L"移出了一个客户端对象/n");

break;

}

}

}

/*------------------------------------------------------------------

【函数介绍】: 打开TCP服务

【入口参数】: (无)

【出口参数】: (无)

【返回 值】: <=0:打开TCP服务失败; =1:打开TCP服务成功

------------------------------------------------------------------*/

int CTCPServer_CE::Open()

{

WSADATA wsa;

//1.初始化socket资源

if (WSAStartup(MAKEWORD(2,2),&wsa) != 0)

{

return -1;//代表失败

}

//2.创建监听套接字

if ((m_ServerSocket=socket(AF_INET, SOCK_STREAM, 0))<0)

{

return -2;

}

SOCKADDR_IN serverAddr;

ZeroMemory((char *)&serverAddr,sizeof(serverAddr));

serverAddr.sin_family = AF_INET;

serverAddr.sin_port = htons(m_LocalPort);

serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

//3.绑定监听套接字

if (bind(m_ServerSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr))<0)

{

return -3 ;

}

//4.监听套接字开始监听

if (listen(m_ServerSocket,8)!=0)

{

return -3;

}

//4.设置监听套接字通讯模式为异步模式

DWORD ul= 1;

ioctlsocket(m_ServerSocket,FIONBIO,&ul);

ResetEvent(m_exitThreadEvent);

//5.创建通讯线程，在线程里，等待客户端接入

m_serverThreadHandle = CreateThread(NULL,0,SocketThreadFunc,this,0,NULL);

if (m_serverThreadHandle == NULL)

{

closesocket(m_ServerSocket);

return -1;

}

return 1;

}

/*-----------------------------------------------------------------

【函数介绍】: 关闭TCP服务

【入口参数】: (无)

【出口参数】: (无)

【返回 值】: <=0:关闭TCP服务失败; =1:关闭TCP服务成功

------------------------------------------------------------------*/

int CTCPServer_CE::Close()

{

//结束通讯线程

SetEvent(m_exitThreadEvent);

//等待秒，如果读线程没有退出，则强制退出

if (WaitForSingleObject(m_serverThreadHandle,1000) == WAIT_TIMEOUT)

{

TerminateThread(m_serverThreadHandle,0);

TRACE(L"强制终止服务器端线程/n");

}

m_serverThreadHandle = NULL;

//关闭Socket，释放资源

int err = closesocket(m_ServerSocket);

if (err == SOCKET_ERROR)

{

return -1;

}

//首先，关闭与所有客户端连接

POSITION pos = m_ListClientSocket.GetHeadPosition();

while (pos != NULL)

{

//得到客户端对象

CTCPCustom_CE *pTcpCustom = (CTCPCustom_CE*)m_ListClientSocket.GetNext(pos);

if (!pTcpCustom->Close())

{

TRACE(L"关闭客户端socket错误");

}

//释放内存

delete pTcpCustom;

pTcpCustom = NULL;

}

m_ListClientSocket.RemoveAll();

WSACleanup();

return 1;

}

/*-----------------------------------------------------------------

【函数介绍】: 发送数据

【入口参数】: pCustomCE ：客户端对象指针

buf : 缓冲区

dwBufLen : 缓冲区长度

【出口参数】: (无)

【返回 值】: TRUE : 发送成功；FALSE : 发送失败

------------------------------------------------------------------*/

BOOL CTCPServer_CE::SendData(CTCPCustom_CE* pCustomCE, const char * buf , DWORD dwBufLen)

{

BOOL bResult = FALSE;

BOOL bExisted = FALSE;

if (pCustomCE == NULL)

{

return FALSE;

}

//判断此客户端是否存在

POSITION pos = m_ListClientSocket.GetHeadPosition();

while (pos != NULL)

{

CTCPCustom_CE *pTcpCustom = (CTCPCustom_CE*)m_ListClientSocket.GetNext(pos);

if (pCustomCE == pTcpCustom)

{

bExisted = TRUE;

break;

}

}

if (!bExisted)

{

return FALSE;

}

bResult = pCustomCE->SendData(buf,dwBufLen);

if (!bResult)

{

//

RemoteClient(pCustomCE);

}

return bResult;

}

5：服务端操作类

#include "TCPServer_CE.h"

#include "TCPCustom_CE.h"

//定义通用缓冲区

typedef struct _DATA_BUF

{

DWORD dwBufLen;

char* sBuf;

TCHAR szAddress[MAX_PATH];

}DATA_BUF,*PDATA_BUF;

//定义TCP 收到客户端数据消息

#define WM_RECV_TCP_DATA WM_USER + 101

//定义TCP客户端连接消息

#define WM_TCP_CLIENT_CONNECT WM_USER + 102

ON_MESSAGE(WM_RECV_TCP_DATA,OnRecvTCPData)

ON_MESSAGE(WM_TCP_CLIENT_CONNECT,OnClientConnect)

//TCP接收数据处理函数

afx_msg LONG OnRecvTCPData(WPARAM wParam,LPARAM lParam);

//客户端连接断开消息函数

afx_msg LONG OnClientConnect(WPARAM wParam,LPARAM lParam);

private:

//定义CTCPClient_CE对象

CTCPClient_CE m_tcpClient;

private:

//定义CTCPServer_CE对象

CTCPServer_CE m_tcpServer;

private:

//客户端连接建立事件处理函数

static void CALLBACK OnClientConnect(void* pOwner,CTCPCustom_CE *pTcpCustom);

//客户端SOCKET关闭事件处理函数

static void CALLBACK OnClientClose(void* pOwner,CTCPCustom_CE*pTcpCustom);

//服务器端收到来自客户端的数据

static void CALLBACK OnClientRead(void* pOwner,CTCPCustom_CE* pTcpCustom,const char * buf,DWORD dwBufLen );

//客户端Socket错误事件处理函数

static void CALLBACK OnClientError(void* pOwner,CTCPCustom_CE* pTcpCustom,int nErrorCode);

//服务器端Socket错误事件处理函数

static void CALLBACK OnServerError(void* pOwner,CTCPServer_CE* pTcpServer_CE,int nErrorCode);

//客户端连接建立事件处理函数

void CALLBACK CServerDlg::OnClientConnect(void* pOwner,CTCPCustom_CE* pTcpCustom)

{

TCHAR *szAddress =NULL;

DWORD dwBufLen = pTcpCustom->m_RemoteHost.GetLength() + 1;

szAddress = new TCHAR[dwBufLen];

ZeroMemory(szAddress,dwBufLen*2);

//拷贝内存，得到客户端IP地址

wcscpy(szAddress,pTcpCustom->m_RemoteHost);

CServerDlg *pThis = (CServerDlg*)pOwner;

//发送异步消息，表示有客户端连接，消息处理完后，需要释放内存

pThis->PostMessage(WM_TCP_CLIENT_CONNECT,0,LPARAM(szAddress));

}

//客户端SOCKET关闭事件处理函数

void CALLBACK CServerDlg::OnClientClose(void* pOwner,CTCPCustom_CE* pTcpCustom)

{

TCHAR *szAddress =NULL;

DWORD dwBufLen = pTcpCustom->m_RemoteHost.GetLength() + 1;

szAddress = new TCHAR[dwBufLen];

ZeroMemory(szAddress,dwBufLen*2);

//拷贝内存，得到客户端IP地址

wcscpy(szAddress,pTcpCustom->m_RemoteHost);

CServerDlg *pThis = (CServerDlg*)pOwner;

//发送异步消息，表示有客户端连接，消息处理完后，需要释放内存

pThis->PostMessage(WM_TCP_CLIENT_CONNECT,1,LPARAM(szAddress));

}

//服务器端收到来自客户端的数据

void CALLBACK CServerDlg::OnClientRead(void* pOwner,CTCPCustom_CE* pTcpCustom,const char * buf,DWORD dwBufLen )

{

DATA_BUF *pGenBuf = new DATA_BUF;

char *pRecvBuf = NULL; //接收缓冲区

//得到父对象指针

CServerDlg* pThis = (CServerDlg*)pOwner;

//将接收的缓冲区拷贝到pRecvBuf种

pRecvBuf = new char[dwBufLen];

CopyMemory(pRecvBuf,buf,dwBufLen);

ZeroMemory(pGenBuf,sizeof(DATA_BUF));

pGenBuf->dwBufLen = dwBufLen;

pGenBuf->sBuf = pRecvBuf;

//

wcscpy(pGenBuf->szAddress,pTcpCustom->m_RemoteHost);

//发送异步消息，表示收到TCP数据，消息处理完，应释放内存

pThis->PostMessage(WM_RECV_TCP_DATA,WPARAM(pGenBuf),LPARAM(pTcpCustom));

}

//客户端Socket错误事件处理函数

void CALLBACK CServerDlg::OnClientError(void* pOwner,CTCPCustom_CE* pTcpCustom,int nErrorCode)

{

}

//服务器端Socket错误事件处理函数

void CALLBACK CServerDlg::OnServerError(void* pOwner,CTCPServer_CE* pTcpServer_CE,int nErrorCode)

{

}

//TCP接收数据处理函数

LONG CServerDlg::OnRecvTCPData(WPARAM wParam,LPARAM lParam)

{

DATA_BUF *pGenBuf = (DATA_BUF*)wParam; //通用缓冲区

CTCPCustom_CE* pTcpCustom= (CTCPCustom_CE* )lParam; //TCP客户端对象

//接收显示列表

CListBox * pLstRecv = (CListBox*)GetDlgItem(IDC_LST_RECV);

ASSERT(pLstRecv != NULL);

//接收到的数据

CString strRecv;

CString strLen;

strLen.Format(L"%d",pGenBuf->dwBufLen);

strRecv = CString(pGenBuf->sBuf);

pLstRecv->AddString(_T("************************************"));

pLstRecv->AddString(_T("来自: ") + CString(pGenBuf->szAddress) );

pLstRecv->AddString(_T("数据长度:")+strLen);

pLstRecv->AddString(strRecv);

//发送回应命令

if (!m_tcpServer.SendData(pTcpCustom,"recv ok",strlen("recv ok")))

{

AfxMessageBox(_T("发送失败"));

}

//释放内存

delete[] pGenBuf->sBuf;

pGenBuf->sBuf = NULL;

delete pGenBuf;

pGenBuf = NULL;

return 0;

}

//客户端连接断开消息函数

LONG CServerDlg::OnClientConnect(WPARAM wParam,LPARAM lParam)

{

int iIndex;

TCHAR *szAddress = (TCHAR*)lParam;

CString strAddrss = szAddress;

CListBox * pLstConn = (CListBox*)GetDlgItem(IDC_LST_CONN);

ASSERT(pLstConn != NULL);

if (wParam == 0)

{

pLstConn->AddString(strAddrss + _T("建立连接"));

}

else

{

iIndex = pLstConn->FindString(iIndex,strAddrss + _T("建立连接"));

if (iIndex != LB_ERR)

{

pLstConn->DeleteString(iIndex);

}

}

//释放内存

delete[] szAddress;

szAddress = NULL;

return 0;

}

//监听

void CServerDlg::OnBnClickedBtnListen()

{

UpdateData(TRUE);

//设置m_tcpServer属性

m_tcpServer.m_LocalPort = m_localPort;

m_tcpServer.m_pOwner = this;

m_tcpServer.OnClientConnect = OnClientConnect;

m_tcpServer.OnClientClose = OnClientClose;

m_tcpServer.OnClientRead = OnClientRead;

m_tcpServer.OnClientError = OnClientError;

m_tcpServer.OnServerError = OnServerError;

if (m_tcpServer.Open() <= 0)

{

AfxMessageBox(_T("监听失败"));

return;

}

}

//关闭

void CServerDlg::OnBnClickedBtnClose()

{

CListBox * pLstConn = (CListBox*)GetDlgItem(IDC_LST_CONN);

ASSERT(pLstConn != NULL);

CListBox * pLstRecv = (CListBox*)GetDlgItem(IDC_LST_RECV);

ASSERT(pLstRecv != NULL);

//

if (m_tcpServer.Close() <=0)

{

AfxMessageBox(_T("关闭TCP服务器失败"));

return;

}

//清空列表

pLstConn->ResetContent();

pLstRecv->ResetContent();

}