bool UDPThread::Listen(const int &iAddressFamily) {
sock = socket(iAddressFamily, SOCK_DGRAM, IPPROTO_UDP);
#ifdef _WIN32
if(sock == INVALID_SOCKET) {
#else
if(sock == -1) {
#endif
AppendLog("[ERR] UDP Socket creation error.");
return false;
}
#ifndef _WIN32
int on = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
#endif
sockaddr_storage sas;
memset(&sas, 0, sizeof(sockaddr_storage));
socklen_t sas_len;
if(iAddressFamily == AF_INET6) {
((struct sockaddr_in6 *)&sas)->sin6_family = AF_INET6;
((struct sockaddr_in6 *)&sas)->sin6_port = htons((unsigned short)atoi(clsSettingManager::mPtr->sTexts[SETTXT_UDP_PORT]));
sas_len = sizeof(struct sockaddr_in6);
if(clsSettingManager::mPtr->bBools[SETBOOL_BIND_ONLY_SINGLE_IP] == true && clsServerManager::sHubIP6[0] != '\0') {
#if defined(_WIN32) && !defined(_WIN64) && !defined(_WIN_IOT)
win_inet_pton(clsServerManager::sHubIP6, &((struct sockaddr_in6 *)&sas)->sin6_addr);
#else
inet_pton(AF_INET6, clsServerManager::sHubIP6, &((struct sockaddr_in6 *)&sas)->sin6_addr);
#endif
} else {
((struct sockaddr_in6 *)&sas)->sin6_addr = in6addr_any;
if(iAddressFamily == AF_INET6 && clsServerManager::bIPv6DualStack == true) {
#ifdef _WIN32
DWORD dwIPv6 = 0;
setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&dwIPv6, sizeof(dwIPv6));
#else
int iIPv6 = 0;
setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &iIPv6, sizeof(iIPv6));
#endif
}
}
} else {
((struct sockaddr_in *)&sas)->sin_family = AF_INET;
((struct sockaddr_in *)&sas)->sin_port = htons((unsigned short)atoi(clsSettingManager::mPtr->sTexts[SETTXT_UDP_PORT]));
sas_len = sizeof(struct sockaddr_in);
if(clsSettingManager::mPtr->bBools[SETBOOL_BIND_ONLY_SINGLE_IP] == true && clsServerManager::sHubIP[0] != '\0') {
((struct sockaddr_in *)&sas)->sin_addr.s_addr = inet_addr(clsServerManager::sHubIP);
} else {
((struct sockaddr_in *)&sas)->sin_addr.s_addr = INADDR_ANY;
}
}
#ifdef _WIN32
if(bind(sock, (struct sockaddr *)&sas, sas_len) == SOCKET_ERROR) {
AppendLog("[ERR] UDP Socket bind error: "+string(WSAGetLastError()));
#else
if(bind(sock, (struct sockaddr *)&sas, sas_len) == -1) {
AppendLog("[ERR] UDP Socket bind error: "+string(ErrnoStr(errno))+" ("+string(errno)+")");
#endif
return false;
}
return true;
}
//---------------------------------------------------------------------------
UDPThread::~UDPThread() {
#ifdef _WIN32
if(sock != INVALID_SOCKET) {
closesocket(sock);
sock = INVALID_SOCKET;
}
if(hThreadHandle != INVALID_HANDLE_VALUE) {
CloseHandle(hThreadHandle);
#else
if(threadId != 0) {
Close();
WaitFor();
#endif
}
}
//---------------------------------------------------------------------------
#ifdef _WIN32
unsigned __stdcall ExecuteUDP(void* UDPThrd) {
#else
static void* ExecuteUDP(void* UDPThrd) {
#endif
((UDPThread *)UDPThrd)->Run();
return 0;
}
//---------------------------------------------------------------------------
void UDPThread::Resume() {
#ifdef _WIN32
hThreadHandle = (HANDLE)_beginthreadex(NULL, 0, ExecuteUDP, this, 0, &threadId);
if(hThreadHandle == 0) {
#else
int iRet = pthread_create(&threadId, NULL, ExecuteUDP, this);
if(iRet != 0) {
#endif
AppendDebugLog("%s - [ERR] Failed to create new UDPThread\n");
}
}
//---------------------------------------------------------------------------
void UDPThread::Run() {
sockaddr_storage sas;
socklen_t sas_len = sizeof(sockaddr_storage);
int len = 0;
while(bTerminated == false) {
len = recvfrom(sock, rcvbuf, 4095, 0, (struct sockaddr *)&sas, &sas_len);
if(len < 5 || strncmp(rcvbuf, "$SR ", 4) != 0) {
continue;
}
rcvbuf[len] = '\0';
// added ip check, we don't want fake $SR causing kick of innocent user...
clsEventQueue::mPtr->AddThread(clsEventQueue::EVENT_UDP_SR, rcvbuf, &sas);
}
}
//---------------------------------------------------------------------------
void UDPThread::Close() {
bTerminated = true;
#ifdef _WIN32
closesocket(sock);
#else
shutdown(sock, SHUT_RDWR);
close(sock);
#endif
}
//---------------------------------------------------------------------------
void UDPThread::WaitFor() {
#ifdef _WIN32
WaitForSingleObject(hThreadHandle, INFINITE);
#else
if(threadId != 0) {
pthread_join(threadId, NULL);
threadId = 0;
}
#endif
}
FILE *SearchFile( const char *path, bool queue )
/**********************************************/
{
FILE *file = NULL;
struct src_item *fl;
const char *fn;
bool isabs;
char fullpath[FILENAME_MAX];
DebugMsg1(("SearchFile(%s) enter\n", path ));
//_splitpath( path, drive, dir, fname, ext );
//DebugMsg1(("SearchFile(): drive=%s, dir=%s, fname=%s, ext=%s\n", drive, dir, fname, ext ));
fn = GetFNamePart( path );
/* if no absolute path is given, then search in the directory
* of the current source file first!
* v2.11: various changes because field fullpath has been removed.
*/
isabs = ISABS( path );
//if ( dir[0] != '\\' && dir[0] != '/' ) {
if ( !isabs ) {
for ( fl = src_stack; fl ; fl = fl->next ) {
if ( fl->type == SIT_FILE ) {
const char *fn2;
char *src;
//_splitpath( GetFName( fl->srcfile )->fname, drive2, dir2, NULL, NULL );
//DebugMsg1(("SearchFile(): curr src=%s, split into drive=%s, dir=%s\n", GetFName( fl->srcfile)->fname, drive2, dir2 ));
src = GetFName( fl->srcfile )->fname;
fn2 = GetFNamePart( src );
if ( fn2 != src ) {
int i = fn2 - src;
/* v2.10: if there's a directory part, add it to the directory part of the current file.
* fixme: check that both parts won't exceed FILENAME_MAX!
* fixme: 'path' is relative, but it may contain a drive letter!
*/
memcpy( fullpath, src, i );
strcpy( fullpath + i, path );
if ( (file = fopen( fullpath, "rb" )) != NULL ) {
DebugMsg1(("SearchFile(): file found, fopen(%s)=%X\n", fullpath, file ));
path = fullpath;
}
#ifdef DEBUG_OUT
else
DebugMsg1(("SearchFile(): fopen(%s) failed\n", fullpath ));
#endif
}
break;
}
}
}
if ( file == NULL ) {
fullpath[0] = NULLC;
file = fopen( path, "rb" );
DebugMsg1(("SearchFile(): fopen(%s)=%X\n", path, file ));
/* if the file isn't found yet and include paths have been set,
* and NO absolute path is given, then search include dirs
*/
if( file == NULL && ModuleInfo.g.IncludePath != NULL && !isabs ) {
if ( (file = open_file_in_include_path( path, fullpath )) != NULL ) {
DebugMsg1(("SearchFile(): open_file_in_include_path(%s)=%X [%s]\n", path, file, fullpath ));
path = fullpath;
}
#ifdef DEBUG_OUT
else
DebugMsg1(("SearchFile(): open_file_in_include_path(%s)=NULL\n", path ));
#endif
}
if( file == NULL ) {
EmitErr( CANNOT_OPEN_FILE, path, ErrnoStr() );
return( NULL );
}
}
/* is the file to be added to the file stack?
* assembly files usually are, but binary files ( INCBIN ) aren't.
*/
if ( queue ) {
fl = PushSrcItem( SIT_FILE, file );
fl->srcfile = AddFile( path );
FileCur->string_ptr = GetFName( fl->srcfile )->fname;
#if FILESEQ
if ( Options.line_numbers && Parse_Pass == PASS_1 )
AddFileSeq( fl->srcfile );
#endif
}
return( file );
}
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
}
int main( int argc, char **argv )
/*******************************/
{
char *pEnv;
int numArgs = 0;
int numFiles = 0;
int rc = 0;
#if WILDCARDS
long fh; /* _findfirst/next/close() handle, must be long! */
struct _finddata_t finfo;
char drv[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_PATH];
#endif
#if 0 //def DEBUG_OUT /* DebugMsg() cannot be used that early */
int i;
for ( i = 1; i < argc; i++ ) {
printf("argv[%u]=>%s<\n", i, argv[i] );
}
#endif
pEnv = getenv( "JWASM" );
if ( pEnv == NULL )
pEnv = "";
argv[0] = pEnv;
#ifndef DEBUG_OUT
signal(SIGSEGV, genfailure);
#endif
#if CATCHBREAK
signal(SIGBREAK, genfailure);
#else
signal(SIGTERM, genfailure);
#endif
MsgInit();
while ( 1 ) {
if ( ParseCmdline( (const char **)argv, &numArgs ) == NULL )
break; /* exit if no source file name supplied */
numFiles++;
write_logo();
#if WILDCARDS
if ((fh = _findfirst( Options.names[ASM], &finfo )) == -1 ) {
DebugMsg(("main: _findfirst(%s) failed\n", Options.names[ASM] ));
EmitErr( CANNOT_OPEN_FILE, Options.names[ASM], ErrnoStr() );
break;
}
_splitpath( Options.names[ASM], drv, dir, NULL, NULL );
DebugMsg(("main: _splitpath(%s): drv=\"%s\" dir=\"%s\"\n", Options.names[ASM], drv, dir ));
do {
_makepath( fname, drv, dir, finfo.name, NULL );
DebugMsg(("main: _makepath(\"%s\", \"%s\", \"%s\")=\"%s\"\n", drv, dir, finfo.name, fname ));
rc = AssembleModule( fname ); /* assemble 1 module */
} while ( ( _findnext( fh, &finfo ) != -1 ) );
_findclose( fh );
#else
rc = AssembleModule( Options.names[ASM] );
#endif
};
CmdlineFini();
if ( numArgs == 0 ) {
write_logo();
printf( MsgGetEx( MSG_USAGE ) );
} else if ( numFiles == 0 )
EmitError( NO_FILENAME_SPECIFIED );
MsgFini();
return( 1 - rc ); /* zero if no errors */
}