VC下Socket多线程通讯类
/*
public:
void SendServerUDP(CString NewInfo);
void SendClientUDP(CString NewInfo);
CString GetLocalIP();
CString GetLocalHost();
int GetUDPPort();
bool SetUDPIP(CString NewIP);
bool SetUDPPort(int NewPort);
bool CloseUDPClient();
bool CloseUDPServer();
bool CreateUDPClient();
bool CreateUDPServer();
void SendServerTCP(CString NewInfo);
void SendClientTCP(CString NewInfo);
bool SetTCPIP(CString NewIP);
int GetTCPPort();
bool SetTCPPort(int NewPort);
bool CloseTCPClient();
bool CloseTCPServer();
bool CreateTCPClient();
bool CreateTCPServer();
*/
#define hui //显示提示信息
//客户端登陆信息结构
typedef struct _CLIENT_INFORMATION
{
char User[64]; //客户端主机名
char IP[64]; //客户端IP
char Type[20]; //指令类型(USERINFORMATION: 客户端信息)
int Data; //指令数据(1:客户登陆、0:客户退出)
}CLIENT_INFORMATION;
//TCP(Socket)指针结构
typedef struct _SERVICE_TCP_PARM
{
int SocketService; //Windows Socket
CLIENT_INFORMATION Userinfo; //客户端信息
}SERVICE_TCP_PARM;
//服务器发送TCP数据包结构
typedef struct _SERVER_TCP_SEND_MESSAGE
{
char Mag[20];
char Type[20]; //指令类型（保留）
int Data; //指令数据（保留）
SERVICE_TCP_PARM User;
}SERVER_TCP_SEND_MESSAGE;
//客户端发送TCP数据包结构
typedef struct _CLIENT_TCP_SEND_MESSAGE
{
char Mag[20];
char Type[20]; //指令类型（保留）
int Data; //指令数据（保留）
SERVICE_TCP_PARM User;
}CLIENT_TCP_SEND_MESSAGE;
//UDP(Socket)指针结构
typedef struct _SERVICE_UDP_PARM
{
int SocketService; //Windows Socket
CLIENT_INFORMATION Userinfo; //客户端信息
}SERVICE_UDP_PARM;
//UDP(Socket)指针结构
typedef struct _SERVICE_UDP_LIST
{
int SocketService; //Windows Socket
CLIENT_INFORMATION Userinfo; //客户端信息
struct sockaddr_in FromAddr; //客户端地址
}SERVICE_UDP_LIST;
//服务器发送UDP数据包结构
typedef struct _SERVER_UDP_SEND_MESSAGE
{
char Mag[20];
char Type[20]; //指令类型（保留）
int Data; //指令数据（保留）
SERVICE_TCP_PARM User;
}SERVER_UDP_SEND_MESSAGE;
//客户端发送UDP数据包结构
typedef struct _CLIENT_UDP_SEND_MESSAGE
{
char Mag[20];
char Type[20]; //指令类型（保留）
int Data; //指令数据（保留）
SERVICE_TCP_PARM User;
}CLIENT_UDP_SEND_MESSAGE;
SERVICE_TCP_PARM* p_TCP_Server; //服务器TCP传送指针结构
SERVICE_TCP_PARM* p_TCP_Client; //客户端TCP传送指针结构
SERVICE_UDP_PARM* p_UDP_Server; //服务器UDP传送指针结构
SERVICE_UDP_PARM* p_UDP_Client; //客户端UDP传送指针结构
bool g_End_TCP_Proc=false; //TCP服务器/客户端终止标志(true：终止)
bool g_Server_TCP_Work=false; //TCP服务器工作标志(true：工作中)
bool g_Client_TCP_Work=false; //TCP客户端工作标志(true：工作中)
bool g_End_UDP_Proc=false; //UDP服务器/客户端终止标志(true：终止)
bool g_Server_UDP_Work=false; //UDP服务器工作标志(true：工作中)
bool g_Client_UDP_Work=false; //UDP客户端工作标志(true：工作中)
std::list<SERVICE_TCP_PARM> g_TCP_Lists; //登陆用户列表
SERVICE_TCP_PARM g_TCP_List;
std::list<SERVICE_UDP_LIST> g_UDP_Lists; //登陆用户列表
SERVICE_UDP_LIST g_UDP_List;
UINT Server_TCP_Service_Proc(LPVOID p);
UINT Server_TCP_Select_Proc(LPVOID p);
UINT Cilent_TCP_Select_Proc(LPVOID p);
UINT Server_UDP_Select_Proc(LPVOID p);
UINT Cilent_UDP_Select_Proc(LPVOID p);
/////////////////////////////////////////////////////////////////////////////
// CMySocket
CMySocket::CMySocket()
{
if (!AfxSocketInit())
{
AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
return ;
}
}
CMySocket::~CMySocket()
{
}
// Do not edit the following lines, which are needed by ClassWizard.
#if 0
BEGIN_MESSAGE_MAP(CMySocket, CSocket)
//{{AFX_MSG_MAP(CMySocket)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
#endif // 0
/////////////////////////////////////////////////////////////////////////////
// CMySocket member functions
bool CMySocket::CreateTCPServer()
{
try
{
::g_End_TCP_Proc=false;
struct sockaddr_in sock_addr;
sock_addr.sin_family=AF_INET;
sock_addr.sin_port=htons(m_TCP_PORT);
sock_addr.sin_addr.S_un.S_addr=inet_addr(m_TCP_IP);
p_TCP_Server=(SERVICE_TCP_PARM*)malloc(sizeof(SERVICE_TCP_PARM));
p_TCP_Server->SocketService=socket(AF_INET,SOCK_STREAM,0);//TCP:SOCK_STREAM、UDP:SOCK_DGRAM
if(p_TCP_Server->SocketService==INVALID_SOCKET)
{
free(p_TCP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 建立Socket失败/t");
#endif
return false;
}
if(bind(p_TCP_Server->SocketService,(struct sockaddr*)&sock_addr,sizeof(sockaddr))!=0)
{
closesocket(p_TCP_Server->SocketService);
free(p_TCP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 绑定Socket失败/t");
#endif
return false;
}
if(listen(p_TCP_Server->SocketService,100) != 0)//客户端总数
{
closesocket(p_TCP_Server->SocketService);
free(p_TCP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 监听Socket失败/t");
#endif
return false;
}
if(AfxBeginThread(Server_TCP_Service_Proc,p_TCP_Server)==NULL)
{
closesocket(p_TCP_Server->SocketService);
free(p_TCP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 启动失败/t");
#endif
return false;
}else
{
#ifdef hui
// AfxMessageBox("<服务器>/n/n提示信息: 启动成功/t");
#endif
}
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::CreateTCPClient()
{
try
{
::g_End_TCP_Proc=false;
//设置连接服务器信息
struct sockaddr_in sock_addr;
sock_addr.sin_family=AF_INET;
sock_addr.sin_port=htons(m_TCP_PORT);
sock_addr.sin_addr.S_un.S_addr=inet_addr(m_TCP_IP);
//建立连接
p_TCP_Client=(SERVICE_TCP_PARM*)malloc(sizeof(SERVICE_TCP_PARM));
p_TCP_Client->SocketService=socket(AF_INET,SOCK_STREAM,0);//TCP:SOCK_STREAM、UDP:SOCK_DGRAM
if(connect(p_TCP_Client->SocketService,(sockaddr*)&sock_addr,sizeof(sock_addr)))
{
free(p_TCP_Client);
#ifdef hui
AfxMessageBox("<客户端>/n/n提示信息: 无法连接到指定服务器/t");
#endif
return false;
}
//取得本机信息
strcpy(p_TCP_Client->Userinfo.IP,GetLocalIP());
strcpy(p_TCP_Client->Userinfo.User,GetLocalHost());
strcpy(p_TCP_Client->Userinfo.Type,"NULL");
p_TCP_Client->Userinfo.Data=0;
//创建客户端线程
if(AfxBeginThread(Cilent_TCP_Select_Proc,p_TCP_Client)==NULL)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n提示信息: 启动失败/t");
#endif
free(p_TCP_Client);
return false;
}else
{
#ifdef hui
// AfxMessageBox("<客户端>/n/n/n提示信息: 启动成功/t");
#endif
}
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::CloseTCPServer()
{
try
{
::g_End_TCP_Proc=true;
Sleep(200);
if (::g_Server_TCP_Work==true)
{
std::list<SERVICE_TCP_PARM>::iterator it_user;
for(it_user = g_TCP_Lists.begin();it_user != g_TCP_Lists.end();it_user++)
{
closesocket(it_user->SocketService);
}
closesocket(p_TCP_Server->SocketService);
}
free(p_TCP_Server);
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::CloseTCPClient()
{
try
{
::g_End_TCP_Proc=true;
Sleep(200);
if (::g_Client_TCP_Work==true)
{
closesocket(p_TCP_Client->SocketService);
}
free(p_TCP_Client);
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::SetTCPPort(int NewPort)
{
try
{
m_TCP_PORT=(int)NewPort;
return true;
}catch (_com_error e)
{
return false;
}
}
int CMySocket::GetTCPPort()
{
try
{
return m_TCP_PORT;
}catch (_com_error e)
{
return 0;
}
}
bool CMySocket::SetTCPIP(CString NewIP)
{
try
{
m_TCP_IP=(CString)NewIP;
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::CreateUDPServer()
{
try
{
::g_End_UDP_Proc=false;
//建立接收端口
struct sockaddr_in sock_addr;
sock_addr.sin_family=AF_INET;
sock_addr.sin_port=htons(m_UDP_PORT);
sock_addr.sin_addr.S_un.S_addr=inet_addr(m_UDP_IP);
p_UDP_Server=(SERVICE_UDP_PARM*)malloc(sizeof(SERVICE_UDP_PARM));
p_UDP_Server->SocketService=socket(AF_INET,SOCK_DGRAM,0);//TCP:SOCK_STREAM、UDP:SOCK_DGRAM
if(p_UDP_Server->SocketService==INVALID_SOCKET)
{
free(p_UDP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 建立Socket失败/t");
#endif
return false;
}
/* //允许端口复用
BOOL Temp = TRUE;
if(int e=setsockopt(p_UDP_Server->SocketService, SOL_SOCKET, SO_REUSEADDR, (const char *)&Temp, sizeof(BOOL)))
{
closesocket(p_UDP_Server->SocketService);
free(p_UDP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 设置Socket失败/t");
#endif
return false;
}
// 允许发送广播
if(int e=setsockopt(p_UDP_Server->SocketService, SOL_SOCKET, SO_BROADCAST, (const char *)&Temp, sizeof(BOOL)))
{
closesocket(p_UDP_Server->SocketService);
free(p_UDP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 设置Socket失败/t");
#endif
return false;
}
*/
if(bind(p_UDP_Server->SocketService,(struct sockaddr*)&sock_addr,sizeof(sockaddr))!=0)
{
closesocket(p_UDP_Server->SocketService);
free(p_UDP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 绑定Socket失败/t");
#endif
return false;
}
//建立发送端口
/* struct sockaddr_in destaddr;
memset( &destaddr, 0, sizeof(sockaddr_in) );
destaddr.sin_family = AF_INET;
destaddr.sin_addr.S_un.S_addr = inet_addr("255.255.255.255");
destaddr.sin_port = ntohs(theDlg->m_MySocket.m_UDP_PORT);
*/
/*
p_UDP_Server_SEND=(SERVICE_UDP_PARM*)malloc(sizeof(SERVICE_UDP_PARM));
p_UDP_Server_SEND->SocketService=socket(AF_INET,SOCK_DGRAM,0);//TCP:SOCK_STREAM、UDP:SOCK_DGRAM
if(p_UDP_Server_SEND->SocketService==INVALID_SOCKET)
{
free(p_UDP_Server);
free(p_UDP_Server_SEND);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 建立 Socket 失败/t");
#endif
return false;
}
// 允许发送广播
if(int e=setsockopt(p_UDP_Server_SEND->SocketService, SOL_SOCKET, SO_BROADCAST, (const char *)&Temp, sizeof(BOOL)))
{
closesocket(p_UDP_Server_SEND->SocketService);
free(p_UDP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 设置Socket失败/t");
#endif
return false;
}
*/
if(AfxBeginThread(Server_UDP_Select_Proc,p_UDP_Server)==NULL)
{
closesocket(p_UDP_Server->SocketService);
free(p_UDP_Server);
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 启动失败/t");
#endif
return false;
}else
{
#ifdef hui
AfxMessageBox("<服务器>/n/n提示信息: 启动成功/t");
#endif
}
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::CreateUDPClient()
{
try
{
//建立激活信号
::g_End_UDP_Proc=false;
//设置连接服务器信息
struct sockaddr_in sock_addr;
sock_addr.sin_family=AF_INET;
sock_addr.sin_port=htons(m_UDP_PORT);
sock_addr.sin_addr.S_un.S_addr=inet_addr(m_UDP_IP);
//建立连接
p_UDP_Client=(SERVICE_UDP_PARM*)malloc(sizeof(SERVICE_UDP_PARM));
p_UDP_Client->SocketService=socket(AF_INET,SOCK_DGRAM,0);//TCP:SOCK_STREAM、UDP:SOCK_DGRAM
if(connect(p_UDP_Client->SocketService,(sockaddr*)&sock_addr,sizeof(sock_addr)))
{
closesocket(p_UDP_Client->SocketService);
free(p_UDP_Client);
#ifdef hui
AfxMessageBox("<客户端>/n/n提示信息: 无法连接到指定服务器/t");
#endif
return false;
}
//取得本机信息
strcpy(p_UDP_Client->Userinfo.IP,GetLocalIP());
strcpy(p_UDP_Client->Userinfo.User,GetLocalHost());
strcpy(p_UDP_Client->Userinfo.Type,"NULL");
p_UDP_Client->Userinfo.Data=0;
//创建客户端线程
if(AfxBeginThread(Cilent_UDP_Select_Proc,p_UDP_Client)==NULL)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n提示信息: 启动失败/t");
#endif
closesocket(p_UDP_Client->SocketService);
free(p_UDP_Client);
return false;
}else
{
#ifdef hui
AfxMessageBox("<客户端>/n/n/n提示信息: 启动成功/t");
#endif
}
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::CloseUDPServer()
{
try
{
::g_End_UDP_Proc=true;
Sleep(200);
if (::g_Server_UDP_Work==true)
{
//设置本机信息
char userinfo[65535];
::memset(&userinfo, '/0', 65535);
CString info;
info="服务器终止";
strcpy(userinfo,info);//发送的信息
int userinfo_length=info.GetLength ();
std::list<SERVICE_UDP_LIST>::iterator it_user;
for(it_user = g_UDP_Lists.begin();it_user != g_UDP_Lists.end();it_user++)
{
int nSendLen = sendto(it_user->SocketService, (LPSTR)&userinfo,userinfo_length, 0, (struct sockaddr*)&it_user->FromAddr,sizeof(it_user->FromAddr));
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n发送客户信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
closesocket(p_UDP_Server->SocketService);
free(p_UDP_Server);
}
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::CloseUDPClient()
{
try
{
::g_End_UDP_Proc=true;
Sleep(200);
if (::g_Client_UDP_Work==true)
{
//设置本机信息
char userinfo[65535];
::memset(&userinfo, '/0', 65535);
CString info;
info="退出";
strcpy(userinfo,info);//发送的信息
int userinfo_length=info.GetLength ();
//发送本机信息
int nSendLen = send(p_UDP_Client->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n发送信息/n/n/n提示信息: 发送错误/t");
#endif
}
closesocket(p_UDP_Client->SocketService);
free(p_UDP_Client);
}
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::SetUDPPort(int NewPort)
{
try
{
m_UDP_PORT=(int)NewPort;
return true;
}catch (_com_error e)
{
return false;
}
}
bool CMySocket::SetUDPIP(CString NewIP)
{
try
{
m_UDP_IP=(CString)NewIP;
return true;
}catch (_com_error e)
{
return false;
}
}
int CMySocket::GetUDPPort()
{
try
{
return m_UDP_PORT;
}catch (_com_error e)
{
return 0;
}
}
CString CMySocket::GetLocalHost()
{
try
{
char name[32];
int nGethostname;
/*{{hui
int gethostname (
char FAR * name,
int namelen);//取得本机名
hui}}*/
nGethostname = gethostname(name, sizeof(name));
return (CString)name;
}catch (_com_error e)
{
return "NULL";
}
}
CString CMySocket::GetLocalIP()
{
try
{
char name[32];
int nGethostname;
/*{{hui
int gethostname (
char FAR * name,
int namelen);//取得本机名
hui}}*/
nGethostname = gethostname(name, sizeof(name));
if(nGethostname == SOCKET_ERROR)
{
return "127.0.0.1";
}
struct hostent FAR * hostent;
/*{{hui
struct hostent FAR * gethostbyname (const char FAR * name);//取得主机通讯信息
char FAR * inet_ntoa (struct in_addr in);//转换IP地址到字符串
hui}}*/
hostent = gethostbyname(name);
return (CString)inet_ntoa(*((struct in_addr *)hostent->h_addr_list[0]));
}catch (_com_error e)
{
return "127.0.0.1";
}
}
UINT Server_TCP_Service_Proc(LPVOID p)
{
try
{
g_Server_TCP_Work=true;
SERVICE_TCP_PARM *p_Accept=(SERVICE_TCP_PARM*)p;
SOCKET sockets;
sockaddr_in addr;
int addrlen;
while(1)
{
//接收客户端请求
addrlen=sizeof(addr);
sockets=accept(p_Accept->SocketService,(struct sockaddr*)&addr,&addrlen);
//结束服务线程
if(::g_End_TCP_Proc==true)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n/n提示信息: 服务已关闭/t");
#endif
return 0;
}
if(sockets==INVALID_SOCKET)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n/n提示信息: 客户端登陆错误/t");
#endif
break;
}else
{
//启动TCP工作线程
SERVICE_TCP_PARM *p_Temp;
p_Temp = (SERVICE_TCP_PARM *)malloc(sizeof(SERVICE_TCP_PARM));
p_Temp->SocketService=sockets;
strcpy(p_Temp->Userinfo.IP,(CString)inet_ntoa(addr.sin_addr));
SERVER_TCP_SEND_MESSAGE Server_TCP_Message; //服务器发送TCP数据包
::memset(&Server_TCP_Message, '/0', sizeof(Server_TCP_Message));
//接收客户端信息
char userinfo[65535];
::memset(&userinfo, '/0', 65535);
int readlen=recv(p_Temp->SocketService,(LPSTR)&userinfo,65535,0);//receive file name
if(readlen==0 || readlen==SOCKET_ERROR)
{
;
}else
{
g_TCP_List=*p_Temp;
CString info;
info.Format ("客户：%s (%s) 登陆",userinfo,(CString)p_Temp->Userinfo.IP);
strcpy(userinfo,info);
int userinfo_length=info.GetLength ();
#ifdef _DEBUG
AfxMessageBox((CString)info);
#else
theDlg->SetReviInfo((CString)info);
#endif
if(AfxBeginThread(Server_TCP_Select_Proc,p_Temp)==NULL)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n/n提示信息: 创建工作线程失败/t");
#endif
}else
{
//插入客户链表数据
::g_TCP_Lists.push_back(g_TCP_List);
//将客户登陆信息发送给所有登陆客户端
std::list<SERVICE_TCP_PARM>::iterator it_user;
for(it_user = g_TCP_Lists.begin();it_user != g_TCP_Lists.end();it_user++)
{
int nSendLen = send(it_user->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n发送登陆信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
}
}//if(readlen==0 || readlen==SOCKET_ERROR)
}//if(sockets==INVALID_SOCKET)
}//while(1)
return 0;
}catch (_com_error e)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n/n提示信息: 服为器接收客户线程意外结束/t");
#endif
return 1;
}
}
UINT Server_TCP_Select_Proc(LPVOID p)
{
try
{
SERVICE_TCP_PARM *p_Temp=(SERVICE_TCP_PARM*)p;
char userinfo[65535];
while(1)
{
//结束服务线程
if(::g_End_TCP_Proc==true)
{
#ifdef hui
AfxMessageBox("提示信息: 结束工作线程/t");
#endif
// closesocket(p_Temp->SocketService);
// free(p_Temp);
return 0;
}
//接收客户端请求
::memset(&userinfo, '/0', 65535);
int readlen=recv(p_Temp->SocketService,(LPSTR)&userinfo,65535,0);//receive file name
if(readlen==0 || readlen==SOCKET_ERROR)
{
CString info;
info="客户( " + (CString)p_Temp->Userinfo.IP + " )退出";
strcpy(userinfo,info);
int userinfo_length=info.GetLength ();
#ifdef _DEBUG
AfxMessageBox((CString)info);
#else
theDlg->SetReviInfo((CString)info);
#endif
//将客户退出信息发送给所有登陆客户端
std::list<SERVICE_TCP_PARM>::iterator it_user;
for(it_user = g_TCP_Lists.begin();it_user != g_TCP_Lists.end();it_user++)
{
if (it_user->SocketService == p_Temp->SocketService)
{
it_user=g_TCP_Lists.erase (it_user);// 删除元素
break;
}
}
for(it_user = g_TCP_Lists.begin();it_user != g_TCP_Lists.end();it_user++)
{
int nSendLen = send(it_user->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n发送退出信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
closesocket(p_Temp->SocketService);
free(p_Temp);
return 0;
}else
{
CString info;
info.Format ("%s：%s",p_Temp->Userinfo.IP,userinfo);
strcpy(userinfo,info);
int userinfo_length=info.GetLength ();
#ifdef _DEBUG
AfxMessageBox((CString)info);
#else
theDlg->SetReviInfo ((CString)info);
#endif
std::list<SERVICE_TCP_PARM>::iterator it_user;
for(it_user = g_TCP_Lists.begin();it_user != g_TCP_Lists.end();it_user++)
{
int nSendLen = send(it_user->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n发送登陆信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
}//if(readlen==0 || readlen==SOCKET_ERROR)
}//while(1)
}catch (_com_error e)
{
#ifdef hui
AfxMessageBox("提示信息: 工作线程意外结束/t");
#endif
return 1;
}
}
UINT Cilent_TCP_Select_Proc(LPVOID p)
{
try
{
SERVICE_TCP_PARM *p_Temp;
p_Temp=(SERVICE_TCP_PARM *)p;
CString info;
// info=(CString)p_Temp->Userinfo.IP + " " + (CString)p_Temp->Userinfo.User;
info=(CString)p_Temp->Userinfo.User;
char userinfo[65535];
::memset(&userinfo, '/0', 65535);
strcpy(userinfo,info);
int userinfo_length=info.GetLength ();
//发送本机信息
int nSendLen = send(p_Temp->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n发送本机信息/n/n/n提示信息: 发送错误/t");
#endif
return 1;
}
g_Client_TCP_Work=true;
//进入工作状态
while(1)
{
//结束客户端线程
if(::g_End_TCP_Proc==true)
{
#ifdef _DEBUG
AfxMessageBox("关闭工作线程");
#else
theDlg->SetReviInfo("关闭工作线程");
#endif
// closesocket(p_Temp->SocketService);
// free(p_Temp);
return 0;
}
//接收服务器请求
::memset(&userinfo, '/0', 65535);
int readlen=recv(p_Temp->SocketService,(LPSTR)&userinfo,65535,0);//receive file name
if(readlen==0 || readlen==SOCKET_ERROR)
{
#ifdef _DEBUG
AfxMessageBox("服务器终止");
#else
theDlg->SetReviInfo("服务器终止");
#endif
// closesocket(p_Temp->SocketService);
// free(p_Temp);
return 0;
}else
{
info=userinfo;
#ifdef _DEBUG
AfxMessageBox((CString)info);
#else
theDlg->SetReviInfo ((CString)info);
#endif
}//if(readlen==0 || readlen==SOCKET_ERROR)
}//while(1)
}catch (_com_error e)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n/n提示信息: 工作线程意外结束/t");
#endif
return 1;
}
}
UINT Server_UDP_Select_Proc(LPVOID p)
{
try
{
SERVICE_UDP_PARM *p_Temp=(SERVICE_UDP_PARM*)p;
g_Server_UDP_Work=true;
char userinfo[65535];
CString info;
while(1)
{
//结束服务线程
if(::g_End_UDP_Proc==true)
{
#ifdef hui
AfxMessageBox("提示信息: 结束工作线程/t");
#endif
// closesocket(p_Temp->SocketService);
// free(p_Temp);
return 0;
}
struct sockaddr_in from;
int fromlen =sizeof(from);
//接收客户端请求
::memset(&userinfo, '/0', 65535);
int readlen=recvfrom(p_Temp->SocketService,(LPSTR)&userinfo,65535,0,(struct sockaddr*)&from,&fromlen);
if(readlen==0 || readlen==SOCKET_ERROR)
{
;
}else
{
//取得客户链表数据
g_UDP_List.SocketService = p_Temp->SocketService;
g_UDP_List.FromAddr = from;
std::list<SERVICE_UDP_LIST>::iterator it_user;
bool isuser=false;
//查询客户IP地址是否已登陆
for(it_user = g_UDP_Lists.begin();it_user != g_UDP_Lists.end();it_user++)
{
if(strcmp((CString)inet_ntoa(it_user->FromAddr.sin_addr),(CString)inet_ntoa(g_UDP_List.FromAddr.sin_addr)) == 0)
{
isuser=true;
if (strcmp((CString)userinfo,"退出") == 0)
{
it_user=g_UDP_Lists.erase (it_user);// 删除元素
}
break;
}
}
if (isuser == false)
{
//插入客户链表数据
::g_UDP_Lists.push_back(g_UDP_List);
info="客户:" + (CString)userinfo + "( " + (CString)inet_ntoa(g_UDP_List.FromAddr.sin_addr) + " )登陆";
}else
{
info=(CString)inet_ntoa(g_UDP_List.FromAddr.sin_addr) + "：" + (CString)userinfo;
}
#ifdef _DEBUG
AfxMessageBox((CString)info);
#else
theDlg->SetReviInfo ((CString)info);
#endif
strcpy(userinfo,info);
int userinfo_length=info.GetLength ();
//将客户信息发送给所有登陆客户端
for(it_user = g_UDP_Lists.begin();it_user != g_UDP_Lists.end();it_user++)
{
int nSendLen = sendto(it_user->SocketService, (LPSTR)&userinfo,userinfo_length, 0, (struct sockaddr*)&it_user->FromAddr,sizeof(it_user->FromAddr));
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n发送客户信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
}//if(readlen==0 || readlen==SOCKET_ERROR)
}//while(1)
}catch (_com_error e)
{
#ifdef hui
AfxMessageBox("提示信息: 工作线程意外结束/t");
#endif
return 1;
}
}
UINT Cilent_UDP_Select_Proc(LPVOID p)
{
try
{
SERVICE_UDP_PARM *p_Temp;
p_Temp=(SERVICE_UDP_PARM *)p;
//设置本机信息
char userinfo[65535];
::memset(&userinfo, '/0', 65535);
CString info;
// info=(CString)p_Temp->Userinfo.IP + " " + (CString)p_Temp->Userinfo.User;
info=(CString)p_Temp->Userinfo.User;
strcpy(userinfo,info);
int userinfo_length=info.GetLength ();
//发送本机信息
int nSendLen = send(p_Temp->SocketService, (LPSTR)&userinfo,userinfo_length,0);
g_Client_UDP_Work=true;
//进入工作状态
while(1)
{
//结束客户端线程
if(::g_End_UDP_Proc==true)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n提示信息: 关闭工作线程/t");
#endif
// closesocket(p_Temp->SocketService);
// free(p_Temp);
return 0;
}
::memset(&userinfo, '/0', 65535);
//接收服务器信息
int readlen=recv(p_Temp->SocketService,(LPSTR)&userinfo,65535,0);//receive file name
if(readlen==0 || readlen==SOCKET_ERROR)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n/n提示信息: 服务器终止，客户端退出/t");
#endif
closesocket(p_Temp->SocketService);
free(p_Temp);
return 0;
}else
{
info=userinfo;
#ifdef _DEBUG
AfxMessageBox((CString)info);
#else
theDlg->SetReviInfo ((CString)info);
#endif
}//if(readlen==0 || readlen==SOCKET_ERROR)
}//while(1)
}catch (_com_error e)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n/n提示信息: 工作线程意外结束/t");
#endif
return 1;
}
}
void CMySocket::SendClientTCP(CString NewInfo)
{
//设置本机信息
char userinfo[65535];
::memset(&userinfo, '/0', 65535);
strcpy(userinfo,NewInfo);
int userinfo_length=NewInfo.GetLength ();
//发送本机信息
int nSendLen = send(p_TCP_Client->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n发送信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
void CMySocket::SendServerTCP(CString NewInfo)
{
char userinfo[65535];
NewInfo="服务器："+NewInfo;
::memset(&userinfo, '/0', 65535);
strcpy(userinfo,NewInfo);//发送的信息
int userinfo_length=NewInfo.GetLength ();
std::list<SERVICE_TCP_PARM>::iterator it_user;
for(it_user = g_TCP_Lists.begin();it_user != g_TCP_Lists.end();it_user++)
{
int nSendLen = send(it_user->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n发送信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
#ifdef _DEBUG
AfxMessageBox((CString)NewInfo);
#else
theDlg->SetReviInfo ((CString)NewInfo);
#endif
}
void CMySocket::SendClientUDP(CString NewInfo)
{
//设置本机信息
char userinfo[65535];
strcpy(userinfo,NewInfo);
int userinfo_length=NewInfo.GetLength ();
//发送本机信息
int nSendLen = send(p_UDP_Client->SocketService, (LPSTR)&userinfo,userinfo_length,0);
if((unsigned int)nSendLen!=userinfo_length)
{
#ifdef hui
AfxMessageBox("<客户端>/n/n发送信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
void CMySocket::SendServerUDP(CString NewInfo)
{
//设置本机信息
char userinfo[65535];
NewInfo="服务器：" + NewInfo;
strcpy(userinfo,NewInfo);
int userinfo_length=NewInfo.GetLength ();
std::list<SERVICE_UDP_LIST>::iterator it_user;
for(it_user = g_UDP_Lists.begin();it_user != g_UDP_Lists.end();it_user++)
{
int nSendLen = sendto(it_user->SocketService, (LPSTR)&userinfo,userinfo_length, 0, (struct sockaddr*)&it_user->FromAddr,sizeof(it_user->FromAddr));
if((unsigned int)nSendLen != userinfo_length)
{
#ifdef hui
AfxMessageBox("<服务器>/n/n发送客户信息/n/n/n提示信息: 发送错误/t");
#endif
}
}
#ifdef _DEBUG
AfxMessageBox((CString)NewInfo);
#else
theDlg->SetReviInfo ((CString)NewInfo);
#endif
}
联系客服
