void GlobalDataQueue::SendFinalQueue() { if(pQueueItems != NULL) { QueueItem * pNext = pQueueItems; while(pNext != NULL) { QueueItem * pCur = pNext; pNext = pCur->pNext; switch(pCur->ui8CommandType) { case CMD_OPS: case CMD_CHAT: case CMD_LUA: AddDataToQueue(GlobalQueues[0], pCur->sCommand1, pCur->szLen1); break; default: break; } } } if(pNewQueueItems[0] != NULL) { QueueItem * pNext = pNewQueueItems[0]; while(pNext != NULL) { QueueItem * pCur = pNext; pNext = pCur->pNext; switch(pCur->ui8CommandType) { case CMD_OPS: case CMD_CHAT: case CMD_LUA: AddDataToQueue(GlobalQueues[0], pCur->sCommand1, pCur->szLen1); break; default: break; } } } if(GlobalQueues[0].szLen == 0) { return; } GlobalQueues[0].sZbuffer = ZlibUtility->CreateZPipe(GlobalQueues[0].sBuffer, GlobalQueues[0].szLen, GlobalQueues[0].sZbuffer, GlobalQueues[0].szZlen, GlobalQueues[0].szZsize); User * pNext = colUsers->llist; while(pNext != NULL) { User * pCur = pNext; pNext = pCur->next; if(GlobalQueues[0].szZlen != 0) { UserPutInSendBuf(pCur, GlobalQueues[0].sZbuffer, GlobalQueues[0].szZlen); ui64BytesSentSaved += (GlobalQueues[0].szLen - GlobalQueues[0].szZlen); } else { UserPutInSendBuf(pCur, GlobalQueues[0].sBuffer, GlobalQueues[0].szLen); } } }
void theLoop::AcceptUser(AcceptedSocket *AccptSocket) { bool bIPv6 = false; char sIP[46]; uint8_t ui128IpHash[16]; memset(ui128IpHash, 0, 16); uint16_t ui16IpTableIdx = 0; if(AccptSocket->addr.ss_family == AF_INET6) { memcpy(ui128IpHash, &((struct sockaddr_in6 *)&AccptSocket->addr)->sin6_addr.s6_addr, 16); if(IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&AccptSocket->addr)->sin6_addr)) { in_addr ipv4addr; memcpy(&ipv4addr, ((struct sockaddr_in6 *)&AccptSocket->addr)->sin6_addr.s6_addr + 12, 4); strcpy(sIP, inet_ntoa(ipv4addr)); ui16IpTableIdx = ui128IpHash[14] * ui128IpHash[15]; } else { bIPv6 = true; #ifdef _WIN32 win_inet_ntop(&((struct sockaddr_in6 *)&AccptSocket->addr)->sin6_addr, sIP, 46); #else inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&AccptSocket->addr)->sin6_addr, sIP, 46); #endif ui16IpTableIdx = GetIpTableIdx(ui128IpHash); } } else { strcpy(sIP, inet_ntoa(((struct sockaddr_in *)&AccptSocket->addr)->sin_addr)); ui128IpHash[10] = 255; ui128IpHash[11] = 255; memcpy(ui128IpHash+12, &((struct sockaddr_in *)&AccptSocket->addr)->sin_addr.s_addr, 4); ui16IpTableIdx = ui128IpHash[14] * ui128IpHash[15]; } // set the recv buffer #ifdef _WIN32 int32_t bufsize = 8192; if(setsockopt(AccptSocket->s, SOL_SOCKET, SO_RCVBUF, (char *) &bufsize, sizeof(bufsize)) == SOCKET_ERROR) { int iError = WSAGetLastError(); int imsgLen = sprintf(msg, "[SYS] setsockopt failed on attempt to set SO_RCVBUF. IP: %s Err: %s (%d)", sIP, WSErrorStr(iError), iError); #else int bufsize = 8192; if(setsockopt(AccptSocket->s, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize)) == -1) { int imsgLen = sprintf(msg, "[SYS] setsockopt failed on attempt to set SO_RCVBUF. IP: %s Err: %d", sIP, errno); #endif if(CheckSprintf(imsgLen, 1024, "theLoop::AcceptUser1") == true) { UdpDebug->Broadcast(msg, imsgLen); } #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif return; } // set the send buffer bufsize = 32768; #ifdef _WIN32 if(setsockopt(AccptSocket->s, SOL_SOCKET, SO_SNDBUF, (char *) &bufsize, sizeof(bufsize)) == SOCKET_ERROR) { int iError = WSAGetLastError(); int imsgLen = sprintf(msg, "[SYS] setsockopt failed on attempt to set SO_SNDBUF. IP: %s Err: %s (%d)", sIP, WSErrorStr(iError), iError); #else if(setsockopt(AccptSocket->s, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize)) == -1) { int imsgLen = sprintf(msg, "[SYS] setsockopt failed on attempt to set SO_SNDBUF. IP: %s Err: %d", sIP, errno); #endif if(CheckSprintf(imsgLen, 1024, "theLoop::AcceptUser2") == true) { UdpDebug->Broadcast(msg, imsgLen); } #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif return; } // set sending of keepalive packets #ifdef _WIN32 bool bKeepalive = true; setsockopt(AccptSocket->s, SOL_SOCKET, SO_KEEPALIVE, (char *)&bKeepalive, sizeof(bKeepalive)); #else int iKeepAlive = 1; if(setsockopt(AccptSocket->s, SOL_SOCKET, SO_KEEPALIVE, &iKeepAlive, sizeof(iKeepAlive)) == -1) { int imsgLen = sprintf(msg, "[SYS] setsockopt failed on attempt to set SO_KEEPALIVE. IP: %s Err: %d", sIP, errno); if(CheckSprintf(imsgLen, 1024, "theLoop::AcceptUser3") == true) { UdpDebug->Broadcast(msg, imsgLen); } shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); return; } #endif // set non-blocking mode #ifdef _WIN32 uint32_t block = 1; if(ioctlsocket(AccptSocket->s, FIONBIO, (unsigned long *)&block) == SOCKET_ERROR) { int iError = WSAGetLastError(); int imsgLen = sprintf(msg, "[SYS] ioctlsocket failed on attempt to set FIONBIO. IP: %s Err: %s (%d)", sIP, WSErrorStr(iError), iError); #else int oldFlag = fcntl(AccptSocket->s, F_GETFL, 0); if(fcntl(AccptSocket->s, F_SETFL, oldFlag | O_NONBLOCK) == -1) { int imsgLen = sprintf(msg, "[SYS] fcntl failed on attempt to set O_NONBLOCK. IP: %s Err: %d", sIP, errno); #endif if(CheckSprintf(imsgLen, 1024, "theLoop::AcceptUser3") == true) { UdpDebug->Broadcast(msg, imsgLen); } #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif return; } if(SettingManager->bBools[SETBOOL_REDIRECT_ALL] == true) { if(SettingManager->sPreTexts[SetMan::SETPRETXT_REDIRECT_ADDRESS] != NULL) { int imsgLen = sprintf(msg, "<%s> %s %s|%s", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_REDIR_TO], SettingManager->sTexts[SETTXT_REDIRECT_ADDRESS], SettingManager->sPreTexts[SetMan::SETPRETXT_REDIRECT_ADDRESS]); if(CheckSprintf(imsgLen, 1024, "theLoop::AcceptUser4") == true) { send(AccptSocket->s, msg, imsgLen, 0); ui64BytesSent += imsgLen; } } #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif return; } time_t acc_time; time(&acc_time); BanItem * Ban = hashBanManager->FindFull(ui128IpHash, acc_time); if(Ban != NULL) { if(((Ban->ui8Bits & hashBanMan::FULL) == hashBanMan::FULL) == true) { int imsglen; char *messg = GenerateBanMessage(Ban, imsglen, acc_time); send(AccptSocket->s, messg, imsglen, 0); #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RD); close(AccptSocket->s); #endif /* int imsgLen = sprintf(msg, "[SYS] Banned ip %s - connection closed.", sIP); if(CheckSprintf(imsgLen, 1024, "theLoop::AcceptUser5") == true) { UdpDebug->Broadcast(msg, imsgLen); }*/ return; } } RangeBanItem * RangeBan = hashBanManager->FindFullRange(ui128IpHash, acc_time); if(RangeBan != NULL) { if(((RangeBan->ui8Bits & hashBanMan::FULL) == hashBanMan::FULL) == true) { int imsglen; char *messg = GenerateRangeBanMessage(RangeBan, imsglen, acc_time); send(AccptSocket->s, messg, imsglen, 0); #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RD); close(AccptSocket->s); #endif /* int imsgLen = sprintf(msg, "[SYS] Range Banned ip %s - connection closed.", sIP); if(CheckSprintf(imsgLen, 1024, "theLoop::AcceptUser6") == true) { UdpDebug->Broadcast(msg, imsgLen); }*/ return; } } ui32Joins++; // set properties of the new user object User * pUser = new User(); if(pUser == NULL) { #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif AppendDebugLog("%s - [MEM] Cannot allocate pUser in theLoop::AcceptUser\n", 0); return; } pUser->uLogInOut = new LoginLogout(); if(pUser->uLogInOut == NULL) { #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif delete pUser; AppendDebugLog("%s - [MEM] Cannot allocate uLogInOut in theLoop::AcceptUser\n", 0); return; } pUser->uLogInOut->logonClk = ui64ActualTick; pUser->Sck = AccptSocket->s; pUser->ui8State = User::STATE_KEY_OR_SUP; memcpy(pUser->ui128IpHash, ui128IpHash, 16); pUser->ui16IpTableIdx = ui16IpTableIdx; UserSetIP(pUser, sIP); if(bIPv6 == true) { pUser->ui32BoolBits |= User::BIT_IPV6; } else { pUser->ui32BoolBits |= User::BIT_IPV4; } if(UserMakeLock(pUser) == false) { #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif delete pUser; return; } if(Ban != NULL) { uint32_t hash = 0; if(((Ban->ui8Bits & hashBanMan::NICK) == hashBanMan::NICK) == true) { hash = Ban->ui32NickHash; } int imsglen; char *messg = GenerateBanMessage(Ban, imsglen, acc_time); pUser->uLogInOut->uBan = new UserBan(messg, imsglen, hash); if(pUser->uLogInOut->uBan == NULL || pUser->uLogInOut->uBan->sMessage == NULL) { #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif if(pUser->uLogInOut->uBan == NULL) { AppendDebugLog("%s - [MEM] Cannot allocate new uBan in theLoop::AcceptUser\n", 0); } else { AppendDebugLog("%s - [MEM] Cannot allocate uBan->sMessage in theLoop::AcceptUser\n", 0); } delete pUser; return; } } else if(RangeBan != NULL) { int imsglen; char *messg = GenerateRangeBanMessage(RangeBan, imsglen, acc_time); pUser->uLogInOut->uBan = new UserBan(messg, imsglen, 0); if(pUser->uLogInOut->uBan == NULL || pUser->uLogInOut->uBan->sMessage == NULL) { #ifdef _WIN32 shutdown(AccptSocket->s, SD_SEND); closesocket(AccptSocket->s); #else shutdown(AccptSocket->s, SHUT_RDWR); close(AccptSocket->s); #endif if(pUser->uLogInOut->uBan == NULL) { AppendDebugLog("%s - [MEM] Cannot allocate new uBan in theLoop::AcceptUser1\n", 0); } else { AppendDebugLog("%s - [MEM] Cannot allocate uBan->sMessage in theLoop::AcceptUser1\n", 0); } delete pUser; return; } } // Everything is ok, now add to users... colUsers->AddUser(pUser); } //--------------------------------------------------------------------------- void theLoop::ReceiveLoop() { #ifndef _WIN32 while((iSIG = sigtimedwait(&sst, &info, &zerotime)) != -1) { if(iSIG == SIGSCRTMR) { ScriptOnTimer((ScriptTimer *)info.si_value.sival_ptr); } else if(iSIG == SIGREGTMR) { RegTimerHandler(); } } #endif // Receiving loop for process all incoming data and store in queues uint32_t iRecvRests = 0; ui8SrCntr++; if(ui8SrCntr >= 7 || (colUsers->ui16ActSearchs + colUsers->ui16PasSearchs) > 8 || colUsers->ui16ActSearchs > 5) { ui8SrCntr = 0; } if(ui64ActualTick-iLstUptmTck > 60) { time_t acctime; time(&acctime); acctime -= starttime; uint64_t iValue = acctime / 86400; acctime -= (time_t)(86400*iValue); iDays = iValue; iValue = acctime / 3600; acctime -= (time_t)(3600*iValue); iHours = iValue; iValue = acctime / 60; iMins = iValue; #ifdef _WIN32 if(iMins == 0 || iMins == 15 || iMins == 30 || iMins == 45) { if(HeapValidate(GetProcessHeap(), 0, 0) == 0) { AppendDebugLog("%s - [ERR] Process memory heap corrupted\n", 0); } HeapCompact(GetProcessHeap(), 0); if(HeapValidate(hPtokaXHeap, HEAP_NO_SERIALIZE, 0) == 0) { AppendDebugLog("%s - [ERR] PtokaX memory heap corrupted\n", 0); } HeapCompact(hPtokaXHeap, HEAP_NO_SERIALIZE); if(HeapValidate(hRecvHeap, HEAP_NO_SERIALIZE, 0) == 0) { AppendDebugLog("%s - [ERR] Recv memory heap corrupted\n", 0); } HeapCompact(hRecvHeap, HEAP_NO_SERIALIZE); if(HeapValidate(hSendHeap, HEAP_NO_SERIALIZE, 0) == 0) { AppendDebugLog("%s - [ERR] Send memory heap corrupted\n", 0); } HeapCompact(hSendHeap, HEAP_NO_SERIALIZE); if(HeapValidate(hLuaHeap, 0, 0) == 0) { AppendDebugLog("%s - [ERR] Lua memory heap corrupted\n", 0); } HeapCompact(hLuaHeap, 0); } #endif iLstUptmTck = ui64ActualTick; } AcceptedSocket *NextSck = NULL; #ifdef _WIN32 EnterCriticalSection(&csAcceptQueue); #else pthread_mutex_lock(&mtxAcceptQueue); #endif if(AcceptedSocketsS != NULL) { NextSck = AcceptedSocketsS; AcceptedSocketsS = NULL; AcceptedSocketsE = NULL; } #ifdef _WIN32 LeaveCriticalSection(&csAcceptQueue); #else pthread_mutex_unlock(&mtxAcceptQueue); #endif while(NextSck != NULL) { AcceptedSocket *CurSck = NextSck; NextSck = CurSck->next; AcceptUser(CurSck); delete CurSck; } User *nextUser = colUsers->llist; while(nextUser != 0 && bServerTerminated == false) { User *curUser = nextUser; nextUser = curUser->next; // PPK ... true == we have rest ;) if(UserDoRecv(curUser) == true) { iRecvRests++; //Memo("Rest " + string(curUser->Nick, curUser->NickLen) + ": '" + string(curUser->recvbuf) + "'"); } // curUser->ProcessLines(); //} switch(curUser->ui8State) { case User::STATE_KEY_OR_SUP:{ // check logon timeout for iState 1 if(ui64ActualTick - curUser->uLogInOut->logonClk > 20) { int imsgLen = sprintf(msg, "[SYS] Login timeout 1 for %s - user disconnected.", curUser->sIP); if(CheckSprintf(imsgLen, 1024, "theLoop::ReceiveLoop3") == true) { UdpDebug->Broadcast(msg, imsgLen); } UserClose(curUser); continue; } break; } case User::STATE_IPV4_CHECK: { // check IPv4Check timeout if((ui64ActualTick - curUser->uLogInOut->ui64IPv4CheckTick) > 10) { int imsgLen = sprintf(msg, "[SYS] IPv4Check timeout for %s (%s).", curUser->sNick, curUser->sIP); if(CheckSprintf(imsgLen, 1024, "theLoop::ReceiveLoop31") == true) { UdpDebug->Broadcast(msg, imsgLen); } curUser->ui8State = User::STATE_ADDME; continue; } break; } case User::STATE_ADDME: { // PPK ... Add user, but only if send $GetNickList (or have quicklist supports) <- important, used by flooders !!! if(((curUser->ui32BoolBits & User::BIT_GETNICKLIST) == User::BIT_GETNICKLIST) == false && ((curUser->ui32SupportBits & User::SUPPORTBIT_QUICKLIST) == User::SUPPORTBIT_QUICKLIST) == false && ((curUser->ui32BoolBits & User::BIT_PINGER) == User::BIT_PINGER) == true) continue; int imsgLen = GetWlcmMsg(msg); UserSendCharDelayed(curUser, msg, imsgLen); curUser->ui8State = User::STATE_ADDME_1LOOP; continue; } case User::STATE_ADDME_1LOOP: { // PPK ... added login delay. if(dLoggedUsers >= dActualSrvLoopLogins && ((curUser->ui32BoolBits & User::BIT_OPERATOR) == User::BIT_OPERATOR) == false) { if(ui64ActualTick - curUser->uLogInOut->logonClk > 300) { int imsgLen = sprintf(msg, "[SYS] Login timeout (%d) 3 for %s (%s) - user disconnected.", (int)curUser->ui8State, curUser->sNick, curUser->sIP); if(CheckSprintf(imsgLen, 1024, "theLoop::ReceiveLoop4") == true) { UdpDebug->Broadcast(msg, imsgLen); } UserClose(curUser); } continue; } // PPK ... is not more needed, free mem ;) if(curUser->uLogInOut->pBuffer != NULL) { #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)curUser->uLogInOut->pBuffer) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate curUser->uLogInOut->pBuffer in theLoop::ReceiveLoop\n", 0); } #else free(curUser->uLogInOut->pBuffer); #endif curUser->uLogInOut->pBuffer = NULL; } if((curUser->ui32BoolBits & User::BIT_IPV6) == User::BIT_IPV6 && ((curUser->ui32BoolBits & User::SUPPORTBIT_IPV4) == User::SUPPORTBIT_IPV4) == false) { in_addr ipv4addr; ipv4addr.s_addr = INADDR_NONE; if(curUser->ui128IpHash[0] == 32 && curUser->ui128IpHash[1] == 2) { // 6to4 tunnel memcpy(&ipv4addr, curUser->ui128IpHash + 2, 4); } else if(curUser->ui128IpHash[0] == 32 && curUser->ui128IpHash[1] == 1 && curUser->ui128IpHash[2] == 0 && curUser->ui128IpHash[3] == 0) { // teredo tunnel uint32_t ui32Ip = 0; memcpy(&ui32Ip, curUser->ui128IpHash + 12, 4); ui32Ip ^= 0xffffffff; memcpy(&ipv4addr, &ui32Ip, 4); } if(ipv4addr.s_addr != INADDR_NONE) { strcpy(curUser->sIPv4, inet_ntoa(ipv4addr)); curUser->ui8IPv4Len = (uint8_t)strlen(curUser->sIPv4); curUser->ui32BoolBits |= User::BIT_IPV4; } } //New User Connected ... the user is operator ? invoke lua User/OpConnected uint32_t iBeforeLuaLen = curUser->sbdatalen; bool bRet = ScriptManager->UserConnected(curUser); if(curUser->ui8State >= User::STATE_CLOSING) {// connection closed by script? if(bRet == false) { // only when all scripts process userconnected ScriptManager->UserDisconnected(curUser); } continue; } if(iBeforeLuaLen < curUser->sbdatalen) { size_t szNeededLen = curUser->sbdatalen-iBeforeLuaLen; void * sOldBuf = curUser->uLogInOut->pBuffer; #ifdef _WIN32 if(curUser->uLogInOut->pBuffer == NULL) { curUser->uLogInOut->pBuffer = (char *)HeapAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, szNeededLen+1); } else { curUser->uLogInOut->pBuffer = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, sOldBuf, szNeededLen+1); } #else curUser->uLogInOut->pBuffer = (char *)realloc(sOldBuf, szNeededLen+1); #endif if(curUser->uLogInOut->pBuffer == NULL) { curUser->ui32BoolBits |= User::BIT_ERROR; UserClose(curUser); AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for sLockUsrConn in theLoop::ReceiveLoop\n", (uint64_t)(szNeededLen+1)); continue; } memcpy(curUser->uLogInOut->pBuffer, curUser->sendbuf+iBeforeLuaLen, szNeededLen); curUser->uLogInOut->iUserConnectedLen = (uint32_t)szNeededLen; curUser->uLogInOut->pBuffer[curUser->uLogInOut->iUserConnectedLen] = '\0'; curUser->sbdatalen = iBeforeLuaLen; curUser->sendbuf[curUser->sbdatalen] = '\0'; } // PPK ... wow user is accepted, now add it :) if(((curUser->ui32BoolBits & User::BIT_HAVE_BADTAG) == User::BIT_HAVE_BADTAG) == true) { UserHasSuspiciousTag(curUser); } UserAdd2Userlist(curUser); dLoggedUsers++; curUser->ui8State = User::STATE_ADDME_2LOOP; ui64TotalShare += curUser->ui64SharedSize; curUser->ui32BoolBits |= User::BIT_HAVE_SHARECOUNTED; #ifdef _BUILD_GUI if(::SendMessage(pMainWindowPageUsersChat->hWndPageItems[MainWindowPageUsersChat::BTN_AUTO_UPDATE_USERLIST], BM_GETCHECK, 0, 0) == BST_CHECKED) { pMainWindowPageUsersChat->AddUser(curUser); } #endif // if(sqldb) sqldb->AddVisit(curUser); // PPK ... change to NoHello supports int imsgLen = sprintf(msg, "$Hello %s|", curUser->sNick); if(CheckSprintf(imsgLen, 1024, "theLoop::ReceiveLoop6") == true) { g_GlobalDataQueue->AddQueueItem(msg, imsgLen, NULL, 0, GlobalDataQueue::CMD_HELLO); } g_GlobalDataQueue->UserIPStore(curUser); switch(SettingManager->ui8FullMyINFOOption) { case 0: g_GlobalDataQueue->AddQueueItem(curUser->sMyInfoLong, curUser->ui16MyInfoLongLen, NULL, 0, GlobalDataQueue::CMD_MYINFO); break; case 1: g_GlobalDataQueue->AddQueueItem(curUser->sMyInfoShort, curUser->ui16MyInfoShortLen, curUser->sMyInfoLong, curUser->ui16MyInfoLongLen, GlobalDataQueue::CMD_MYINFO); break; case 2: g_GlobalDataQueue->AddQueueItem(curUser->sMyInfoShort, curUser->ui16MyInfoShortLen, NULL, 0, GlobalDataQueue::CMD_MYINFO); break; default: break; } if(((curUser->ui32BoolBits & User::BIT_OPERATOR) == User::BIT_OPERATOR) == true) { g_GlobalDataQueue->OpListStore(curUser->sNick); } curUser->iLastMyINFOSendTick = ui64ActualTick; break; } case User::STATE_ADDED: if(curUser->cmdToUserStrt != NULL) { PrcsdToUsrCmd *next = curUser->cmdToUserStrt; curUser->cmdToUserStrt = NULL; curUser->cmdToUserEnd = NULL; while(next != NULL) { PrcsdToUsrCmd *cur = next; next = cur->next; if(cur->iLoops >= 2) { User * ToUser = hashManager->FindUser(cur->ToNick, cur->iToNickLen); if(ToUser == cur->To) { if(SettingManager->iShorts[SETSHORT_MAX_PM_COUNT_TO_USER] == 0 || cur->iPmCount == 0) { UserSendCharDelayed(cur->To, cur->sCommand, cur->iLen); } else { if(cur->To->iReceivedPmCount == 0) { cur->To->iReceivedPmTick = ui64ActualTick; } else if(cur->To->iReceivedPmCount >= (uint32_t)SettingManager->iShorts[SETSHORT_MAX_PM_COUNT_TO_USER]) { if(cur->To->iReceivedPmTick+60 < ui64ActualTick) { cur->To->iReceivedPmTick = ui64ActualTick; cur->To->iReceivedPmCount = 0; } else { bool bSprintfCheck; int imsgLen; if(cur->iPmCount == 1) { imsgLen = sprintf(msg, "$To: %s From: %s $<%s> %s %s %s!|", curUser->sNick, cur->ToNick, SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_SRY_LST_MSG_BCS], cur->ToNick, LanguageManager->sTexts[LAN_EXC_MSG_LIMIT]); bSprintfCheck = CheckSprintf(imsgLen, 1024, "theLoop::ReceiveLoop1"); } else { imsgLen = sprintf(msg, "$To: %s From: %s $<%s> %s %d %s %s %s!|", curUser->sNick, cur->ToNick, SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_SORRY_LAST], cur->iPmCount, LanguageManager->sTexts[LAN_MSGS_NOT_SENT], cur->ToNick, LanguageManager->sTexts[LAN_EXC_MSG_LIMIT]); bSprintfCheck = CheckSprintf(imsgLen, 1024, "theLoop::ReceiveLoop2"); } if(bSprintfCheck == true) { UserSendCharDelayed(curUser, msg, imsgLen); } #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)cur->sCommand) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate cur->sCommand in theLoop::ReceiveLoop\n", 0); } #else free(cur->sCommand); #endif cur->sCommand = NULL; #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)cur->ToNick) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate cur->ToNick in theLoop::ReceiveLoop\n", 0); } #else free(cur->ToNick); #endif cur->ToNick = NULL; delete cur; continue; } } UserSendCharDelayed(cur->To, cur->sCommand, cur->iLen); cur->To->iReceivedPmCount += cur->iPmCount; } } } else { cur->iLoops++; if(curUser->cmdToUserStrt == NULL) { cur->next = NULL; curUser->cmdToUserStrt = cur; curUser->cmdToUserEnd = cur; } else { curUser->cmdToUserEnd->next = cur; curUser->cmdToUserEnd = cur; } continue; } #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)cur->sCommand) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate cur->sCommand1 in theLoop::ReceiveLoop\n", 0); } #else free(cur->sCommand); #endif cur->sCommand = NULL; #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)cur->ToNick) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate cur->ToNick1 in theLoop::ReceiveLoop\n", 0); } #else free(cur->ToNick); #endif cur->ToNick = NULL; delete cur; } } if(ui8SrCntr == 0) { if(curUser->cmdActive6Search != NULL) { if(curUser->cmdActive4Search != NULL) { g_GlobalDataQueue->AddQueueItem(curUser->cmdActive6Search->sCommand, curUser->cmdActive6Search->iLen, curUser->cmdActive4Search->sCommand, curUser->cmdActive4Search->iLen, GlobalDataQueue::CMD_ACTIVE_SEARCH_V64); } else { g_GlobalDataQueue->AddQueueItem(curUser->cmdActive6Search->sCommand, curUser->cmdActive6Search->iLen, NULL, 0, GlobalDataQueue::CMD_ACTIVE_SEARCH_V6); } } else if(curUser->cmdActive4Search != NULL) { g_GlobalDataQueue->AddQueueItem(curUser->cmdActive4Search->sCommand, curUser->cmdActive4Search->iLen, NULL, 0, GlobalDataQueue::CMD_ACTIVE_SEARCH_V4); } if(curUser->cmdPassiveSearch != NULL) { uint8_t ui8CmdType = GlobalDataQueue::CMD_PASSIVE_SEARCH_V4; if((curUser->ui32BoolBits & User::BIT_IPV6) == User::BIT_IPV6) { if((curUser->ui32BoolBits & User::BIT_IPV4) == User::BIT_IPV4) { if((curUser->ui32BoolBits & User::BIT_IPV6_ACTIVE) == User::BIT_IPV6_ACTIVE) { ui8CmdType = GlobalDataQueue::CMD_PASSIVE_SEARCH_V4_ONLY; } else if((curUser->ui32BoolBits & User::BIT_IPV4_ACTIVE) == User::BIT_IPV4_ACTIVE) { ui8CmdType = GlobalDataQueue::CMD_PASSIVE_SEARCH_V6_ONLY; } else { ui8CmdType = GlobalDataQueue::CMD_PASSIVE_SEARCH_V64; } } else { ui8CmdType = GlobalDataQueue::CMD_PASSIVE_SEARCH_V6; } } g_GlobalDataQueue->AddQueueItem(curUser->cmdPassiveSearch->sCommand, curUser->cmdPassiveSearch->iLen, NULL, 0, ui8CmdType); UserDeletePrcsdUsrCmd(curUser->cmdPassiveSearch); curUser->cmdPassiveSearch = NULL; } } // PPK ... deflood memory cleanup, if is not needed anymore if(ui8SrCntr == 0) { if(curUser->sLastChat != NULL && curUser->ui16LastChatLines < 2 && (curUser->ui64SameChatsTick+SettingManager->iShorts[SETSHORT_SAME_MAIN_CHAT_TIME]) < ui64ActualTick) { #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)curUser->sLastChat) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate curUser->sLastChat in theLoop::ReceiveLoop\n", 0); } #else free(curUser->sLastChat); #endif curUser->sLastChat = NULL; curUser->ui16LastChatLen = 0; curUser->ui16SameMultiChats = 0; curUser->ui16LastChatLines = 0; } if(curUser->sLastPM != NULL && curUser->ui16LastPmLines < 2 && (curUser->ui64SamePMsTick+SettingManager->iShorts[SETSHORT_SAME_PM_TIME]) < ui64ActualTick) { #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)curUser->sLastPM) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate curUser->sLastPM in theLoop::ReceiveLoop\n", 0); } #else free(curUser->sLastPM); #endif curUser->sLastPM = NULL; curUser->ui16LastPMLen = 0; curUser->ui16SameMultiPms = 0; curUser->ui16LastPmLines = 0; } if(curUser->sLastSearch != NULL && (curUser->ui64SameSearchsTick+SettingManager->iShorts[SETSHORT_SAME_SEARCH_TIME]) < ui64ActualTick) { #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)curUser->sLastSearch) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate curUser->sLastSearch in theLoop::ReceiveLoop\n", 0); } #else free(curUser->sLastSearch); #endif curUser->sLastSearch = NULL; curUser->ui16LastSearchLen = 0; } } continue; case User::STATE_CLOSING: { if(((curUser->ui32BoolBits & User::BIT_ERROR) == User::BIT_ERROR) == false && curUser->sbdatalen != 0) { if(curUser->uLogInOut->iToCloseLoops != 0 || ((curUser->ui32BoolBits & User::BIT_PINGER) == User::BIT_PINGER) == true) { UserTry2Send(curUser); curUser->uLogInOut->iToCloseLoops--; continue; } } curUser->ui8State = User::STATE_REMME; continue; } // if user is marked as dead, remove him case User::STATE_REMME: { #ifdef _WIN32 shutdown(curUser->Sck, SD_SEND); closesocket(curUser->Sck); #else shutdown(curUser->Sck, SHUT_RD); close(curUser->Sck); #endif // linked list colUsers->RemUser(curUser); delete curUser; continue; } default: { // check logon timeout if(ui64ActualTick - curUser->uLogInOut->logonClk > 60) { int imsgLen = sprintf(msg, "[SYS] Login timeout (%d) 2 for %s (%s) - user disconnected.", (int)curUser->ui8State, curUser->sNick, curUser->sIP); if(CheckSprintf(imsgLen, 1024, "theLoop::ReceiveLoop7") == true) { UdpDebug->Broadcast(msg, imsgLen); } UserClose(curUser); continue; } break; } } } if(ui8SrCntr == 0) { colUsers->ui16ActSearchs = 0; colUsers->ui16PasSearchs = 0; } iLastRecvRest = iRecvRests; iRecvRestsPeak = iRecvRests > iRecvRestsPeak ? iRecvRests : iRecvRestsPeak; } //--------------------------------------------------------------------------- void theLoop::SendLoop() { g_GlobalDataQueue->PrepareQueueItems(); // PPK ... send loop // now logging users get changed myinfo with myinfos // old users get it in this loop from queue -> badwith saving !!! no more twice myinfo =) // Sending Loop uint32_t iSendRests = 0; User *nextUser = colUsers->llist; while(nextUser != 0 && bServerTerminated == false) { User *curUser = nextUser; nextUser = curUser->next; switch(curUser->ui8State) { case User::STATE_ADDME_2LOOP: { ui32Logged++; if(ui32Peak < ui32Logged) { ui32Peak = ui32Logged; if(SettingManager->iShorts[SETSHORT_MAX_USERS_PEAK] < (int16_t)ui32Peak) SettingManager->SetShort(SETSHORT_MAX_USERS_PEAK, (int16_t)ui32Peak); } curUser->ui8State = User::STATE_ADDED; // finaly send the nicklist/myinfos/oplist UserAddUserList(curUser); // PPK ... UserIP2 supports if(((curUser->ui32SupportBits & User::SUPPORTBIT_USERIP2) == User::SUPPORTBIT_USERIP2) == true && ((curUser->ui32BoolBits & User::BIT_QUACK_SUPPORTS) == User::BIT_QUACK_SUPPORTS) == false && ProfileMan->IsAllowed(curUser, ProfileManager::SENDALLUSERIP) == false) { int imsgLen = sprintf(msg, "$UserIP %s %s|", curUser->sNick, (curUser->sIPv4[0] == '\0' ? curUser->sIP : curUser->sIPv4)); if(CheckSprintf(imsgLen, 1024, "theLoop::SendLoop1") == true) { UserSendCharDelayed(curUser, msg, imsgLen); } } curUser->ui32BoolBits &= ~User::BIT_GETNICKLIST; // PPK ... send motd ??? if(SettingManager->ui16PreTextsLens[SetMan::SETPRETXT_MOTD] != 0) { if(SettingManager->bBools[SETBOOL_MOTD_AS_PM] == true) { int imsgLen = sprintf(g_sBuffer, SettingManager->sPreTexts[SetMan::SETPRETXT_MOTD], curUser->sNick); if(CheckSprintf(imsgLen, g_szBufferSize, "theLoop::SendLoop2") == true) { UserSendCharDelayed(curUser, g_sBuffer, imsgLen); } } else { UserSendCharDelayed(curUser, SettingManager->sPreTexts[SetMan::SETPRETXT_MOTD], SettingManager->ui16PreTextsLens[SetMan::SETPRETXT_MOTD]); } } // check for Debug subscription if(((curUser->ui32BoolBits & User::BIT_OPERATOR) == User::BIT_OPERATOR) == true) UdpDebug->CheckUdpSub(curUser, true); if(curUser->uLogInOut->iUserConnectedLen != 0) { UserPutInSendBuf(curUser, curUser->uLogInOut->pBuffer, curUser->uLogInOut->iUserConnectedLen); #ifdef _WIN32 if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)curUser->uLogInOut->pBuffer) == 0) { AppendDebugLog("%s - [MEM] Cannot deallocate curUser->uLogInOut->pBuffer in theLoop::SendLoop\n", 0); } #else free(curUser->uLogInOut->pBuffer); #endif curUser->uLogInOut->pBuffer = NULL; } // Login struct no more needed, free mem ! ;) delete curUser->uLogInOut; curUser->uLogInOut = NULL; // PPK ... send all login data from buffer ! if(curUser->sbdatalen > 0) { UserTry2Send(curUser); } // apply one loop delay to avoid double sending of hello and oplist continue; } case User::STATE_ADDED: { if(((curUser->ui32BoolBits & User::BIT_GETNICKLIST) == User::BIT_GETNICKLIST) == true) { UserAddUserList(curUser); curUser->ui32BoolBits &= ~User::BIT_GETNICKLIST; } // process global data queues if(g_GlobalDataQueue->pQueueItems != NULL) { g_GlobalDataQueue->ProcessQueues(curUser); } if(g_GlobalDataQueue->pSingleItems != NULL) { g_GlobalDataQueue->ProcessSingleItems(curUser); } // send data acumulated by queues above // if sending caused error, close the user if(curUser->sbdatalen != 0) { // PPK ... true = we have rest ;) if(UserTry2Send(curUser) == true) { iSendRests++; } } break; } case User::STATE_CLOSING: case User::STATE_REMME: continue; default: if(curUser->sbdatalen > 0) { UserTry2Send(curUser); } break; } } g_GlobalDataQueue->ClearQueues(); if(iLoopsForLogins >= 40) { dLoggedUsers = 0; iLoopsForLogins = 0; dActualSrvLoopLogins = 0; } dActualSrvLoopLogins += (double)SettingManager->iShorts[SETSHORT_MAX_SIMULTANEOUS_LOGINS]/40; iLoopsForLogins++; iLastSendRest = iSendRests; iSendRestsPeak = iSendRests > iSendRestsPeak ? iSendRests : iSendRestsPeak; }
void GlobalDataQueue::ProcessQueues(User * pUser) { uint32_t ui32QueueType = 0; // short myinfos uint16_t ui16QueueBits = 0; if(SettingManager->ui8FullMyINFOOption == 1 && ProfileMan->IsAllowed(pUser, ProfileManager::SENDFULLMYINFOS)) { ui32QueueType = 1; // full myinfos ui16QueueBits |= BIT_LONG_MYINFO; } if(pUser->ui64SharedSize != 0) { if(((pUser->ui32BoolBits & User::BIT_IPV6) == User::BIT_IPV6) == true) { if(((pUser->ui32BoolBits & User::BIT_IPV4) == User::BIT_IPV4) == true) { if(((pUser->ui32BoolBits & User::BIT_IPV6_ACTIVE) == User::BIT_IPV6_ACTIVE) == true) { if(((pUser->ui32BoolBits & User::BIT_IPV4_ACTIVE) == User::BIT_IPV4_ACTIVE) == true) { ui32QueueType += 6; // all searches both ipv4 and ipv6 ui16QueueBits |= BIT_ALL_SEARCHES_IPV64; } else { ui32QueueType += 14; // all searches ipv6 + active searches ipv4 ui16QueueBits |= BIT_ALL_SEARCHES_IPV6_ACTIVE_IPV4; } } else { if(((pUser->ui32BoolBits & User::BIT_IPV4_ACTIVE) == User::BIT_IPV4_ACTIVE) == true) { ui32QueueType += 16; // active searches ipv6 + all searches ipv4 ui16QueueBits |= BIT_ACTIVE_SEARCHES_IPV6_ALL_IPV4; } else { ui32QueueType += 12; // active searches both ipv4 and ipv6 ui16QueueBits |= BIT_ACTIVE_SEARCHES_IPV64; } } } else { if(((pUser->ui32BoolBits & User::BIT_IPV6_ACTIVE) == User::BIT_IPV6_ACTIVE) == true) { ui32QueueType += 4; // all searches ipv6 only ui16QueueBits |= BIT_ALL_SEARCHES_IPV6; } else { ui32QueueType += 10; // active searches ipv6 only ui16QueueBits |= BIT_ACTIVE_SEARCHES_IPV6; } } } else { if(((pUser->ui32BoolBits & User::BIT_IPV4_ACTIVE) == User::BIT_IPV4_ACTIVE) == true) { ui32QueueType += 2; // all searches ipv4 only ui16QueueBits |= BIT_ALL_SEARCHES_IPV4; } else { ui32QueueType += 8; // active searches ipv4 only ui16QueueBits |= BIT_ACTIVE_SEARCHES_IPV4; } } } if(((pUser->ui32SupportBits & User::SUPPORTBIT_NOHELLO) == User::SUPPORTBIT_NOHELLO) == false) { ui32QueueType += 14; // send hellos ui16QueueBits |= BIT_HELLO; } if(((pUser->ui32BoolBits & User::BIT_OPERATOR) == User::BIT_OPERATOR) == true) { ui32QueueType += 28; // send operator data ui16QueueBits |= BIT_OPERATOR; } if(pUser->iProfile != -1 && ((pUser->ui32SupportBits & User::SUPPORTBIT_USERIP2) == User::SUPPORTBIT_USERIP2) == true && ProfileMan->IsAllowed(pUser, ProfileManager::SENDALLUSERIP) == true) { ui32QueueType += 56; // send userips ui16QueueBits |= BIT_USERIP; } if(GlobalQueues[ui32QueueType].bCreated == false) { if(pQueueItems != NULL) { QueueItem * pNext = pQueueItems; while(pNext != NULL) { QueueItem * pCur = pNext; pNext = pCur->pNext; switch(pCur->ui8CommandType) { case CMD_HELLO: if((ui16QueueBits & BIT_HELLO) == BIT_HELLO) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_MYINFO: if((ui16QueueBits & BIT_LONG_MYINFO) == BIT_LONG_MYINFO) { if(pCur->sCommand2 != NULL) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand2, pCur->szLen2); } break; } if(pCur->sCommand1 != NULL) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_OPS: if((ui16QueueBits & BIT_OPERATOR) == BIT_OPERATOR) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_ACTIVE_SEARCH_V6: if(((ui16QueueBits & BIT_ALL_SEARCHES_IPV4) == BIT_ALL_SEARCHES_IPV4) == false && ((ui16QueueBits & BIT_ACTIVE_SEARCHES_IPV4) == BIT_ACTIVE_SEARCHES_IPV4) == false) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_ACTIVE_SEARCH_V64: if(((ui16QueueBits & BIT_ALL_SEARCHES_IPV4) == BIT_ALL_SEARCHES_IPV4) == false && ((ui16QueueBits & BIT_ACTIVE_SEARCHES_IPV4) == BIT_ACTIVE_SEARCHES_IPV4) == false) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } else if(((ui16QueueBits & BIT_ALL_SEARCHES_IPV6) == BIT_ALL_SEARCHES_IPV6) == false && ((ui16QueueBits & BIT_ACTIVE_SEARCHES_IPV6) == BIT_ACTIVE_SEARCHES_IPV6) == false) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand2, pCur->szLen2); } break; case CMD_ACTIVE_SEARCH_V4: if(((ui16QueueBits & BIT_ALL_SEARCHES_IPV6) == BIT_ALL_SEARCHES_IPV6) == false && ((ui16QueueBits & BIT_ACTIVE_SEARCHES_IPV6) == BIT_ACTIVE_SEARCHES_IPV6) == false) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_PASSIVE_SEARCH_V6: if((ui16QueueBits & BIT_ALL_SEARCHES_IPV6) == BIT_ALL_SEARCHES_IPV6 || (ui16QueueBits & BIT_ALL_SEARCHES_IPV64) == BIT_ALL_SEARCHES_IPV64 || (ui16QueueBits & BIT_ALL_SEARCHES_IPV6_ACTIVE_IPV4) == BIT_ALL_SEARCHES_IPV6_ACTIVE_IPV4) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_PASSIVE_SEARCH_V64: if((ui16QueueBits & BIT_ALL_SEARCHES_IPV64) == BIT_ALL_SEARCHES_IPV64 || (ui16QueueBits & BIT_ALL_SEARCHES_IPV6) == BIT_ALL_SEARCHES_IPV6 || (ui16QueueBits & BIT_ALL_SEARCHES_IPV4) == BIT_ALL_SEARCHES_IPV4 || (ui16QueueBits & BIT_ACTIVE_SEARCHES_IPV6_ALL_IPV4) == BIT_ACTIVE_SEARCHES_IPV6_ALL_IPV4 || (ui16QueueBits & BIT_ALL_SEARCHES_IPV6_ACTIVE_IPV4) == BIT_ALL_SEARCHES_IPV6_ACTIVE_IPV4) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_PASSIVE_SEARCH_V4: if((ui16QueueBits & BIT_ALL_SEARCHES_IPV4) == BIT_ALL_SEARCHES_IPV4 || (ui16QueueBits & BIT_ALL_SEARCHES_IPV64) == BIT_ALL_SEARCHES_IPV64 || (ui16QueueBits & BIT_ACTIVE_SEARCHES_IPV6_ALL_IPV4) == BIT_ACTIVE_SEARCHES_IPV6_ALL_IPV4) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_PASSIVE_SEARCH_V4_ONLY: if((ui16QueueBits & BIT_ALL_SEARCHES_IPV4) == BIT_ALL_SEARCHES_IPV4) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_PASSIVE_SEARCH_V6_ONLY: if((ui16QueueBits & BIT_ALL_SEARCHES_IPV6) == BIT_ALL_SEARCHES_IPV6) { AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); } break; case CMD_HUBNAME: case CMD_CHAT: case CMD_QUIT: case CMD_LUA: AddDataToQueue(GlobalQueues[ui32QueueType], pCur->sCommand1, pCur->szLen1); break; default: break; // should not happen ;) } } } if(OpListQueue.szLen != 0) { AddDataToQueue(GlobalQueues[ui32QueueType], OpListQueue.sBuffer, OpListQueue.szLen); } if(UserIPQueue.szLen != 0 && (ui16QueueBits & BIT_USERIP) == BIT_USERIP) { AddDataToQueue(GlobalQueues[ui32QueueType], UserIPQueue.sBuffer, UserIPQueue.szLen); } GlobalQueues[ui32QueueType].bCreated = true; GlobalQueues[ui32QueueType].pNext = pCreatedGlobalQueues; pCreatedGlobalQueues = &GlobalQueues[ui32QueueType]; } if(GlobalQueues[ui32QueueType].szLen == 0) { if(ui8SrCntr == 0) { if(pUser->cmdActive6Search != NULL) { UserDeletePrcsdUsrCmd(pUser->cmdActive6Search); pUser->cmdActive6Search = NULL; } if(pUser->cmdActive4Search != NULL) { UserDeletePrcsdUsrCmd(pUser->cmdActive4Search); pUser->cmdActive4Search = NULL; } } return; } if(ui8SrCntr == 0) { PrcsdUsrCmd * cmdActiveSearch = NULL; if((pUser->ui32BoolBits & User::BIT_IPV6) == User::BIT_IPV6) { cmdActiveSearch = pUser->cmdActive6Search; pUser->cmdActive6Search = NULL; if(pUser->cmdActive4Search != NULL) { UserDeletePrcsdUsrCmd(pUser->cmdActive4Search); pUser->cmdActive4Search = NULL; } } else { cmdActiveSearch = pUser->cmdActive4Search; pUser->cmdActive4Search = NULL; } if(cmdActiveSearch != NULL) { if(pUser->ui64SharedSize == 0) { UserDeletePrcsdUsrCmd(cmdActiveSearch); } else { if(((pUser->ui32SupportBits & User::SUPPORTBIT_ZPIPE) == User::SUPPORTBIT_ZPIPE) == true) { if(GlobalQueues[ui32QueueType].bZlined == false) { GlobalQueues[ui32QueueType].bZlined = true; GlobalQueues[ui32QueueType].sZbuffer = ZlibUtility->CreateZPipe(GlobalQueues[ui32QueueType].sBuffer, GlobalQueues[ui32QueueType].szLen, GlobalQueues[ui32QueueType].sZbuffer, GlobalQueues[ui32QueueType].szZlen, GlobalQueues[ui32QueueType].szZsize); } if(GlobalQueues[ui32QueueType].szZlen != 0 && (GlobalQueues[ui32QueueType].szZlen <= (GlobalQueues[ui32QueueType].szLen-cmdActiveSearch->iLen))) { UserPutInSendBuf(pUser, GlobalQueues[ui32QueueType].sZbuffer, GlobalQueues[ui32QueueType].szZlen); ui64BytesSentSaved += (GlobalQueues[ui32QueueType].szLen - GlobalQueues[ui32QueueType].szZlen); UserDeletePrcsdUsrCmd(cmdActiveSearch); return; } } uint32_t ui32SbLen = pUser->sbdatalen; UserPutInSendBuf(pUser, GlobalQueues[ui32QueueType].sBuffer, GlobalQueues[ui32QueueType].szLen); // PPK ... check if adding of searchs not cause buffer overflow ! if(pUser->sbdatalen <= ui32SbLen) { ui32SbLen = 0; } UserRemFromSendBuf(pUser, cmdActiveSearch->sCommand, cmdActiveSearch->iLen, ui32SbLen); UserDeletePrcsdUsrCmd(cmdActiveSearch); return; } } } if(((pUser->ui32SupportBits & User::SUPPORTBIT_ZPIPE) == User::SUPPORTBIT_ZPIPE) == true) { if(GlobalQueues[ui32QueueType].bZlined == false) { GlobalQueues[ui32QueueType].bZlined = true; GlobalQueues[ui32QueueType].sZbuffer = ZlibUtility->CreateZPipe(GlobalQueues[ui32QueueType].sBuffer, GlobalQueues[ui32QueueType].szLen, GlobalQueues[ui32QueueType].sZbuffer, GlobalQueues[ui32QueueType].szZlen, GlobalQueues[ui32QueueType].szZsize); } if(GlobalQueues[ui32QueueType].szZlen != 0) { UserPutInSendBuf(pUser, GlobalQueues[ui32QueueType].sZbuffer, GlobalQueues[ui32QueueType].szZlen); ui64BytesSentSaved += (GlobalQueues[ui32QueueType].szLen - GlobalQueues[ui32QueueType].szZlen); return; } } UserPutInSendBuf(pUser, GlobalQueues[ui32QueueType].sBuffer, GlobalQueues[ui32QueueType].szLen); }