void ResNickMan::AddReservedNick(const char * sNick, const bool &bFromScript/* = false*/) {
uint32_t ulHash = HashNick(sNick, strlen(sNick));
if(CheckReserved(sNick, ulHash) == false) {
ReservedNick * pNewNick = new ReservedNick(sNick, ulHash);
if(pNewNick == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pNewNick in ResNickMan::AddReservedNick\n", 0);
return;
} else if(pNewNick->sNick == NULL) {
delete pNewNick;
AppendDebugLog("%s - [MEM] Cannot allocate pNewNick->sNick in ResNickMan::AddReservedNick\n", 0);
return;
}
if(ReservedNicks == NULL) {
ReservedNicks = pNewNick;
} else {
ReservedNicks->prev = pNewNick;
pNewNick->next = ReservedNicks;
ReservedNicks = pNewNick;
}
pNewNick->bFromScript = bFromScript;
}
}
void classUsers::AddBot2NickList(char * Nick, const size_t &szNickLen, const bool &isOp) {
// $NickList nick$$nick2$$|
if(nickListSize < nickListLen+szNickLen+2) {
char * pOldBuf = nickList;
#ifdef _WIN32
nickList = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, nickListSize+NICKLISTSIZE+1);
#else
nickList = (char *)realloc(pOldBuf, nickListSize+NICKLISTSIZE+1);
#endif
if(nickList == NULL) {
nickList = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in classUsers::AddBot2NickList for NickList\n", (uint64_t)(nickListSize+NICKLISTSIZE+1));
return;
}
nickListSize += NICKLISTSIZE;
}
memcpy(nickList+nickListLen-1, Nick, szNickLen);
nickListLen += (uint32_t)(szNickLen+2);
nickList[nickListLen-3] = '$';
nickList[nickListLen-2] = '$';
nickList[nickListLen-1] = '|';
nickList[nickListLen] = '\0';
iZNickListLen = 0;
if(isOp == false)
return;
if(opListSize < opListLen+szNickLen+2) {
char * pOldBuf = opList;
#ifdef _WIN32
opList = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, opListSize+OPLISTSIZE+1);
#else
opList = (char *)realloc(pOldBuf, opListSize+OPLISTSIZE+1);
#endif
if(opList == NULL) {
opList = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in classUsers::AddBot2NickList for opList\n", (uint64_t)(opListSize+OPLISTSIZE+1));
return;
}
opListSize += OPLISTSIZE;
}
memcpy(opList+opListLen-1, Nick, szNickLen);
opListLen += (uint32_t)(szNickLen+2);
opList[opListLen-3] = '$';
opList[opListLen-2] = '$';
opList[opListLen-1] = '|';
opList[opListLen] = '\0';
iZOpListLen = 0;
}
void clsEventQueue::AddNormal(uint8_t ui8Id, char * sMsg) {
if(ui8Id != EVENT_RSTSCRIPT && ui8Id != EVENT_STOPSCRIPT) {
event * next = NormalS;
while(next != NULL) {
event * cur = next;
next = cur->next;
if(cur->ui8Id == ui8Id) {
return;
}
}
}
event * pNewEvent = new event();
if(pNewEvent == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pNewEvent in clsEventQueue::AddNormal\n", 0);
return;
}
if(sMsg != NULL) {
size_t szLen = strlen(sMsg);
#ifdef _WIN32
pNewEvent->sMsg = (char *)HeapAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, szLen+1);
#else
pNewEvent->sMsg = (char *)malloc(szLen+1);
#endif
if(pNewEvent->sMsg == NULL) {
delete pNewEvent;
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for pNewEvent->sMsg in clsEventQueue::AddNormal\n", (uint64_t)(szLen+1));
return;
}
memcpy(pNewEvent->sMsg, sMsg, szLen);
pNewEvent->sMsg[szLen] = '\0';
} else {
pNewEvent->sMsg = NULL;
}
pNewEvent->ui8Id = ui8Id;
if(NormalS == NULL) {
NormalS = pNewEvent;
pNewEvent->prev = NULL;
} else {
pNewEvent->prev = NormalE;
NormalE->next = pNewEvent;
}
NormalE = pNewEvent;
pNewEvent->next = NULL;
}
void classUsers::AddBot2MyInfos(char * MyInfo) {
size_t len = strlen(MyInfo);
if(myInfosTag != NULL) {
if(strstr(myInfosTag, MyInfo) == NULL ) {
if(myInfosTagSize < myInfosTagLen+len) {
char * pOldBuf = myInfosTag;
#ifdef _WIN32
myInfosTag = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, myInfosTagSize+MYINFOLISTSIZE+1);
#else
myInfosTag = (char *)realloc(pOldBuf, myInfosTagSize+MYINFOLISTSIZE+1);
#endif
if(myInfosTag == NULL) {
myInfosTag = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes for myInfosTag in classUsers::AddBot2MyInfos\n", (uint64_t)(myInfosTagSize+MYINFOLISTSIZE+1));
return;
}
myInfosTagSize += MYINFOLISTSIZE;
}
memcpy(myInfosTag+myInfosTagLen, MyInfo, len);
myInfosTagLen += (uint32_t)len;
myInfosTag[myInfosTagLen] = '\0';
iZMyInfosLen = 0;
}
}
if(myInfos != NULL) {
if(strstr(myInfos, MyInfo) == NULL ) {
if(myInfosSize < myInfosLen+len) {
char * pOldBuf = myInfos;
#ifdef _WIN32
myInfos = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, myInfosSize+MYINFOLISTSIZE+1);
#else
myInfos = (char *)realloc(pOldBuf, myInfosSize+MYINFOLISTSIZE+1);
#endif
if(myInfos == NULL) {
myInfos = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes for myInfos in classUsers::AddBot2MyInfos\n", (uint64_t)(myInfosSize+MYINFOLISTSIZE+1));
return;
}
myInfosSize += MYINFOLISTSIZE;
}
memcpy(myInfos+myInfosLen, MyInfo, len);
myInfosLen += (uint32_t)len;
myInfos[myInfosLen] = '\0';
iZMyInfosTagLen = 0;
}
}
}
void GlobalDataQueue::InsertQueueItem(char * sCommand, const size_t &szLen, void * pBeforeItem, const uint8_t &ui8CmdType) {
QueueItem * pNewItem = new QueueItem();
if(pNewItem == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pNewItem in GlobalDataQueue::InsertQueueItem\n", 0);
return;
}
#ifdef _WIN32
pNewItem->sCommand1 = (char *)HeapAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, szLen);
#else
pNewItem->sCommand1 = (char *)malloc(szLen+1);
#endif
if(pNewItem->sCommand1 == NULL) {
delete pNewItem;
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for pNewItem->sCommand1 in GlobalDataQueue::InsertQueueItem\n", (uint64_t)(szLen+1));
return;
}
memcpy(pNewItem->sCommand1, sCommand, szLen);
pNewItem->sCommand1[szLen] = '\0';
pNewItem->szLen1 = szLen;
pNewItem->sCommand2 = NULL;
pNewItem->szLen2 = 0;
pNewItem->ui8CommandType = ui8CmdType;
pNewItem->pNext = (QueueItem *)pBeforeItem;
QueueItem * pNext = pNewQueueItems[0];
if(pNext == pBeforeItem) {
pNewQueueItems[0] = pNewItem;
return;
}
while(pNext != NULL) {
QueueItem * pCur = pNext;
pNext = pCur->pNext;
if(pNext == pBeforeItem) {
pCur->pNext = pNewItem;
return;
}
}
}
// 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 classUsers::Add2OpList(User * u) {
if(opListSize < opListLen+u->ui8NickLen+2) {
char * pOldBuf = opList;
#ifdef _WIN32
opList = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, opListSize+OPLISTSIZE+1);
#else
opList = (char *)realloc(pOldBuf, opListSize+OPLISTSIZE+1);
#endif
if(opList == NULL) {
opList = pOldBuf;
u->ui32BoolBits |= User::BIT_ERROR;
UserClose(u);
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in classUsers::Add2OpList for opList\n", (uint64_t)(opListSize+OPLISTSIZE+1));
return;
}
opListSize += OPLISTSIZE;
}
memcpy(opList+opListLen-1, u->sNick, u->ui8NickLen);
opListLen += (uint32_t)(u->ui8NickLen+2);
opList[opListLen-3] = '$';
opList[opListLen-2] = '$';
opList[opListLen-1] = '|';
opList[opListLen] = '\0';
iZOpListLen = 0;
}
void classUsers::Add2MyInfosTag(User * u) {
if(myInfosTagSize < myInfosTagLen+u->ui16MyInfoLongLen) {
char * pOldBuf = myInfosTag;
#ifdef _WIN32
myInfosTag = (char *)HeapReAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, myInfosTagSize+MYINFOLISTSIZE+1);
#else
myInfosTag = (char *)realloc(pOldBuf, myInfosTagSize+MYINFOLISTSIZE+1);
#endif
if(myInfosTag == NULL) {
myInfosTag = pOldBuf;
u->ui32BoolBits |= User::BIT_ERROR;
UserClose(u);
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in classUsers::Add2MyInfosTag\n", (uint64_t)(myInfosTagSize+MYINFOLISTSIZE+1));
return;
}
myInfosTagSize += MYINFOLISTSIZE;
}
memcpy(myInfosTag+myInfosTagLen, u->sMyInfoLong, u->ui16MyInfoLongLen);
myInfosTagLen += u->ui16MyInfoLongLen;
myInfosTag[myInfosTagLen] = '\0';
iZMyInfosTagLen = 0;
}
string & string::operator+=(const string & sStr) {
if(sStr.c_str() == sEmpty) {
return *this;
}
char * oldbuf = sData;
if(sData == sEmpty) {
sData = (char *)malloc(szDataLen+sStr.size()+1);
} else {
sData = (char *)realloc(oldbuf, szDataLen+sStr.size()+1);
}
if(sData == NULL) {
sData = oldbuf;
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for sData in string::operator+=(string)\n", (uint64_t)(szDataLen+sStr.size()+1));
return *this;
}
memcpy(sData+szDataLen, sStr.c_str(), sStr.size());
szDataLen += sStr.size();
sData[szDataLen] = '\0';
return *this;
}
ReservedNicksManager::ReservedNick * ReservedNicksManager::ReservedNick::CreateReservedNick(const char * sNewNick, const uint32_t ui32NickHash) {
ReservedNick * pReservedNick = new (std::nothrow) ReservedNick();
if(pReservedNick == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate new pReservedNick in ReservedNick::CreateReservedNick\n");
return NULL;
}
size_t szNickLen = strlen(sNewNick);
#ifdef _WIN32
pReservedNick->m_sNick = (char *)HeapAlloc(ServerManager::m_hPtokaXHeap, HEAP_NO_SERIALIZE, szNickLen+1);
#else
pReservedNick->m_sNick = (char *)malloc(szNickLen+1);
#endif
if(pReservedNick->m_sNick == NULL) {
AppendDebugLogFormat("[MEM] Cannot allocate %zu bytes in ReservedNick::CreateReservedNick\n", szNickLen+1);
delete pReservedNick;
return NULL;
}
memcpy(pReservedNick->m_sNick, sNewNick, szNickLen);
pReservedNick->m_sNick[szNickLen] = '\0';
pReservedNick->m_ui32Hash = ui32NickHash;
return pReservedNick;
}
string & string::operator+=(const char * sTxt) {
size_t szLen = strlen(sTxt);
char * oldbuf = sData;
if(sData == sEmpty) {
sData = (char *)malloc(szDataLen+szLen+1);
} else {
sData = (char *)realloc(oldbuf, szDataLen+szLen+1);
}
if(sData == NULL) {
sData = oldbuf;
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for sData in string::operator+=(char)\n", (uint64_t)(szDataLen+szLen+1));
return *this;
}
memcpy(sData+szDataLen, sTxt, szLen);
szDataLen += szLen;
sData[szDataLen] = '\0';
return *this;
}
void theLoop::Looper() {
#ifdef _WIN32
KillTimer(NULL, srvLoopTimer);
#endif
// PPK ... two loop stategy for saving badwith
if(bRecv == true) {
ReceiveLoop();
} else {
SendLoop();
eventqueue->ProcessEvents();
}
if(bServerTerminated == false) {
bRecv = !bRecv;
#ifdef _WIN32
srvLoopTimer = SetTimer(NULL, 0, 100, NULL);
if(srvLoopTimer == 0) {
AppendDebugLog("%s - [ERR] Cannot start Looper in theLoop::Looper\n", 0);
exit(EXIT_FAILURE);
}
#endif
} else {
// tell the scripts about the end
ScriptManager->OnExit();
// send last possible global data
g_GlobalDataQueue->SendFinalQueue();
ServerFinalStop(true);
}
}
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;
}
void clsGlobalDataQueue::SingleItemStore(char * sData, const size_t &szDataLen, User * pFromUser, const int32_t &i32Profile, const uint8_t &ui8Type) {
SingleDataItem * pNewItem = new SingleDataItem();
if(pNewItem == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pNewItem in clsGlobalDataQueue::SingleItemStore\n", 0);
return;
}
if(sData != NULL) {
#ifdef _WIN32
pNewItem->sData = (char *)HeapAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, szDataLen+1);
#else
pNewItem->sData = (char *)malloc(szDataLen+1);
#endif
if(pNewItem->sData == NULL) {
delete pNewItem;
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes in clsGlobalDataQueue::SingleItemStore\n", (uint64_t)(szDataLen+1));
return;
}
memcpy(pNewItem->sData, sData, szDataLen);
pNewItem->sData[szDataLen] = '\0';
} else {
pNewItem->sData = NULL;
}
pNewItem->szDataLen = szDataLen;
pNewItem->pFromUser = pFromUser;
pNewItem->ui8Type = ui8Type;
pNewItem->pPrev = NULL;
pNewItem->pNext = NULL;
pNewItem->i32Profile = i32Profile;
if(pNewSingleItems[0] == NULL) {
pNewSingleItems[0] = pNewItem;
pNewSingleItems[1] = pNewItem;
} else {
pNewItem->pPrev = pNewSingleItems[1];
pNewSingleItems[1]->pNext = pNewItem;
pNewSingleItems[1] = pNewItem;
}
}
void classUsers::Add2RecTimes(User * curUser) {
time_t acc_time;
time(&acc_time);
if(ProfileMan->IsAllowed(curUser, ProfileManager::NOUSRSAMEIP) == true ||
(acc_time-curUser->LoginTime) >= SettingManager->iShorts[SETSHORT_MIN_RECONN_TIME]) {
return;
}
RecTime * pNewRecTime = new RecTime();
if(pNewRecTime == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pNewRecTime in classUsers::Add2RecTimes\n", 0);
return;
}
#ifdef _WIN32
pNewRecTime->sNick = (char *)HeapAlloc(hPtokaXHeap, HEAP_NO_SERIALIZE, curUser->ui8NickLen+1);
#else
pNewRecTime->sNick = (char *)malloc(curUser->ui8NickLen+1);
#endif
if(pNewRecTime->sNick == NULL) {
delete pNewRecTime;
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes in classUsers::Add2RecTimes\n", (uint64_t)(curUser->ui8NickLen+1));
return;
}
memcpy(pNewRecTime->sNick, curUser->sNick, curUser->ui8NickLen);
pNewRecTime->sNick[curUser->ui8NickLen] = '\0';
pNewRecTime->ui64DisConnTick = ui64ActualTick-(acc_time-curUser->LoginTime);
pNewRecTime->ui32NickHash = curUser->ui32NickHash;
memcpy(pNewRecTime->ui128IpHash, curUser->ui128IpHash, 16);
pNewRecTime->prev = NULL;
pNewRecTime->next = RecTimeList;
if(RecTimeList != NULL) {
RecTimeList->prev = pNewRecTime;
}
RecTimeList = pNewRecTime;
}
bool UdpDebug::New(User * pUser, const uint16_t ui16Port) {
UdpDbgItem * pNewDbg = new (std::nothrow) UdpDbgItem();
if(pNewDbg == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pNewDbg in UdpDebug::New\n");
return false;
}
// initialize dbg item
#ifdef _WIN32
pNewDbg->m_sNick = (char *)HeapAlloc(ServerManager::m_hPtokaXHeap, HEAP_NO_SERIALIZE, pUser->m_ui8NickLen+1);
#else
pNewDbg->m_sNick = (char *)malloc(pUser->m_ui8NickLen+1);
#endif
if(pNewDbg->m_sNick == NULL) {
AppendDebugLogFormat("[MEM] Cannot allocate %" PRIu8 " bytes for sNick in UdpDebug::New\n", pUser->m_ui8NickLen+1);
delete pNewDbg;
return false;
}
memcpy(pNewDbg->m_sNick, pUser->m_sNick, pUser->m_ui8NickLen);
pNewDbg->m_sNick[pUser->m_ui8NickLen] = '\0';
pNewDbg->m_ui32Hash = pUser->m_ui32NickHash;
struct in6_addr i6addr;
memcpy(&i6addr, &pUser->m_ui128IpHash, 16);
bool bIPv6 = (IN6_IS_ADDR_V4MAPPED(&i6addr) == 0);
if(bIPv6 == true) {
((struct sockaddr_in6 *)&pNewDbg->m_sasTo)->sin6_family = AF_INET6;
((struct sockaddr_in6 *)&pNewDbg->m_sasTo)->sin6_port = htons(ui16Port);
memcpy(((struct sockaddr_in6 *)&pNewDbg->m_sasTo)->sin6_addr.s6_addr, pUser->m_ui128IpHash, 16);
pNewDbg->m_sasLen = sizeof(struct sockaddr_in6);
} else {
((struct sockaddr_in *)&pNewDbg->m_sasTo)->sin_family = AF_INET;
((struct sockaddr_in *)&pNewDbg->m_sasTo)->sin_port = htons(ui16Port);
((struct sockaddr_in *)&pNewDbg->m_sasTo)->sin_addr.s_addr = inet_addr(pUser->m_sIP);
pNewDbg->m_sasLen = sizeof(struct sockaddr_in);
}
pNewDbg->m_Socket = socket((bIPv6 == true ? AF_INET6 : AF_INET), SOCK_DGRAM, IPPROTO_UDP);
#ifdef _WIN32
if(pNewDbg->m_Socket == INVALID_SOCKET) {
int iErr = WSAGetLastError();
#else
if(pNewDbg->m_Socket == -1) {
#endif
pUser->SendFormat("UdpDebug::New1", true, "*** [ERR] %s: %s (%d).|", LanguageManager::m_Ptr->m_sTexts[LAN_UDP_SCK_CREATE_ERR],
#ifdef _WIN32
WSErrorStr(iErr), iErr);
#else
ErrnoStr(errno), errno);
#endif
delete pNewDbg;
return false;
}
PXBReader::~PXBReader() {
#ifdef _WIN32
if(pItemDatas != NULL) {
if(HeapFree(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE, pItemDatas) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate pItemDatas in PXBReader::~PXBReader\n");
}
}
#else
free(pItemDatas);
#endif
#ifdef _WIN32
if(ui16ItemLengths != NULL) {
if(HeapFree(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)ui16ItemLengths) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate ui16ItemLengths in PXBReader::~PXBReader\n");
}
}
#else
free(ui16ItemLengths);
#endif
#ifdef _WIN32
if(sItemIdentifiers != NULL) {
if(HeapFree(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)sItemIdentifiers) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate sItemIdentifiers in PXBReader::~PXBReader\n");
}
}
#else
free(sItemIdentifiers);
#endif
#ifdef _WIN32
if(ui8ItemValues != NULL) {
if(HeapFree(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)ui8ItemValues) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate ui8ItemValues in PXBReader::~PXBReader\n");
}
}
#else
free(ui8ItemValues);
#endif
if(pFile != NULL) {
fclose(pFile);
}
}
ReservedNicksManager::ReservedNick::~ReservedNick() {
#ifdef _WIN32
if(m_sNick != NULL && HeapFree(ServerManager::m_hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)m_sNick) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate m_sNick in ReservedNicksManager::ReservedNick::~ReservedNick\n");
}
#else
free(m_sNick);
#endif
}
ResNickMan::ReservedNick::~ReservedNick() {
#ifdef _WIN32
if(sNick != NULL && HeapFree(hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)sNick) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate sNick in ResNickMan::ReservedNick::~ReservedNick\n", 0);
}
#else
free(sNick);
#endif
}
bool PXBReader::PrepareArrays(const uint8_t &ui8Size) {
#ifdef _WIN32
pItemDatas = (void **)HeapAlloc(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, ui8Size*sizeof(void *));
#else
pItemDatas = (void **)calloc(ui8Size, sizeof(void *));
#endif
if(pItemDatas == NULL) {
AppendDebugLog("%s - [MEM] Cannot create pItemDatas in PXBReader::PrepareArrays\n");
return false;
}
#ifdef _WIN32
ui16ItemLengths = (uint16_t *)HeapAlloc(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, ui8Size*sizeof(uint16_t));
#else
ui16ItemLengths = (uint16_t *)calloc(ui8Size, sizeof(uint16_t));
#endif
if(ui16ItemLengths == NULL) {
AppendDebugLog("%s - [MEM] Cannot create ui16ItemLengths in PXBReader::PrepareArrays\n");
return false;
}
#ifdef _WIN32
sItemIdentifiers = (char *)HeapAlloc(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, ui8Size*(sizeof(char)*2));
#else
sItemIdentifiers = (char *)calloc(ui8Size, sizeof(char)*2);
#endif
if(sItemIdentifiers == NULL) {
AppendDebugLog("%s - [MEM] Cannot create sItemIdentifiers in PXBReader::PrepareArrays\n");
return false;
}
#ifdef _WIN32
ui8ItemValues = (uint8_t *)HeapAlloc(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, ui8Size*sizeof(ui8ItemValues));
#else
ui8ItemValues = (uint8_t *)calloc(ui8Size, sizeof(ui8ItemValues));
#endif
if(ui8ItemValues == NULL) {
AppendDebugLog("%s - [MEM] Cannot create ui8ItemValues in PXBReader::PrepareArrays\n");
return false;
}
ui8AllocatedSize = ui8Size;
return true;
}
clsZlibUtility::~clsZlibUtility() {
#ifdef _WIN32
if(pZbuffer != NULL) {
if(HeapFree(clsServerManager::hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)pZbuffer) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate pZbuffer in clsZlibUtility::~clsZlibUtility\n");
}
}
#else
free(pZbuffer);
#endif
}
clsTextFilesManager::TextFile::~TextFile() {
#ifdef _WIN32
if(sCommand != NULL) {
if(HeapFree(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)sCommand) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate sCommand in clsTextFilesManager::TextFile::~TextFile\n", 0);
}
}
#else
free(sCommand);
#endif
#ifdef _WIN32
if(sText != NULL) {
if(HeapFree(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)sText) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate sText in clsTextFilesManager::TextFile::~TextFile\n", 0);
}
}
#else
free(sText);
#endif
}
void * clsGlobalDataQueue::InsertBlankQueueItem(void * pAfterItem, const uint8_t &ui8CmdType) {
QueueItem * pNewItem = new QueueItem();
if(pNewItem == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pNewItem in clsGlobalDataQueue::InsertBlankQueueItem\n", 0);
return NULL;
}
pNewItem->sCommand1 = NULL;
pNewItem->szLen1 = 0;
pNewItem->sCommand2 = NULL;
pNewItem->szLen2 = 0;
pNewItem->ui8CommandType = ui8CmdType;
if(pAfterItem == pNewQueueItems[0]) {
pNewItem->pNext = pNewQueueItems[0];
pNewQueueItems[0] = pNewItem;
return pNewItem;
}
QueueItem * pNext = pNewQueueItems[0];
while(pNext != NULL) {
QueueItem * pCur = pNext;
pNext = pCur->pNext;
if(pCur == pAfterItem) {
if(pCur->pNext == NULL) {
pNewQueueItems[1] = pNewItem;
}
pNewItem->pNext = pCur->pNext;
pCur->pNext = pNewItem;
return pNewItem;
}
}
pNewItem->pNext = NULL;
if(pNewQueueItems[0] == NULL) {
pNewQueueItems[0] = pNewItem;
pNewQueueItems[1] = pNewItem;
} else {
pNewQueueItems[1]->pNext = pNewItem;
pNewQueueItems[1] = pNewItem;
}
return pNewItem;
}
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;
}
UDPThread * UDPThread::Create(const int &iAddressFamily) {
UDPThread * pUDPThread = new (std::nothrow) UDPThread();
if(pUDPThread == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate pUDPThread in UDPThread::Create\n");
return NULL;
}
if(pUDPThread->Listen(iAddressFamily) == true) {
pUDPThread->Resume();
return pUDPThread;
} else {
delete pUDPThread;
return NULL;
}
}
UdpDebug::UdpDbgItem::~UdpDbgItem() {
#ifdef _WIN32
if(m_sNick != NULL) {
if(HeapFree(ServerManager::m_hPtokaXHeap, HEAP_NO_SERIALIZE, (void *)m_sNick) == 0) {
AppendDebugLog("%s - [MEM] Cannot deallocate m_sNick in UdpDebug::UdpDbgItem::~UdpDbgItem\n");
}
}
#else
free(m_sNick);
#endif
#ifdef _WIN32
closesocket(m_Socket);
#else
close(m_Socket);
#endif
}
void clsGlobalDataQueue::FillBlankQueueItem(char * sCommand, const size_t &szLen, void * pQueueItem) {
#ifdef _WIN32
((QueueItem *)pQueueItem)->sCommand1 = (char *)HeapAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, szLen+1);
#else
((QueueItem *)pQueueItem)->sCommand1 = (char *)malloc(szLen+1);
#endif
if(((QueueItem *)pQueueItem)->sCommand1 == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for pNewItem->sCommand1 in clsGlobalDataQueue::FillBlankQueueItem\n", (uint64_t)(szLen+1));
return;
}
memcpy(((QueueItem *)pQueueItem)->sCommand1, sCommand, szLen);
((QueueItem *)pQueueItem)->sCommand1[szLen] = '\0';
((QueueItem *)pQueueItem)->szLen1 = szLen;
}
void string::stralloc(const char * sTxt, const size_t &szLen) {
szDataLen = szLen;
if(szDataLen == 0) {
sData = (char *)sEmpty;
return;
}
sData = (char *)malloc(szDataLen+1);
if(sData == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate %" PRIu64 " bytes for sData in string::stralloc\n", (uint64_t)(szDataLen+1));
return;
}
memcpy(sData, sTxt, szDataLen);
sData[szDataLen] = '\0';
}
void UdpDebug::CreateBuffer() {
if(m_sDebugBuffer != NULL) {
return;
}
#ifdef _WIN32
m_sDebugBuffer = (char *)HeapAlloc(ServerManager::m_hPtokaXHeap, HEAP_NO_SERIALIZE, 4+256+65535);
#else
m_sDebugBuffer = (char *)malloc(4+256+65535);
#endif
if(m_sDebugBuffer == NULL) {
AppendDebugLog("%s - [MEM] Cannot allocate 4+256+65535 bytes for m_sDebugBuffer in UdpDebug::CreateBuffer\n");
exit(EXIT_FAILURE);
}
UpdateHubName();
}
void theLoop::AcceptSocket(const SOCKET &s, const sockaddr_storage &addr) {
#else
void theLoop::AcceptSocket(const int &s, const sockaddr_storage &addr) {
#endif
AcceptedSocket * pNewSocket = new AcceptedSocket();
if(pNewSocket == NULL) {
#ifdef _WIN32
shutdown(s, SD_SEND);
closesocket(s);
#else
shutdown(s, SHUT_RDWR);
close(s);
#endif
AppendDebugLog("%s - [MEM] Cannot allocate pNewSocket in theLoop::AcceptSocket\n", 0);
return;
}
pNewSocket->s = s;
memcpy(&pNewSocket->addr, &addr, sizeof(sockaddr_storage));
pNewSocket->next = NULL;
#ifdef _WIN32
EnterCriticalSection(&csAcceptQueue);
#else
pthread_mutex_lock(&mtxAcceptQueue);
#endif
if(AcceptedSocketsS == NULL) {
AcceptedSocketsS = pNewSocket;
AcceptedSocketsE = pNewSocket;
} else {
AcceptedSocketsE->next = pNewSocket;
AcceptedSocketsE = pNewSocket;
}
#ifdef _WIN32
LeaveCriticalSection(&csAcceptQueue);
#else
pthread_mutex_unlock(&mtxAcceptQueue);
#endif
}
