void classUsers::DelFromNickList(char * Nick, const bool &isOp) {
int m = sprintf(msg, "$%s$", Nick);
if(CheckSprintf(m, 1024, "classUsers::DelFromNickList") == false) {
return;
}
nickList[9] = '$';
char *off = strstr(nickList, msg);
nickList[9] = ' ';
if(off != NULL) {
memmove(off+1, off+(m+1), nickListLen-((off+m)-nickList));
nickListLen -= m;
iZNickListLen = 0;
}
if(!isOp) return;
opList[7] = '$';
off = strstr(opList, msg);
opList[7] = ' ';
if(off != NULL) {
memmove(off+1, off+(m+1), opListLen-((off+m)-opList));
opListLen -= m;
iZOpListLen = 0;
}
}
void classUsers::Add2UserIP(User * cur) {
int m = sprintf(msg,"$%s %s$", cur->sNick, cur->sIP);
if(CheckSprintf(m, 1024, "classUsers::Add2UserIP") == false) {
return;
}
if(userIPListSize < userIPListLen+m) {
char * pOldBuf = userIPList;
#ifdef _WIN32
userIPList = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, userIPListSize+IPLISTSIZE+1);
#else
userIPList = (char *)realloc(pOldBuf, userIPListSize+IPLISTSIZE+1);
#endif
if(userIPList == NULL) {
userIPList = pOldBuf;
cur->ui32BoolBits |= User::BIT_ERROR;
UserClose(cur);
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in classUsers::Add2UserIP\n", (uint64_t)(userIPListSize+IPLISTSIZE+1));
return;
}
userIPListSize += IPLISTSIZE;
}
memcpy(userIPList+userIPListLen-1, msg+1, m-1);
userIPListLen += m;
userIPList[userIPListLen-2] = '$';
userIPList[userIPListLen-1] = '|';
userIPList[userIPListLen] = '\0';
iZUserIPListLen = 0;
}
// appends data to the OpListQueue
void clsGlobalDataQueue::OpListStore(char * sNick) {
if(OpListQueue.szLen == 0) {
OpListQueue.szLen = sprintf(OpListQueue.sBuffer, "$OpList %s$$|", sNick);
} else {
int iDataLen = sprintf(msg, "%s$$|", sNick);
if(CheckSprintf(iDataLen, 128, "clsGlobalDataQueue::OpListStore2") == true) {
if(OpListQueue.szSize < OpListQueue.szLen+iDataLen) {
size_t szAllignLen = Allign256(OpListQueue.szLen+iDataLen);
char * pOldBuf = OpListQueue.sBuffer;
#ifdef _WIN32
OpListQueue.sBuffer = (char *)HeapReAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, szAllignLen);
#else
OpListQueue.sBuffer = (char *)realloc(pOldBuf, szAllignLen);
#endif
if(OpListQueue.sBuffer == NULL) {
OpListQueue.sBuffer = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in clsGlobalDataQueue::OpListStore\n", (uint64_t)szAllignLen);
return;
}
OpListQueue.szSize = (uint32_t)(szAllignLen-1);
}
memcpy(OpListQueue.sBuffer+OpListQueue.szLen-1, msg, iDataLen);
OpListQueue.szLen += iDataLen-1;
OpListQueue.sBuffer[OpListQueue.szLen] = '\0';
}
}
}
void clsScriptManager::LoadXML() {
// PPK ... first start all script in order from xml file
#ifdef _WIN32
TiXmlDocument doc((clsServerManager::sPath+"\\cfg\\Scripts.xml").c_str());
#else
TiXmlDocument doc((clsServerManager::sPath+"/cfg/Scripts.xml").c_str());
#endif
if(doc.LoadFile() == false) {
if(doc.ErrorId() != TiXmlBase::TIXML_ERROR_OPENING_FILE && doc.ErrorId() != TiXmlBase::TIXML_ERROR_DOCUMENT_EMPTY) {
int iMsgLen = sprintf(clsServerManager::pGlobalBuffer, "Error loading file Scripts.xml. %s (Col: %d, Row: %d)", doc.ErrorDesc(), doc.Column(), doc.Row());
CheckSprintf(iMsgLen, clsServerManager::szGlobalBufferSize, "clsScriptManager::LoadXML");
#ifdef _BUILD_GUI
::MessageBox(NULL, clsServerManager::pGlobalBuffer, g_sPtokaXTitle, MB_OK | MB_ICONERROR);
#else
AppendLog(clsServerManager::pGlobalBuffer);
#endif
exit(EXIT_FAILURE);
}
} else {
TiXmlHandle cfg(&doc);
TiXmlNode *scripts = cfg.FirstChild("Scripts").Node();
if(scripts != NULL) {
TiXmlNode *child = NULL;
while((child = scripts->IterateChildren(child)) != NULL) {
TiXmlNode *script = child->FirstChild("Name");
if(script == NULL || (script = script->FirstChild()) == NULL) {
continue;
}
char *name = (char *)script->Value();
if(FileExist((clsServerManager::sScriptPath+string(name)).c_str()) == false) {
continue;
}
if((script = child->FirstChild("Enabled")) == NULL ||
(script = script->FirstChild()) == NULL) {
continue;
}
bool enabled = atoi(script->Value()) == 0 ? false : true;
if(FindScript(name) != NULL) {
continue;
}
AddScript(name, enabled, false);
}
}
}
}
void DeFloodReport(User * u, const uint8_t ui8DefloodType, char *sAction) {
if(SettingManager->bBools[SETBOOL_DEFLOOD_REPORT] == true) {
if(SettingManager->bBools[SETBOOL_SEND_STATUS_MESSAGES_AS_PM] == true) {
int imsgLen = sprintf(msg, "%s $<%s> *** %s %s %s %s %s.|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC],
DeFloodGetMessage(ui8DefloodType, 2), u->sNick, LanguageManager->sTexts[LAN_WITH_IP], u->sIP, sAction);
if(CheckSprintf(imsgLen, 1024, "DeFloodReport1") == true) {
g_GlobalDataQueue->SingleItemStore(msg, imsgLen, NULL, 0, GlobalDataQueue::SI_PM2OPS);
}
} else {
int imsgLen = sprintf(msg, "<%s> *** %s %s %s %s %s.|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], DeFloodGetMessage(ui8DefloodType, 2), u->sNick,
LanguageManager->sTexts[LAN_WITH_IP], u->sIP, sAction);
if(CheckSprintf(imsgLen, 1024, "DeFloodReport2") == true) {
g_GlobalDataQueue->AddQueueItem(msg, imsgLen, NULL, 0, GlobalDataQueue::CMD_OPS);
}
}
}
int imsgLen = sprintf(msg, "[SYS] Flood type %hu from %s (%s) - user closed.", (uint16_t)ui8DefloodType, u->sNick, u->sIP);
if(CheckSprintf(imsgLen, 1024, "DeFloodReport3") == true) {
UdpDebug->Broadcast(msg, imsgLen);
}
}
bool classUsers::CheckRecTime(User * curUser) {
RecTime * next = RecTimeList;
while(next != NULL) {
RecTime * cur = next;
next = cur->next;
// check expires...
if(cur->ui64DisConnTick+SettingManager->iShorts[SETSHORT_MIN_RECONN_TIME] <= ui64ActualTick) {
#ifdef _WIN32
if(cur->sNick != NULL) {
if(HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)cur->sNick) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate cur->sNick in classUsers::CheckRecTime\n", 0);
}
}
#else
free(cur->sNick);
#endif
if(cur->prev == NULL) {
if(cur->next == NULL) {
RecTimeList = NULL;
} else {
cur->next->prev = NULL;
RecTimeList = cur->next;
}
} else if(cur->next == NULL) {
cur->prev->next = NULL;
} else {
cur->prev->next = cur->next;
cur->next->prev = cur->prev;
}
delete cur;
continue;
}
if(cur->ui32NickHash == curUser->ui32NickHash && memcmp(cur->ui128IpHash, curUser->ui128IpHash, 16) == 0 && strcasecmp(cur->sNick, curUser->sNick) == 0) {
int imsgLen = sprintf(msg, "<%s> %s %" PRIu64 " %s.|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_PLEASE_WAIT],
(cur->ui64DisConnTick+SettingManager->iShorts[SETSHORT_MIN_RECONN_TIME])-ui64ActualTick, LanguageManager->sTexts[LAN_SECONDS_BEFORE_RECONN]);
if(CheckSprintf(imsgLen, 1024, "classUsers::CheckRecTime1") == true) {
UserSendChar(curUser, msg, imsgLen);
}
return true;
}
}
return false;
}
void classUsers::DelFromUserIP(User * cur) {
int m = sprintf(msg,"$%s %s$", cur->sNick, cur->sIP);
if(CheckSprintf(m, 1024, "classUsers::DelFromUserIP") == false) {
return;
}
userIPList[7] = '$';
char *off = strstr(userIPList, msg);
userIPList[7] = ' ';
if(off != NULL) {
memmove(off+1, off+(m+1), userIPListLen-((off+m)-userIPList));
userIPListLen -= m;
iZUserIPListLen = 0;
}
}
void classUsers::DelFromOpList(char * Nick) {
int m = sprintf(msg, "$%s$", Nick);
if(CheckSprintf(m, 1024, "classUsers::DelFromOpList") == false) {
return;
}
opList[7] = '$';
char *off = strstr(opList, msg);
opList[7] = ' ';
if(off != NULL) {
memmove(off+1, off+(m+1), opListLen-((off+m)-opList));
opListLen -= m;
iZOpListLen = 0;
}
}
void classUsers::RemUser(User * u) {
if(u->prev == NULL) {
if(u->next == NULL) {
llist = NULL;
elist = NULL;
} else {
u->next->prev = NULL;
llist = u->next;
}
} else if(u->next == NULL) {
u->prev->next = NULL;
elist = u->prev;
} else {
u->prev->next = u->next;
u->next->prev = u->prev;
}
#ifdef _DEBUG
int iret = sprintf(msg, "# User %s removed from linked list.", u->sNick);
if(CheckSprintf(iret, 1024, "classUsers::RemUser") == true) {
Cout(msg);
}
#endif
}
bool DeFloodCheckInterval(User * u, const uint8_t &ui8DefloodType,
uint16_t &ui16Count, uint64_t &ui64LastOkTick,
const int16_t &ui16DefloodCount, const uint32_t &ui32DefloodTime, char * sOtherNick/* = NULL*/) {
if(ui16Count == 0) {
ui64LastOkTick = ui64ActualTick;
} else if(ui16Count >= ui16DefloodCount) {
if((ui64LastOkTick+ui32DefloodTime) > ui64ActualTick) {
ui16Count++;
int imsgLen = 0;
if(sOtherNick != NULL) {
imsgLen = sprintf(msg, "$To: %s From: %s $", u->sNick, sOtherNick);
if(CheckSprintf(imsgLen, 1024, "DeFloodCheckInterval1") == false) {
return true;
}
}
int iret = sprintf(msg+imsgLen, "<%s> %s %" PRIu64 " %s.|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_PLEASE_WAIT],
(ui64LastOkTick+ui32DefloodTime)-ui64ActualTick, DeFloodGetMessage(ui8DefloodType, 0));
imsgLen += iret;
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodCheckInterval2") == true) {
UserSendCharDelayed(u, msg, imsgLen);
}
return true;
} else {
ui64LastOkTick = ui64ActualTick;
ui16Count = 0;
}
} else if((ui64LastOkTick+ui32DefloodTime) <= ui64ActualTick) {
ui64LastOkTick = ui64ActualTick;
ui16Count = 0;
}
ui16Count++;
return false;
}
// appends data to the UserIPQueue
void clsGlobalDataQueue::UserIPStore(User * pUser) {
if(UserIPQueue.szLen == 0) {
UserIPQueue.szLen = sprintf(UserIPQueue.sBuffer, "$UserIP %s %s|", pUser->sNick, pUser->sIP);
UserIPQueue.bHaveDollars = false;
} else {
int iDataLen = sprintf(msg, "%s %s$$|", pUser->sNick, pUser->sIP);
if(CheckSprintf(iDataLen, 128, "clsGlobalDataQueue::UserIPStore") == true) {
if(UserIPQueue.bHaveDollars == false) {
UserIPQueue.sBuffer[UserIPQueue.szLen-1] = '$';
UserIPQueue.sBuffer[UserIPQueue.szLen] = '$';
UserIPQueue.bHaveDollars = true;
UserIPQueue.szLen += 2;
}
if(UserIPQueue.szSize < UserIPQueue.szLen+iDataLen) {
size_t szAllignLen = Allign256(UserIPQueue.szLen+iDataLen);
char * pOldBuf = UserIPQueue.sBuffer;
#ifdef _WIN32
UserIPQueue.sBuffer = (char *)HeapReAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, szAllignLen);
#else
UserIPQueue.sBuffer = (char *)realloc(pOldBuf, szAllignLen);
#endif
if(UserIPQueue.sBuffer == NULL) {
UserIPQueue.sBuffer = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in clsGlobalDataQueue::UserIPStore\n", (uint64_t)szAllignLen);
return;
}
UserIPQueue.szSize = (uint32_t)(szAllignLen-1);
}
memcpy(UserIPQueue.sBuffer+UserIPQueue.szLen-1, msg, iDataLen);
UserIPQueue.szLen += iDataLen-1;
UserIPQueue.sBuffer[UserIPQueue.szLen] = '\0';
}
}
}
clsScriptManager::clsScriptManager() : pRunningScriptE(NULL), pRunningScriptS(NULL), ppScriptTable(NULL), pActualUser(NULL), pTimerListS(NULL), pTimerListE(NULL), ui8ScriptCount(0), ui8BotsCount(0), bMoved(false) {
#ifdef _WIN32
clsServerManager::hLuaHeap = ::HeapCreate(HEAP_NO_SERIALIZE, 0x80000, 0);
#endif
#ifdef _WIN32
if(FileExist((clsServerManager::sPath + "\\cfg\\Scripts.pxt").c_str()) == false) {
#else
if(FileExist((clsServerManager::sPath + "/cfg/Scripts.pxt").c_str()) == false) {
#endif
LoadXML();
return;
}
#ifdef _WIN32
FILE * fScriptsFile = fopen((clsServerManager::sPath + "\\cfg\\Scripts.pxt").c_str(), "rt");
#else
FILE * fScriptsFile = fopen((clsServerManager::sPath + "/cfg/Scripts.pxt").c_str(), "rt");
#endif
if(fScriptsFile == NULL) {
#ifdef _WIN32
int imsgLen = sprintf(clsServerManager::pGlobalBuffer, "Error loading file Scripts.pxt %s (%d)", WSErrorStr(errno), errno);
#else
int imsgLen = sprintf(clsServerManager::pGlobalBuffer, "Error loading file Scripts.pxt %s (%d)", ErrnoStr(errno), errno);
#endif
CheckSprintf(imsgLen, clsServerManager::szGlobalBufferSize, "clsScriptManager::clsScriptManager");
#ifdef _BUILD_GUI
::MessageBox(NULL, clsServerManager::pGlobalBuffer, g_sPtokaXTitle, MB_OK | MB_ICONERROR);
#else
AppendLog(clsServerManager::pGlobalBuffer);
#endif
exit(EXIT_FAILURE);
}
size_t szLen = 0;
while(fgets(clsServerManager::pGlobalBuffer, (int)clsServerManager::szGlobalBufferSize, fScriptsFile) != NULL) {
if(clsServerManager::pGlobalBuffer[0] == '#' || clsServerManager::pGlobalBuffer[0] == '\n') {
continue;
}
szLen = strlen(clsServerManager::pGlobalBuffer)-1;
if(szLen < 7) {
continue;
}
clsServerManager::pGlobalBuffer[szLen] = '\0';
for(size_t szi = szLen-1; szi != 0; szi--) {
if(isspace(clsServerManager::pGlobalBuffer[szi-1]) != 0 || clsServerManager::pGlobalBuffer[szi-1] == '=') {
clsServerManager::pGlobalBuffer[szi-1] = '\0';
continue;
}
break;
}
if(clsServerManager::pGlobalBuffer[0] == '\0' || (clsServerManager::pGlobalBuffer[szLen-1] != '1' && clsServerManager::pGlobalBuffer[szLen-1] != '0')) {
continue;
}
if(FileExist((clsServerManager::sScriptPath+string(clsServerManager::pGlobalBuffer)).c_str()) == false || FindScript(clsServerManager::pGlobalBuffer) != NULL) {
continue;
}
AddScript(clsServerManager::pGlobalBuffer, clsServerManager::pGlobalBuffer[szLen-1] == '1' ? true : false, false);
}
fclose(fScriptsFile);
}
//------------------------------------------------------------------------------
clsScriptManager::~clsScriptManager() {
pRunningScriptS = NULL;
pRunningScriptE = NULL;
for(uint8_t ui8i = 0; ui8i < ui8ScriptCount; ui8i++) {
delete ppScriptTable[ui8i];
}
#ifdef _WIN32
if(HeapFree(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)ppScriptTable) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate ScriptTable in clsScriptManager::~clsScriptManager\n");
}
#else
free(ppScriptTable);
#endif
ppScriptTable = NULL;
ui8ScriptCount = 0;
pActualUser = NULL;
ui8BotsCount = 0;
#ifdef _WIN32
::HeapDestroy(clsServerManager::hLuaHeap);
#endif
}
//------------------------------------------------------------------------------
void clsScriptManager::Start() {
ui8BotsCount = 0;
pActualUser = NULL;
// PPK ... first look for deleted and new scripts
CheckForDeletedScripts();
CheckForNewScripts();
// PPK ... second start all enabled scripts
for(uint8_t ui8i = 0; ui8i < ui8ScriptCount; ui8i++) {
if(ppScriptTable[ui8i]->bEnabled == true) {
if(ScriptStart(ppScriptTable[ui8i]) == true) {
AddRunningScript(ppScriptTable[ui8i]);
} else {
ppScriptTable[ui8i]->bEnabled = false;
}
}
}
#ifdef _BUILD_GUI
clsMainWindowPageScripts::mPtr->AddScriptsToList(true);
#endif
}
// PPK ... check global mainchat flood and add to global queue
void classUsers::SendChat2All(User * cur, char * sData, const size_t &szChatLen, void * ptr) {
UdpDebug->Broadcast(sData, szChatLen);
if(ProfileMan->IsAllowed(cur, ProfileManager::NODEFLOODMAINCHAT) == false &&
SettingManager->iShorts[SETSHORT_GLOBAL_MAIN_CHAT_ACTION] != 0) {
if(iChatMsgs == 0) {
iChatMsgsTick = ui64ActualTick;
iChatLockFromTick = ui64ActualTick;
iChatMsgs = 0;
bChatLocked = false;
} else if((iChatMsgsTick+SettingManager->iShorts[SETSHORT_GLOBAL_MAIN_CHAT_TIME]) < ui64ActualTick) {
iChatMsgsTick = ui64ActualTick;
iChatMsgs = 0;
}
iChatMsgs++;
if(iChatMsgs > (uint16_t)SettingManager->iShorts[SETSHORT_GLOBAL_MAIN_CHAT_MESSAGES]) {
iChatLockFromTick = ui64ActualTick;
if(bChatLocked == false) {
if(SettingManager->bBools[SETBOOL_DEFLOOD_REPORT] == true) {
if(SettingManager->bBools[SETBOOL_SEND_STATUS_MESSAGES_AS_PM] == true) {
int imsgLen = sprintf(msg, "%s $<%s> *** %s.|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC],
LanguageManager->sTexts[LAN_GLOBAL_CHAT_FLOOD_DETECTED]);
if(CheckSprintf(imsgLen, 1024, "classUsers::SendChat2All1") == true) {
g_GlobalDataQueue->SingleItemStore(msg, imsgLen, NULL, 0, GlobalDataQueue::SI_PM2OPS);
}
} else {
int imsgLen = sprintf(msg, "<%s> *** %s.|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_GLOBAL_CHAT_FLOOD_DETECTED]);
if(CheckSprintf(imsgLen, 1024, "classUsers::SendChat2All2") == true) {
g_GlobalDataQueue->AddQueueItem(msg, imsgLen, NULL, 0, GlobalDataQueue::CMD_OPS);
}
}
}
bChatLocked = true;
}
}
if(bChatLocked == true) {
if((iChatLockFromTick+SettingManager->iShorts[SETSHORT_GLOBAL_MAIN_CHAT_TIMEOUT]) > ui64ActualTick) {
if(SettingManager->iShorts[SETSHORT_GLOBAL_MAIN_CHAT_ACTION] == 1) {
return;
} else if(SettingManager->iShorts[SETSHORT_GLOBAL_MAIN_CHAT_ACTION] == 2) {
if(szChatLen > 64000) {
sData[64000] = '\0';
}
int iMsgLen = sprintf(g_sBuffer, "%s ", cur->sIP);
if(CheckSprintf(iMsgLen, g_szBufferSize, "classUsers::SendChat2All3") == true) {
memcpy(g_sBuffer+iMsgLen, sData, szChatLen);
iMsgLen += (uint32_t)szChatLen;
g_sBuffer[iMsgLen] = '\0';
g_GlobalDataQueue->AddQueueItem(g_sBuffer, iMsgLen, NULL, 0, GlobalDataQueue::CMD_OPS);
}
return;
}
} else {
bChatLocked = false;
}
}
}
if(ptr == NULL) {
g_GlobalDataQueue->AddQueueItem(sData, szChatLen, NULL, 0, GlobalDataQueue::CMD_CHAT);
} else {
g_GlobalDataQueue->FillBlankQueueItem(sData, szChatLen, ptr);
}
}
void DeFloodDoAction(User * u, const uint8_t &ui8DefloodType, const int16_t &ui16Action,
uint16_t &ui16Count, char * sOtherNick) {
int imsgLen = 0;
if(sOtherNick != NULL) {
imsgLen = sprintf(msg, "$To: %s From: %s $", u->sNick, sOtherNick);
if(CheckSprintf(imsgLen, 1024, "DeFloodDoAction1") == false) {
return;
}
}
switch(ui16Action) {
case 1: {
int iret = sprintf(msg+imsgLen, "<%s> %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], DeFloodGetMessage(ui8DefloodType, 0));
imsgLen += iret;
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodDoAction2") == true) {
UserSendCharDelayed(u, msg, imsgLen);
}
if(ui8DefloodType != DEFLOOD_MAX_DOWN) {
ui16Count++;
}
return;
}
case 2:
u->iDefloodWarnings++;
if(DeFloodCheckForWarn(u, ui8DefloodType, sOtherNick) == false && ui8DefloodType != DEFLOOD_MAX_DOWN) {
ui16Count++;
}
return;
case 3: {
int iret = sprintf(msg+imsgLen, "<%s> %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], DeFloodGetMessage(ui8DefloodType, 0));
imsgLen += iret;
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodDoAction3") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_DISCONNECTED]);
UserClose(u);
return;
}
case 4: {
hashBanManager->TempBan(u, DeFloodGetMessage(ui8DefloodType, 1), NULL, 0, 0, false);
int iret = sprintf(msg+imsgLen, "<%s> %s: %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_BEING_KICKED_BCS],
DeFloodGetMessage(ui8DefloodType, 1));
imsgLen += iret;
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodDoAction4") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_KICKED]);
UserClose(u);
return;
}
case 5: {
hashBanManager->TempBan(u, DeFloodGetMessage(ui8DefloodType, 1), NULL,
SettingManager->iShorts[SETSHORT_DEFLOOD_TEMP_BAN_TIME], 0, false);
int iret = sprintf(msg+imsgLen, "<%s> %s: %s %s: %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_HAD_BEEN_TEMP_BANNED_TO],
formatTime(SettingManager->iShorts[SETSHORT_DEFLOOD_TEMP_BAN_TIME]), LanguageManager->sTexts[LAN_BECAUSE_LWR], DeFloodGetMessage(ui8DefloodType, 1));
imsgLen += iret;
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodDoAction5") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_TEMPORARY_BANNED]);
UserClose(u);
return;
}
case 6: {
hashBanManager->Ban(u, DeFloodGetMessage(ui8DefloodType, 1), NULL, false);
int iret = sprintf(msg+imsgLen, "<%s> %s: %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_ARE_BEING_BANNED_BECAUSE],
DeFloodGetMessage(ui8DefloodType, 1));
imsgLen += iret;
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodDoAction6") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_BANNED]);
UserClose(u);
return;
}
}
}
static int AddReg(lua_State * L) {
if(lua_gettop(L) == 3) {
if(lua_type(L, 1) != LUA_TSTRING || lua_type(L, 2) != LUA_TSTRING || lua_type(L, 3) != LUA_TNUMBER) {
luaL_checktype(L, 1, LUA_TSTRING);
luaL_checktype(L, 2, LUA_TSTRING);
luaL_checktype(L, 3, LUA_TNUMBER);
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
size_t szNickLen, szPassLen;
char *sNick = (char *)lua_tolstring(L, 1, &szNickLen);
char *sPass = (char *)lua_tolstring(L, 2, &szPassLen);
#if LUA_VERSION_NUM < 503
uint16_t i16Profile = (uint16_t)lua_tonumber(L, 3);
#else
uint16_t i16Profile = (uint16_t)lua_tounsigned(L, 3);
#endif
if(i16Profile > clsProfileManager::mPtr->iProfileCount-1 || szNickLen == 0 || szNickLen > 64 || szPassLen == 0 || szPassLen > 64 || strpbrk(sNick, " $|") != NULL || strchr(sPass, '|') != NULL) {
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
bool bAdded = clsRegManager::mPtr->AddNew(sNick, sPass, i16Profile);
lua_settop(L, 0);
if(bAdded == false) {
lua_pushnil(L);
return 1;
}
lua_pushboolean(L, 1);
return 1;
} else if(lua_gettop(L) == 2) {
if(lua_type(L, 1) != LUA_TSTRING || lua_type(L, 2) != LUA_TNUMBER) {
luaL_checktype(L, 1, LUA_TSTRING);
luaL_checktype(L, 2, LUA_TNUMBER);
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
size_t szNickLen;
char *sNick = (char *)lua_tolstring(L, 1, &szNickLen);
#if LUA_VERSION_NUM < 503
uint16_t ui16Profile = (uint16_t)lua_tonumber(L, 2);
#else
uint16_t ui16Profile = (uint16_t)lua_tounsigned(L, 2);
#endif
if(ui16Profile > clsProfileManager::mPtr->iProfileCount-1 || szNickLen == 0 || szNickLen > 64 || strpbrk(sNick, " $|") != NULL) {
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
// check if user is registered
if(clsRegManager::mPtr->Find(sNick, szNickLen) != NULL) {
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
User * pUser = clsHashManager::mPtr->FindUser(sNick, szNickLen);
if(pUser == NULL) {
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
if(pUser->uLogInOut == NULL) {
pUser->uLogInOut = new LoginLogout();
if(pUser->uLogInOut == NULL) {
pUser->ui32BoolBits |= User::BIT_ERROR;
pUser->Close();
AppendDebugLog("%s - [MEM] Cannot allocate new pUser->uLogInOut in RegMan.AddReg\n", 0);
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
}
pUser->SetBuffer(clsProfileManager::mPtr->ProfilesTable[ui16Profile]->sName);
pUser->ui32BoolBits |= User::BIT_WAITING_FOR_PASS;
int iMsgLen = sprintf(clsServerManager::sGlobalBuffer, "<%s> %s.|$GetPass|", clsSettingManager::mPtr->sPreTexts[clsSettingManager::SETPRETXT_HUB_SEC], clsLanguageManager::mPtr->sTexts[LAN_YOU_WERE_REGISTERED_PLEASE_ENTER_YOUR_PASSWORD]);
if(CheckSprintf(iMsgLen, clsServerManager::szGlobalBufferSize, "RegMan.AddReg1") == true) {
pUser->SendCharDelayed(clsServerManager::sGlobalBuffer, iMsgLen);
}
lua_settop(L, 0);
lua_pushboolean(L, 1);
return 1;
} else {
luaL_error(L, "bad argument count to 'RegMan.AddReg' (2 or 3 expected, got %d)", lua_gettop(L));
lua_settop(L, 0);
lua_pushnil(L);
return 1;
}
}
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;
}
bool DeFloodCheckForWarn(User * u, const uint8_t &ui8DefloodType, char * sOtherNick) {
if(u->iDefloodWarnings < (uint32_t)SettingManager->iShorts[SETSHORT_DEFLOOD_WARNING_COUNT]) {
int imsgLen = sprintf(msg, "<%s> %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], DeFloodGetMessage(ui8DefloodType, 0));
if(CheckSprintf(imsgLen, 1024, "DeFloodCheckForWarn1") == true) {
UserSendCharDelayed(u, msg, imsgLen);
}
return false;
} else {
int imsgLen = 0;
if(sOtherNick != NULL) {
imsgLen = sprintf(msg, "$To: %s From: %s $", u->sNick, sOtherNick);
if(CheckSprintf(imsgLen, 1024, "DeFloodCheckForWarn2") == false) {
return true;
}
}
switch(SettingManager->iShorts[SETSHORT_DEFLOOD_WARNING_ACTION]) {
case 0: {
int iret = sprintf(msg+imsgLen, "<%s> %s: %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_ARE_BEING_DISCONNECTED_BECAUSE],
DeFloodGetMessage(ui8DefloodType, 1));
imsgLen += iret;
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodCheckForWarn3") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_DISCONNECTED]);
break;
}
case 1: {
hashBanManager->TempBan(u, DeFloodGetMessage(ui8DefloodType, 1), NULL, 0, 0, false);
int iret = sprintf(msg+imsgLen, "<%s> %s: %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_BEING_KICKED_BCS],
DeFloodGetMessage(ui8DefloodType, 1));
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodCheckForWarn4") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_KICKED]);
break;
}
case 2: {
hashBanManager->TempBan(u, DeFloodGetMessage(ui8DefloodType, 1), NULL,
SettingManager->iShorts[SETSHORT_DEFLOOD_TEMP_BAN_TIME], 0, false);
int iret = sprintf(msg+imsgLen, "<%s> %s: %s %s: %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_HAD_BEEN_TEMP_BANNED_TO],
formatTime(SettingManager->iShorts[SETSHORT_DEFLOOD_TEMP_BAN_TIME]), LanguageManager->sTexts[LAN_BECAUSE_LWR], DeFloodGetMessage(ui8DefloodType, 1));
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodCheckForWarn5") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_TEMPORARY_BANNED]);
break;
}
case 3: {
hashBanManager->Ban(u, DeFloodGetMessage(ui8DefloodType, 1), NULL, false);
int iret = sprintf(msg+imsgLen, "<%s> %s: %s!|", SettingManager->sPreTexts[SetMan::SETPRETXT_HUB_SEC], LanguageManager->sTexts[LAN_YOU_ARE_BEING_BANNED_BECAUSE],
DeFloodGetMessage(ui8DefloodType, 1));
if(CheckSprintf1(iret, imsgLen, 1024, "DeFloodCheckForWarn6") == true) {
UserSendChar(u, msg, imsgLen);
}
DeFloodReport(u, ui8DefloodType, LanguageManager->sTexts[LAN_WAS_BANNED]);
break;
}
}
UserClose(u);
return true;
}
}
bool clsTextFilesManager::ProcessTextFilesCmd(User * u, char * cmd, bool fromPM/* = false*/) const {
TextFile * next = TextFiles;
while(next != NULL) {
TextFile * cur = next;
next = cur->next;
if(strcasecmp(cur->sCommand, cmd) == 0) {
bool bInPM = (clsSettingManager::mPtr->bBools[SETBOOL_SEND_TEXT_FILES_AS_PM] == true || fromPM);
size_t szHubSecLen = (size_t)clsSettingManager::mPtr->ui16PreTextsLens[clsSettingManager::SETPRETXT_HUB_SEC];
size_t szChatLen = 0;
// PPK ... to chat or to PM ???
if(bInPM == true) {
szChatLen = 18+u->ui8NickLen+(2*szHubSecLen)+strlen(cur->sText);
} else {
szChatLen = 4+szHubSecLen+strlen(cur->sText);
}
#ifdef _WIN32
char * sMSG = (char *)HeapAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, szChatLen);
#else
char * sMSG = (char *)malloc(szChatLen);
#endif
if(sMSG == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for sMsg in clsTextFilesManager::ProcessTextFilesCmd\n", (uint64_t)szChatLen);
return true;
}
if(bInPM == true) {
int iret = sprintf(sMSG, "$To: %s From: %s $<%s> %s", u->sNick, clsSettingManager::mPtr->sPreTexts[clsSettingManager::SETPRETXT_HUB_SEC], clsSettingManager::mPtr->sPreTexts[clsSettingManager::SETPRETXT_HUB_SEC],
cur->sText);
if(CheckSprintf(iret, szChatLen, "clsTextFilesManager::ProcessTextFilesCmd1") == false) {
free(sMSG);
return true;
}
} else {
int iret = sprintf(sMSG,"<%s> %s", clsSettingManager::mPtr->sPreTexts[clsSettingManager::SETPRETXT_HUB_SEC], cur->sText);
if(CheckSprintf(iret, szChatLen, "clsTextFilesManager::ProcessTextFilesCmd2") == false) {
free(sMSG);
return true;
}
}
u->SendCharDelayed(sMSG, szChatLen-1);
#ifdef _WIN32
if(HeapFree(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)sMSG) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate sMSG in clsTextFilesManager::ProcessTextFilesCmd\n", 0);
}
#else
free(sMSG);
#endif
return true;
}
}
return false;
}
void clsEventQueue::ProcessEvents() {
event * next = NormalS;
NormalS = NULL;
NormalE = NULL;
while(next != NULL) {
event * cur = next;
next = cur->next;
switch(cur->ui8Id) {
case EVENT_RESTART:
clsServerManager::bIsRestart = true;
clsServerManager::Stop();
break;
case EVENT_RSTSCRIPTS:
clsScriptManager::mPtr->Restart();
break;
case EVENT_RSTSCRIPT: {
Script * curScript = clsScriptManager::mPtr->FindScript(cur->sMsg);
if(curScript == NULL || curScript->bEnabled == false || curScript->LUA == NULL) {
return;
}
clsScriptManager::mPtr->StopScript(curScript, false);
clsScriptManager::mPtr->StartScript(curScript, false);
break;
}
case EVENT_STOPSCRIPT: {
Script * curScript = clsScriptManager::mPtr->FindScript(cur->sMsg);
if(curScript == NULL || curScript->bEnabled == false || curScript->LUA == NULL) {
return;
}
clsScriptManager::mPtr->StopScript(curScript, true);
break;
}
case EVENT_STOP_SCRIPTING:
if(clsSettingManager::mPtr->bBools[SETBOOL_ENABLE_SCRIPTING] == true) {
clsSettingManager::mPtr->bBools[SETBOOL_ENABLE_SCRIPTING] = false;
clsScriptManager::mPtr->OnExit(true);
clsScriptManager::mPtr->Stop();
}
break;
case EVENT_SHUTDOWN:
if(clsServerManager::bIsClose == true) {
break;
}
clsServerManager::bIsClose = true;
clsServerManager::Stop();
break;
default:
break;
}
#ifdef _WIN32
if(cur->sMsg != NULL) {
if(HeapFree(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)cur->sMsg) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate cur->sMsg in clsEventQueue::ProcessEvents\n", 0);
}
}
#else
free(cur->sMsg);
#endif
delete cur;
}
#ifdef _WIN32
EnterCriticalSection(&csEventQueue);
#else
pthread_mutex_lock(&mtxEventQueue);
#endif
next = ThreadS;
ThreadS = NULL;
ThreadE = NULL;
#ifdef _WIN32
LeaveCriticalSection(&csEventQueue);
#else
pthread_mutex_unlock(&mtxEventQueue);
#endif
while(next != NULL) {
event * cur = next;
next = cur->next;
switch(cur->ui8Id) {
case EVENT_REGSOCK_MSG:
clsUdpDebug::mPtr->Broadcast(cur->sMsg);
break;
case EVENT_SRVTHREAD_MSG:
clsUdpDebug::mPtr->Broadcast(cur->sMsg);
break;
case EVENT_UDP_SR: {
size_t szMsgLen = strlen(cur->sMsg);
clsServerManager::ui64BytesRead += (uint64_t)szMsgLen;
char *temp = strchr(cur->sMsg+4, ' ');
if(temp == NULL) {
break;;
}
size_t szLen = (temp-cur->sMsg)-4;
if(szLen > 64 || szLen == 0) {
break;
}
// terminate nick, needed for strcasecmp in clsHashManager
temp[0] = '\0';
User *u = clsHashManager::mPtr->FindUser(cur->sMsg+4, szLen);
if(u == NULL) {
break;
}
// add back space after nick...
temp[0] = ' ';
if(memcmp(cur->ui128IpHash, u->ui128IpHash, 16) != 0) {
break;
}
#ifdef _BUILD_GUI
if(::SendMessage(clsMainWindowPageUsersChat::mPtr->hWndPageItems[clsMainWindowPageUsersChat::BTN_SHOW_COMMANDS], BM_GETCHECK, 0, 0) == BST_CHECKED) {
char msg[128];
int imsglen = sprintf(msg, "UDP > %s (%s) > ", u->sNick, u->sIP);
if(CheckSprintf(imsglen, 128, "clsEventQueue::ProcessEvents") == true) {
RichEditAppendText(clsMainWindowPageUsersChat::mPtr->hWndPageItems[clsMainWindowPageUsersChat::REDT_CHAT], (string(msg, imsglen)+cur->sMsg).c_str());
}
}
#endif
clsDcCommands::mPtr->SRFromUDP(u, cur->sMsg, szMsgLen);
break;
}
default:
break;
}
free(cur->sMsg);
delete cur;
}
}