static void WINAPI StartService(DWORD /*argc*/, char* argv[]) {
ssh = RegisterServiceCtrlHandler(argv[0], CtrlHandler);
if(ssh == NULL) {
AppendLog("RegisterServiceCtrlHandler failed ("+string((uint32_t)GetLastError())+")!");
return;
}
ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
ss.dwCurrentState = SERVICE_START_PENDING;
ss.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP;
ss.dwWin32ExitCode = NO_ERROR;
ss.dwCheckPoint = 0;
ss.dwWaitHint = 10 * 1000;
if(SetServiceStatus(ssh, &ss) == false) {
AppendLog("StartService::SetServiceStatus failed ("+string((uint32_t)GetLastError())+")!");
return;
}
ServerInitialize();
if(ServerStart() == false) {
AppendLog("Server start failed!");
ss.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(ssh, &ss);
return;
}
ss.dwCurrentState = SERVICE_RUNNING;
if(SetServiceStatus(ssh, &ss) == false) {
AppendLog("StartService::SetServiceStatus1 failed ("+string((uint32_t)GetLastError())+")!");
return;
}
MSG msg;
BOOL bRet;
while((bRet = GetMessage(&msg, NULL, 0, 0)) != 0) {
if(bRet == -1) {
// handle the error and possibly exit
} else {
if(msg.message == WM_USER+1) {
break;
} else if(msg.message == WM_TIMER) {
if(msg.wParam == sectimer) {
ServerOnSecTimer();
} else if(msg.wParam == srvLoopTimer) {
srvLoop->Looper();
} else if(msg.wParam == regtimer) {
ServerOnRegTimer();
} else {
//Must be script timer
ScriptOnTimer(msg.wParam);
}
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
ExceptionHandlingUnitialize();
ss.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(ssh, &ss);
}
int __cdecl main(int argc, char* argv[]) {
::SetDllDirectory("");
#ifndef _WIN64
HINSTANCE hKernel32 = ::LoadLibrary("Kernel32.dll");
typedef BOOL (WINAPI * SPDEPP)(DWORD);
SPDEPP pSPDEPP = (SPDEPP)::GetProcAddress(hKernel32, "SetProcessDEPPolicy");
if(pSPDEPP != NULL) {
pSPDEPP(PROCESS_DEP_ENABLE);
}
::FreeLibrary(hKernel32);
#endif
sTitle = "PtokaX DC Hub " + string(PtokaXVersionString);
#ifdef _DEBUG
sTitle += " [debug]";
#endif
#ifdef _DEBUG
// AllocConsole();
// hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
// Cout("PtokaX Debug console\n");
#endif
char sBuf[MAX_PATH+1];
::GetModuleFileName(NULL, sBuf, MAX_PATH);
char * sPath = strrchr(sBuf, '\\');
if(sPath != NULL) {
PATH = string(sBuf, sPath-sBuf);
} else {
PATH = sBuf;
}
char * sServiceName = NULL;
bool bInstallService = false;
for(int i = 0; i < argc; i++) {
if(stricmp(argv[i], "-s") == NULL || stricmp(argv[i], "/service") == NULL) {
if(++i == argc) {
AppendLog("Missing service name!");
return EXIT_FAILURE;
}
sServiceName = argv[i];
bService = true;
} else if(stricmp(argv[i], "-c") == 0) {
if(++i == argc) {
printf("Missing config directory!");
return EXIT_FAILURE;
}
size_t szLen = strlen(argv[i]);
if(szLen >= 1 && argv[i][0] != '\\' && argv[i][0] != '/') {
if(szLen < 4 || (argv[i][1] != ':' || (argv[i][2] != '\\' && argv[i][2] != '/'))) {
printf("Config directory must be absolute path!");
return EXIT_FAILURE;
}
}
if(argv[i][szLen - 1] == '/' || argv[i][szLen - 1] == '\\') {
PATH = string(argv[i], szLen - 1);
} else {
PATH = string(argv[i], szLen);
}
if(DirExist(PATH.c_str()) == false) {
if(CreateDirectory(PATH.c_str(), NULL) == 0) {
printf("Config directory not exist and can't be created!");
return EXIT_FAILURE;
}
}
} else if(stricmp(argv[i], "-i") == NULL || stricmp(argv[i], "/install") == NULL) {
if(++i == argc) {
printf("Please specify service name!");
return EXIT_FAILURE;
}
sServiceName = argv[i];
bInstallService = true;
} else if(stricmp(argv[i], "-u") == NULL || stricmp(argv[i], "/uninstall") == NULL) {
if(++i == argc) {
printf("Please specify service name!");
return EXIT_FAILURE;
}
sServiceName = argv[i];
return UninstallService(sServiceName);
} else if(stricmp(argv[i], "-v") == NULL || stricmp(argv[i], "/version") == NULL) {
printf((sTitle+" built on "+__DATE__+" "+__TIME__).c_str());
return EXIT_SUCCESS;
} else if(stricmp(argv[i], "-h") == NULL || stricmp(argv[i], "/help") == NULL) {
printf("PtokaX [-c <configdir>] [-i <servicename>] [-u <servicename>] [-v]");
return EXIT_SUCCESS;
} else if(stricmp(argv[i], "/nokeycheck") == NULL) {
bCmdNoKeyCheck = true;
} else if(stricmp(argv[i], "/generatexmllanguage") == NULL) {
LangMan::GenerateXmlExample();
return EXIT_SUCCESS;
}
}
if(bInstallService == true) {
if(sPath == NULL && strcmp(PATH.c_str(), sBuf) == 0) {
return InstallService(sServiceName, NULL);
} else {
return InstallService(sServiceName, PATH.c_str());
}
}
ExceptionHandlingInitialize(PATH, sBuf);
if(bService == false) {
ServerInitialize();
if(ServerStart() == false) {
printf("Server start failed!");
ExceptionHandlingUnitialize();
return EXIT_FAILURE;
} else {
printf((sTitle+" running...\n").c_str());
}
MSG msg;
BOOL bRet;
while((bRet = ::GetMessage(&msg, NULL, 0, 0)) != 0) {
if(bRet == -1) {
// handle the error and possibly exit
} else {
if(msg.message == WM_USER+1) {
break;
} else if(msg.message == WM_TIMER) {
if(msg.wParam == srvLoopTimer) {
srvLoop->Looper();
} else if(msg.wParam == regtimer) {
ServerOnRegTimer();
} else {
//Must be script timer
ScriptOnTimer(msg.wParam);
}
}
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
}
ExceptionHandlingUnitialize();
} else {
SERVICE_TABLE_ENTRY DispatchTable[] = {
{ sServiceName, StartService },
{ NULL, NULL }
};
if(StartServiceCtrlDispatcher(DispatchTable) == false) {
AppendLog("StartServiceCtrlDispatcher failed ("+string((uint32_t)GetLastError())+")!");
ExceptionHandlingUnitialize();
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
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;
}
