рад буду услышать конструктивную критику а не пафос который впереди вас идет
Код:
void NetManager::addNetListener(int port, int pckExecutorCnt, int netConnectionLimit, bool logPcks, NetPacketHandler* pckHandler)
{
char buff[1024];
if (WSAStartup(0x0202, (WSADATA *)&buff[0]))
{
_loger->LogError("NetManager", "Error: WSAStartup");
delete(pckHandler);
return;
}
SOCKET server_Socket;
if ((server_Socket = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
_loger->LogError("NetManager", "Error: Init Socket");
WSACleanup();
delete(pckHandler);
return;
}
sockaddr_in local_addr;
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(port);
local_addr.sin_addr.s_addr = 0;
if (bind(server_Socket, (sockaddr *)&local_addr, sizeof(local_addr)))
{
_loger->LogError("NetManager", "Error: Bind");
closesocket(server_Socket);
WSACleanup();
delete(pckHandler);
return;
}
if (listen(server_Socket, netConnectionLimit))
{
_loger->LogError("NetManager", "Error: Listen");
closesocket(server_Socket);
WSACleanup();
delete(pckHandler);
return;
}
bool l = true;
if (ioctlsocket(server_Socket, FIONBIO, (unsigned long*)&l))
{
_loger->LogError("NetManager", "Error: NonBlocking switch");
closesocket(server_Socket);
WSACleanup();
delete(pckHandler);
return;
}
ListenerThreadClass * newListenerClass = new ListenerThreadClass();
newListenerClass->pckExecutorCnt = pckExecutorCnt;
newListenerClass->server_Socket = server_Socket;
newListenerClass->threadId = to_string(port);
newListenerClass->packetHandler = pckHandler;
newListenerClass->netConnectionLimit = netConnectionLimit;
newListenerClass->logPcks = logPcks;
listenerThreads.push_back(newListenerClass);
unsigned threadID;
_beginthreadex(NULL, 0, &NetListenerThread, newListenerClass, 0, &threadID);
}
unsigned __stdcall NetManager::NetListenerThread(void * pars)
{
_set_se_translator(trans_func);
ListenerThreadClass *listenerThread = (ListenerThreadClass *)pars;
_loger->Log("NetManager listenerThread_" + listenerThread->threadId, "Started. Connection limit = " + to_string(listenerThread->netConnectionLimit));
unsigned threadID;
ExecutorThreadClass * newExecutorClass;
for (int x = 1; x <= listenerThread->pckExecutorCnt; x++)
{
newExecutorClass = new ExecutorThreadClass();
newExecutorClass->threadId = listenerThread->threadId + "-" + to_string(x);
newExecutorClass->packetHandler = listenerThread->packetHandler;
newExecutorClass->logPcks = listenerThread->logPcks;
listenerThread->executorThreads.push_back(newExecutorClass);
_beginthreadex(NULL, 0, &NetExecutorThread, newExecutorClass, 0, &threadID);
}
SOCKET client_Socket = NULL;
sockaddr_in client_addr;
int client_addr_size = sizeof(client_addr);
NetClient * newNetClient;
unsigned int t_min;
int activeNetClientsCnt;
deque<ExecutorThreadClass*>::iterator etIter;
ExecutorThreadClass* minUsedThread;
while (!listenerThread->stopThread)
{
client_Socket = accept(listenerThread->server_Socket, (sockaddr *)&client_addr, &client_addr_size);
if (client_Socket != INVALID_SOCKET)
{
activeNetClientsCnt = 0;
t_min = UINT_MAX;
for (etIter = listenerThread->executorThreads.begin(); etIter != listenerThread->executorThreads.end(); etIter++)
{
activeNetClientsCnt += (*etIter)->clientQueue.size();
if ((*etIter)->clientQueue.size() < t_min)
{
minUsedThread = *etIter;
t_min = (*etIter)->clientQueue.size();
}
}
if(listenerThread->logPcks)
_loger->Log("NetManager listenerThread_" + listenerThread->threadId, "Accept connection from " + string(inet_ntoa(client_addr.sin_addr)) + ":" + to_string(ntohs(client_addr.sin_port)));
if (activeNetClientsCnt < listenerThread->netConnectionLimit)
{
newNetClient = (listenerThread->packetHandler)->createNewNetClient();
newNetClient->client_Socket = client_Socket;
newNetClient->remoteAddr = inet_ntoa(client_addr.sin_addr);
newNetClient->remotePort = ntohs(client_addr.sin_port);
minUsedThread->addClient(newNetClient);
newNetClient->onConnect();
}
else
{
if (listenerThread->logPcks)
_loger->Log("NetManager listenerThread_" + listenerThread->threadId, "Max connection Limit. Disconnect connection from " + string(inet_ntoa(client_addr.sin_addr)) + ":" + to_string(ntohs(client_addr.sin_port)));
closesocket(client_Socket);
}
}
Sleep(1);
}
closesocket(listenerThread->server_Socket);
for (etIter = listenerThread->executorThreads.begin(); etIter != listenerThread->executorThreads.end(); etIter++)
{
(*etIter)->stopThread = true;
}
bool allStoped = false;
while (!allStoped)
{
allStoped = true;
for (etIter = listenerThread->executorThreads.begin(); etIter != listenerThread->executorThreads.end(); etIter++)
{
if (!(*etIter)->threadStoped)
allStoped = false;
}
Sleep(1);
}
for (etIter = listenerThread->executorThreads.begin(); etIter != listenerThread->executorThreads.end(); etIter++)
{
delete(*etIter);
}
delete(listenerThread->packetHandler);
_loger->Log("NetManager listenerThread_" + listenerThread->threadId, "Stoped");
listenerThread->threadStoped = true;
return 0;
}
unsigned __stdcall NetManager::NetExecutorThread(void * pars)
{
_set_se_translator(trans_func);
ExecutorThreadClass *executorThread = (ExecutorThreadClass *)pars;
_loger->Log("NetManager executorThread_" + executorThread->threadId, "Started");
NetPacket * pckToExecute = NULL;
int bytes_recv;
BYTE *buff = new BYTE[20 * 1024];
unsigned int currPos;
unsigned int pckSize;
NetPacket *pck;
deque<NetClient*>::iterator cqIter;
deque<NetPacket*>::iterator pqIter;
while (!executorThread->stopThread)
{
executorThread->lockQueue();
for (cqIter = executorThread->clientQueue.begin(); cqIter != executorThread->clientQueue.end();)
{
bytes_recv = recv((*cqIter)->client_Socket, (char*)buff, (20 * 1024), 0);
if (bytes_recv > 0)
{
currPos = 0;
while (bytes_recv > 0)
{
pckSize = (executorThread->packetHandler)->getpacketLen(buff + currPos);
if ((pckSize == 0) || pckSize > (unsigned int)bytes_recv)
{
pckSize = bytes_recv;
if (executorThread->logPcks)
_loger->Log("NetManager executorThread_" + executorThread->threadId, "Incorrect packet lenght");
}
(executorThread->packetHandler)->decrypt(buff + currPos, pckSize);
pck = (executorThread->packetHandler)->packetHandle(buff + currPos, pckSize);
bytes_recv -= pckSize;
if (pck != NULL) {
pck->setBuff(buff + currPos, (executorThread->packetHandler)->getDataOffset(), pckSize);
pck->setNetClient(*cqIter);
executorThread->pckQueue.push_back(pck);
}
else
(*cqIter)->onIncorrectPck();
if (executorThread->logPcks)
_loger->LogPacket(&buff[currPos], pckSize, pck, (*cqIter)->remoteAddr, "Client");
currPos += pckSize;
}
cqIter++;
}
else
{
if (WSAGetLastError() != WSAEWOULDBLOCK)
{
if (executorThread->logPcks)
_loger->Log("NetManager executorThread_" + executorThread->threadId, "Client " + (*cqIter)->remoteAddr + ":" + to_string((*cqIter)->remotePort) + " disconnected");
(*cqIter)->onDisconnect();
(*cqIter)->disconnect();
delete(*cqIter);
cqIter = executorThread->clientQueue.erase(cqIter);
}
else
cqIter++;
}
}
executorThread->unlockQueue();
while (executorThread->pckQueue.size() > 0)
{
pqIter = executorThread->pckQueue.begin();
pckToExecute = (*pqIter);
executorThread->pckQueue.erase(pqIter);
if (pckToExecute != NULL)
{
try
{
pckToExecute->read();
}
catch (SE_Exception e)
{
_loger->LogError("NetManager executorThread_" + executorThread->threadId, "Caught exception on " + pckToExecute->getName());
_loger->printStackTrace(e.getContext());
}
delete(pckToExecute);
pckToExecute = NULL;
}
}
Sleep(1);
}
_loger->Log("NetManager executorThread_" + executorThread->threadId, "Has active clients : " + to_string(executorThread->clientQueue.size()));
int succesDisconnectClientCnt = 0;
executorThread->lockQueue();
for (cqIter = executorThread->clientQueue.begin(); cqIter != executorThread->clientQueue.end();)
{
(*cqIter)->onDisconnect();
(*cqIter)->disconnect();
delete(*cqIter);
cqIter = executorThread->clientQueue.erase(cqIter);
succesDisconnectClientCnt++;
}
_loger->Log("NetManager executorThread_" + executorThread->threadId, "Successful disconnect clients : " + to_string(succesDisconnectClientCnt));
delete(buff);
_loger->Log("NetManager executorThread_" + executorThread->threadId, "Stoped");
executorThread->threadStoped = true;
return 0;
}