#include "Communication.h"
#include <iostream>
CommunicationBase::CommunicationBase()
: m_socket(INVALID_SOCKET), m_running(false),
m_receiveThread(NULL), m_queueEvent(NULL)
{
InitializeCriticalSection(&m_queueCS);
m_queueEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
}
CommunicationBase::~CommunicationBase()
{
CloseSocket();
DeleteCriticalSection(&m_queueCS);
if (m_queueEvent) CloseHandle(m_queueEvent);
}
void CommunicationBase::CloseSocket()
{
if (m_socket != INVALID_SOCKET)
{
m_running = false;
// 关闭套接字会终止接收线程
shutdown(m_socket, SD_BOTH);
closesocket(m_socket);
m_socket = INVALID_SOCKET;
if (m_receiveThread)
{
WaitForSingleObject(m_receiveThread, INFINITE);
CloseHandle(m_receiveThread);
m_receiveThread = NULL;
}
}
}
bool CommunicationBase::SendMessageTcp(const std::string& message)
{
if (m_socket == INVALID_SOCKET || !m_running)
return false;
const char* data = message.c_str();
int length = static_cast<int>(message.size());
int totalSent = 0;
while (totalSent < length)
{
int sent = send(m_socket, data + totalSent, length - totalSent, 0);
if (sent == SOCKET_ERROR)
{
std::cerr << "发送失败: " << WSAGetLastError() << std::endl;
return false;
}
totalSent += sent;
}
return true;
}
//bool SendMessageTcp(SOCKET socket, const std::string& message) {
// const char* data = message.data();
// int total = static_cast<int>(message.size());
// int sent = 0;
//
// while (sent < total && m_running) {
// int bytes = send(socket, data + sent, total - sent, 0);
//
// if (bytes == SOCKET_ERROR) {
// int error = WSAGetLastError();
// if (error == WSAEWOULDBLOCK) {
// // 等待套接字可写
// fd_set writeSet;
// FD_ZERO(&writeSet);
// FD_SET(socket, &writeSet);
//
// timeval timeout{ 0, 10000 }; // 10ms超时
// if (select(0, NULL, &writeSet, NULL, &timeout) <= 0) {
// continue; // 超时或错误
// }
// }
// else {
// // 处理其他错误
// closesocket(socket);
// return false;
// }
// }
// else {
// sent += bytes;
// }
// }
// return sent == total;
//}
std::string CommunicationBase::ReceiveMessage(DWORD timeout_ms)
{
EnterCriticalSection(&m_queueCS);
if (m_messageQueue.empty())
{
LeaveCriticalSection(&m_queueCS);
WaitForSingleObject(m_queueEvent, timeout_ms);
EnterCriticalSection(&m_queueCS);
}
if (m_messageQueue.empty())
{
LeaveCriticalSection(&m_queueCS);
return "";
}
std::string msg = m_messageQueue.front();
m_messageQueue.pop();
LeaveCriticalSection(&m_queueCS);
return msg;
}
DWORD WINAPI CommunicationBase::ReceiveThreadProc(LPVOID lpParam) {
CommunicationBase* pThis = reinterpret_cast<CommunicationBase*>(lpParam);
char buffer[4096];
int bytesReceived;
while (pThis->m_running) {
bytesReceived = recv(pThis->m_socket, buffer, sizeof(buffer) - 1, 0);
if (bytesReceived == SOCKET_ERROR) {
int error = WSAGetLastError();
if (error == WSAEWOULDBLOCK) {
Sleep(10);
continue;
}
break;
}
if (bytesReceived <= 0) {
break;
}
buffer[bytesReceived] = '\0';
std::string msg(buffer);
EnterCriticalSection(&pThis->m_queueCS);
pThis->m_messageQueue.push(msg);
SetEvent(pThis->m_queueEvent);
LeaveCriticalSection(&pThis->m_queueCS);
}
pThis->m_running = false;
return 0;
}
Server::Server(int port)
: m_port(port), m_acceptThread(NULL)
{
InitializeCriticalSection(&m_clientsCS);
m_socket = INVALID_SOCKET;
}
Server::~Server()
{
Stop();
DeleteCriticalSection(&m_clientsCS);
}
bool Server::Start()
{
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
std::cerr << "WSAStartup失败" << std::endl;
return false;
}
m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (m_socket == INVALID_SOCKET) {
std::cerr << "创建套接字失败" << std::endl;
WSACleanup();
return false;
}
sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = INADDR_ANY;
serverAddr.sin_port = htons(m_port);
if (bind(m_socket, (sockaddr*)& serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
{
std::cerr << "绑定失败: " << WSAGetLastError() << std::endl;
closesocket(m_socket);
WSACleanup();
return false;
}
if (listen(m_socket, SOMAXCONN) == SOCKET_ERROR)
{
std::cerr << "监听失败" << std::endl;
closesocket(m_socket);
WSACleanup();
return false;
}
// 设置非阻塞模式
u_long mode = 1;
ioctlsocket(m_socket, FIONBIO, &mode);
m_running = true;
// 启动接受客户端线程
m_acceptThread = CreateThread(NULL, 0, AcceptThreadProc, this, 0, NULL);
if (m_acceptThread == NULL)
{
std::cerr << "创建接受线程失败" << std::endl;
closesocket(m_socket);
WSACleanup();
return false;
}
std::cout << "服务器已启动，监听端口: " << m_port << std::endl;
return true;
}
void Server::Stop()
{
m_running = false;
// 关闭所有客户端套接字
EnterCriticalSection(&m_clientsCS);
for (size_t i = 0; i < m_clientSockets.size(); ++i)
{
if (m_clientSockets[i] != INVALID_SOCKET)
{
shutdown(m_clientSockets[i], SD_BOTH);
closesocket(m_clientSockets[i]);
}
}
m_clientSockets.clear();
LeaveCriticalSection(&m_clientsCS);
CloseSocket();
if (m_acceptThread)
{
WaitForSingleObject(m_acceptThread, INFINITE);
CloseHandle(m_acceptThread);
m_acceptThread = NULL;
}
WSACleanup();
std::cout << "服务器已停止" << std::endl;
}
DWORD WINAPI Server::AcceptThreadProc(LPVOID lpParam)
{
Server* pServer = reinterpret_cast<Server*>(lpParam);
pServer->AcceptClients();
return 0;
}
DWORD WINAPI Server::ClientThreadProc(LPVOID lpParam) {
ClientThreadParam* param = reinterpret_cast<ClientThreadParam*>(lpParam);
param->server->HandleClient(param->clientSocket);
delete param;
return 0;
}
void Server::AcceptClients()
{
while (m_running)
{
sockaddr_in clientAddr;
int addrLen = sizeof(clientAddr);
SOCKET clientSocket = accept(m_socket, (sockaddr*)& clientAddr, &addrLen);
if (clientSocket == INVALID_SOCKET)
{
int error = WSAGetLastError();
if (error == WSAEWOULDBLOCK)
{
Sleep(100);
continue;
}
break;
}
// 设置非阻塞模式a
u_long mode = 1;
ioctlsocket(clientSocket, FIONBIO, &mode);
EnterCriticalSection(&m_clientsCS);
m_clientSockets.push_back(clientSocket);
LeaveCriticalSection(&m_clientsCS);
char ipStr[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &clientAddr.sin_addr, ipStr, INET_ADDRSTRLEN);
std::cout << "新客户端连接: " << ipStr << ":" << ntohs(clientAddr.sin_port) << std::endl;
// 创建线程参数
ClientThreadParam* param = new ClientThreadParam;
param->server = this;
param->clientSocket = clientSocket;
// 创建客户端处理线程
HANDLE hThread = CreateThread(
NULL,
0,
ClientThreadProc,
param,
0,
NULL
);
if (hThread == NULL) {
std::cerr << "创建客户端线程失败: " << GetLastError() << std::endl;
delete param;
closesocket(clientSocket);
}
else {
CloseHandle(hThread); // 立即关闭线程句柄，不保留
}
}
}
void Server::HandleClient(SOCKET clientSocket)
{
char buffer[4096];
int bytesReceived;
while (m_running)
{
bytesReceived = recv(clientSocket, buffer, sizeof(buffer) - 1, 0);
if (bytesReceived == SOCKET_ERROR)
{
int error = WSAGetLastError();
if (error == WSAEWOULDBLOCK)
{
Sleep(10);
continue;
}
break;
}
if (bytesReceived <= 0)
{
break;
}
buffer[bytesReceived] = '\0';
std::string msg(buffer);
// 添加到消息队列
EnterCriticalSection(&m_queueCS);
m_messageQueue.push(msg);
SetEvent(m_queueEvent);
LeaveCriticalSection(&m_queueCS);
std::cout << "收到消息: " << msg << std::endl;
// 广播给其他客户端
Broadcast(msg, clientSocket);
}
// 移除断开连接的客户端
EnterCriticalSection(&m_clientsCS);
for (std::vector<SOCKET>::iterator it = m_clientSockets.begin(); it != m_clientSockets.end(); ++it)
{
if (*it == clientSocket)
{
closesocket(clientSocket);
m_clientSockets.erase(it);
break;
}
}
LeaveCriticalSection(&m_clientsCS);
std::cout << "客户端断开连接" << std::endl;
}
void Server::StartReceiver()
{
// 服务器使用每个客户端单独的线程处理接收
}
void Server::Broadcast(const std::string& message, SOCKET excludeSocket)
{
EnterCriticalSection(&m_clientsCS);
for (size_t i = 0; i < m_clientSockets.size(); ++i)
{
if (m_clientSockets[i] != excludeSocket && m_clientSockets[i] != INVALID_SOCKET)
{
send(m_clientSockets[i], message.c_str(), static_cast<int>(message.size()), 0);
}
}
LeaveCriticalSection(&m_clientsCS);
}
Client::Client(const std::string& ip, int port)
: m_serverIP(ip), m_port(port)
{
m_socket = INVALID_SOCKET;
}
Client::~Client()
{
Disconnect();
}
bool Client::Connect()
{
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
std::cerr << "WSAStartup failed" << std::endl;
return false;
}
m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (m_socket == INVALID_SOCKET)
{
std::cerr << "Socket creation failed" << std::endl;
WSACleanup();
return false;
}
sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(m_port);
inet_pton(AF_INET, m_serverIP.c_str(), &serverAddr.sin_addr);
if (connect(m_socket, (sockaddr*)& serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
std::cerr << "Connection failed: " << WSAGetLastError() << std::endl;
closesocket(m_socket);
WSACleanup();
return false;
}
// 设置非阻塞模式
u_long mode = 1;
ioctlsocket(m_socket, FIONBIO, &mode);
m_running = true;
StartReceiver();
std::cout << "Connected to server: " << m_serverIP << ":" << m_port << std::endl;
return true;
}
void Client::Disconnect()
{
m_running = false;
CloseSocket();
WSACleanup();
std::cout << "Disconnected from server" << std::endl;
}
void Client::StartReceiver()
{
m_receiveThread = CreateThread(NULL, 0, ReceiveThreadProc, this, 0, NULL);
if (m_receiveThread == NULL)
{
std::cerr << "Failed to create receive thread" << std::endl;
m_running = false;
}
}
// 明确的发送接口
bool Client::Send(const std::string& message)
{
if (m_socket == INVALID_SOCKET || !m_running)
{
return false;
}
return SendMessageTcp(message);
}
// 阻塞式接收
bool Client::Receive(std::string& outMessage, DWORD timeout_ms)
{
outMessage = ReceiveMessage(timeout_ms);
return !outMessage.empty();
}
// 非阻塞式接收
bool Client::TryReceive(std::string& outMessage)
{
EnterCriticalSection(&m_queueCS);
if (m_messageQueue.empty())
{
LeaveCriticalSection(&m_queueCS);
return false;
}
outMessage = m_messageQueue.front();
m_messageQueue.pop();
LeaveCriticalSection(&m_queueCS);
return true;
}
仔细阅读代码
最新发布
本文探讨了常见的WSAEWOULDBLOCK错误，该错误表明操作未能在预期时间内完成。对于理解网络编程中此类问题及其解决办法至关重要。
扫一扫
412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
