一：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();
}
TCPIP编程
最新推荐文章于 2024-03-02 00:45:46 发布
1352
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
