qboolean Sys_CreateNewThread(void* (*ThreadMain)(void*), threadid_t *tid, void* arg)
{
char errMessageBuf[512];
DWORD lastError;
HANDLE thid = CreateThread( NULL, // LPSECURITY_ATTRIBUTES lpsa,
0, // DWORD cbStack,
(LPTHREAD_START_ROUTINE)ThreadMain, // LPTHREAD_START_ROUTINE lpStartAddr,
arg, // LPVOID lpvThreadParm,
0, // DWORD fdwCreate,
tid );
if(thid == NULL)
{
lastError = GetLastError();
if(lastError != 0)
{
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, lastError, MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), (LPSTR)errMessageBuf, sizeof(errMessageBuf) -1, NULL);
Com_PrintError("Failed to start thread with error: %s\n", errMessageBuf);
}else{
Com_PrintError("Failed to start thread!\n");
}
return qfalse;
}
return qtrue;
}
P_P_F qboolean Plugin_TcpSendData(int connection, void* data, int len)
{
int pID;
//Identify the calling plugin
pID = PHandler_CallerID();
if(pID<0){
Com_Printf("Plugin_TcpSendData: Error! Tried get TCP data for unknown plugin!\n");
return qfalse;
}
if(pluginFunctions.plugins[pID].enabled==qfalse){
Com_Printf("^1WARNING^7: Plugin_TcpSendData: Tried get TCP data for a disabled plugin!\n");
return qfalse;
}
if(connection >= PLUGIN_MAX_SOCKETS || connection < 0){
Com_PrintError("Plugin_TcpSendData: Second argument can only be a value inside the range: 0...%d plugin ID: #%d\n", PLUGIN_MAX_SOCKETS, pID);
return qfalse;
}
if(data == NULL){
Com_PrintError("Plugin_TcpSendData: Second argument can not be a NULL-Pointer for plugin ID: #%d\n", pID);
return qfalse;
}
return PHandler_TcpSendData(pID, connection, data, len);
}
void PHandler_ScrAddMethod(char *name, xfunction_t function, qboolean replace, int pID)
{
int i;
if(pID>=MAX_PLUGINS){
Com_Printf("Error: tried adding a script command for a plugin with non existent pID. pID supplied: %d.\n",pID);
return;
}else if(pID<0){
Com_Printf("Plugin Handler error: Plugin_ScrAddMethod or Plugin_ScrReplaceMethod called from not within a plugin or from a disabled plugin!\n");
return;
}
if(!pluginFunctions.plugins[pID].loaded){
Com_Printf("Error: Tried adding a command for not loaded plugin! PID: %d.\n",pID);
}
Com_Printf("Adding a plugin script method for plugin %d, command name: %s.\n",pID, name);
for(i = 0; i < MAX_SCRIPTFUNCTIONS; i++ )
{
if(pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].name[0] == 0)
{
break;
}
}
if(i == MAX_SCRIPTFUNCTIONS)
{
Com_PrintError("Exceeded maximum number of scrip-functions (%d) for plugin\n", MAX_SCRIPTFUNCTIONS);
return;
}
if(strlen(name) >= sizeof(pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].name))
{
Com_PrintError("Exceeded maximum length of name for scrip-method: %s (%d) for plugin.\n", name, sizeof(pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].name) );
return;
}
if(replace == qtrue)
{
Scr_RemoveMethod(name);
}
if(Scr_AddMethod(name, (xfunction_t)&pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].dyncallstub, qfalse) == qfalse)
{
Com_PrintError("Failed to add this script method: %s for plugin\n", name);
return;
}
Sys_MemoryProtectWrite(pluginScriptCallStubs.s, sizeof(pluginScriptCallStubs.s));
Q_strncpyz(pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].name, name, sizeof(pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].name));
pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].isMethod = qtrue;
PHandler_InitDynCallStub(&pluginScriptCallStubs.s[pID * MAX_SCRIPTFUNCTIONS + i].dyncallstub, function, pID);
Sys_MemoryProtectExec(pluginScriptCallStubs.s, sizeof(pluginScriptCallStubs.s));
pluginFunctions.plugins[pID].scriptmethods++;
}
void dMessage (int num, const char *msg, ...)
{
va_list ap;
char buf[2048];
va_start (ap, msg);
Q_vsnprintf(buf, sizeof(buf), msg, ap);
va_end(ap);
if(num)
{
Com_PrintError("\nODE Message %d: %s\n", num, buf);
}else{
Com_PrintError("\nODE Message: %s\n", buf);
}
}
ftRequest_t* FileDownloadRequest( const char* url)
{
/* Strip away trailing spaces */
ftprotocols_t proto;
while(*url == ' ')
url++;
if(!Q_stricmpn("ftp://", url, 6)){
url += 6;
proto = FT_PROTO_FTP;
}else if(!Q_stricmpn("http://", url, 7)){
url += 7;
proto = FT_PROTO_HTTP;
}else {
proto = -1;
}
switch(proto)
{
case FT_PROTO_FTP:
return FTP_DLRequest(url);
case FT_PROTO_HTTP:
return HTTPGetRequest(url);
default:
Com_PrintError("Unsupported File Transfer Protocol in url: %s!\n", url);
return NULL;
}
return NULL;
}
void NET_TCPPacketEvent(netadr_t* from, byte* bufData, int len, int socketfd, int connectionId, int serviceId)
{
int i;
msg_t msg;
for(i = 0; i < MAX_TCPEVENTS; i++)
{
if(tcpevents[i].serviceId == serviceId)
{
msg.data = bufData;
msg.cursize = len;
msg.maxsize = len;
msg.readcount = 0;
msg.bit = 0;
msg.readonly = qtrue;
msg.overflowed = qfalse;
if(tcpevents[i].tcpevent(from, &msg, socketfd, connectionId))
{
NET_TcpCloseSocket(socketfd);
}
return;
}
}
Com_PrintError("NET_TCPPacketEvent: Bad serviceId: %d\n", serviceId);
NET_TcpCloseSocket(socketfd);
return; //Close connection
}
void HStorage_WriteDataToFile(varStorage_t* vobj, const char* filename){
fileHandle_t file;
char infostring[8192], buf[128];
int i;
char name[MAX_VARNAME];
char *string;
int count;
vsMemObj_t* obj;
vsValue_t value;
varType_t type;
mvabuf;
obj = vobj->memObj;
file = FS_SV_FOpenFileWrite(va("%s.tmp", filename));
if(!file){
Com_PrintError("HStorage_WriteDataToFile: Can not open %s for writing\n", filename);
return;
}
HStorage_IterInit( obj );
while(HStorage_IterHasNext( obj ))
{
count = HStorage_IterGetNextInfo( obj, name, &type );
if(count == 0)
{
continue;
}
*infostring = 0;
BigInfo_SetValueForKey(infostring, "name", name);
BigInfo_SetValueForKey(infostring, "type", HStorage_EnumToVarType(type));
BigInfo_SetValueForKey(infostring, "count", va("%d", count));
for(i = 0; i < count; i++)
{
if(HStorage_GetDataInternal(obj, &value) == 0)
{
break;
}
if(type == VSVAR_STRING)
{
string = HStorage_ValueToString(type, &value, buf, sizeof(buf));
BigInfo_SetEncodedValueForKey(infostring, va("v%d", i), string, strlen(string));
}else{
BigInfo_SetValueForKey(infostring, va("v%d", i), HStorage_ValueToString(type, &value, buf, sizeof(buf)));
}
}
Q_strcat(infostring, sizeof(infostring), "\\\n");
FS_Write(infostring, strlen(infostring), file);
}
FS_FCloseFile(file);
FS_SV_HomeCopyFile(va("%s.tmp", filename) , (char*)filename);
}
P_P_F qboolean Plugin_UdpSendData(netadr_t* to, void* data, int len)
{
int pID;
if(to == NULL){
pID = PHandler_CallerID();
Com_PrintError("Plugin_UdpSendData: First argument can not be a NULL-Pointer for plugin ID: #%d\n", pID);
return qfalse;
}
if(data == NULL){
pID = PHandler_CallerID();
Com_PrintError("Plugin_UdpSendData: First argument can not be a NULL-Pointer for plugin ID: #%d\n", pID);
return qfalse;
}
return Sys_SendPacket( len, data, to);
}
void Sys_SetExitCmdline(const char* cmdline)
{
if(strlen(cmdline) >= sizeof(exit_cmdline))
{
Com_PrintError("Sys_SetExitCmdline: Exceeded length of %d characters.\n", sizeof(exit_cmdline) -1);
}
Q_strncpyz(exit_cmdline, cmdline, sizeof(exit_cmdline));
}
//duration is in minutes
void SV_PlayerAddBanByip(netadr_t *remote, char *reason, int uid, char* guid, int adminuid, int expire){ //Gets called by future implemented ban-commands and if a prior ban got enforced again
ipBanList_t *list;
int i;
int oldest = 0;
unsigned int oldestTime = 0;
int duration;
if(!remote)
{
Com_PrintError("SV_PlayerAddBanByip: IP address is NULL\n");
return;
}
if(!ipbantime || ipbantime->integer == 0)
return;
for(list = &ipBans[0], i = 0; i < 1024; list++, i++){ //At first check whether we have already an entry for this player
if(NET_CompareBaseAdr(remote, &list->remote)){
break;
}
if (list->systime < oldestTime) {
oldestTime = list->systime;
oldest = i;
}
}
if(i == 1024){
list = &ipBans[oldest];
}
list->remote = *remote;
Q_strncpyz(list->banmsg, reason, 128);
if(guid && strlen(guid) == 32)
guid += 24;
if(guid && strlen(guid) == 8)
{
Q_strncpyz(list->guid, guid, sizeof(list->guid));
}
list->expire = expire;
list->uid = uid;
list->adminuid = adminuid;
duration = expire - Com_GetRealtime();
if(duration > ipbantime->integer*60 || expire == -1)
duration = ipbantime->integer*60; //Don't ban IPs for more than MAX_IPBAN_MINUTES minutes as they can be shared (Carrier-grade NAT)
list->systime = Sys_Milliseconds();
list->timeout = Com_GetRealtime() + duration;
}
void PHandler_ScrAddMethod(char *name, xfunction_t function, qboolean replace, int pID)
{
int i;
if(pID>=MAX_PLUGINS){
Com_Printf("Error: tried adding a script command for a plugin with non existent pID. pID supplied: %d.\n",pID);
return;
}else if(pID<0){
Com_Printf("Plugin Handler error: Plugin_ScrAddMethod or Plugin_ScrReplaceMethod called from not within a plugin or from a disabled plugin!\n");
return;
}
if(!pluginFunctions.plugins[pID].loaded){
Com_Printf("Error: Tried adding a command for not loaded plugin! PID: %d.\n",pID);
}
Com_Printf("Adding a plugin script method for plugin %d, method name: %s.\n",pID, name);
for(i = 0; i < (sizeof(pluginFunctions.plugins[0].scr_methods) / sizeof(pluginCmd_t)); i++ )
{
if(pluginFunctions.plugins[pID].scr_methods[i].xcommand == NULL)
{
break;
}
}
if(i == (sizeof(pluginFunctions.plugins[0].scr_methods) / sizeof(pluginCmd_t)))
{
Com_PrintError("Exceeded maximum number of scrip-methods (%d) for plugin\n", (sizeof(pluginFunctions.plugins[0].scr_methods) / sizeof(pluginCmd_t)));
return;
}
if(strlen(name) >= sizeof(pluginFunctions.plugins[0].scr_methods[0].name))
{
Com_PrintError("Exceeded maximum length of name for scrip-method: %s (%d) for plugin %s\n", name, sizeof(pluginFunctions.plugins[0].scr_methods[0].name) ,name);
return;
}
if(replace == qtrue)
{
Scr_RemoveMethod(name);
}
if(Scr_AddMethod(name, function, qfalse) == qfalse)
{
Com_PrintError("Failed to add this script function: %s for plugin\n", name);
return;
}
Q_strncpyz(pluginFunctions.plugins[pID].scr_methods[i].name, name, sizeof(pluginFunctions.plugins[0].scr_methods[0].name));
pluginFunctions.plugins[pID].scr_methods[i].xcommand = function;
pluginFunctions.plugins[pID].scriptmethods ++;
}
void PHandler_Unload(int id) // Unload a plugin, safe for use.
{
static qboolean unloading = qfalse;
void *lib_handle;
int i;
if(unloading){
Com_PrintError("PHandler_Unload: tried to unload plugin #%d from it's destructor!\n",id);
return;
}
if(pluginFunctions.plugins[id].loaded){
if(pluginFunctions.plugins[id].exports != 0){ // Library-plugins cannot be unloaded, see plugins/readme.txt
Com_PrintError("PHandler_Unload: Cannot unload a library plugin!\n");
return;
}
if(pluginFunctions.plugins[id].scriptfunctions != 0 || pluginFunctions.plugins[id].scriptmethods != 0){
// Script-library plugins cannot be unloaded, see plugins/readme.txt
Com_PrintError("PHandler_Unload: Cannot unload a script-library plugin!\n");
return;
}
unloading = qtrue; // Preventing endless recursion...
if(pluginFunctions.plugins[id].OnUnload != NULL){
pluginFunctions.hasControl = id;
(*pluginFunctions.plugins[id].OnUnload)();
pluginFunctions.hasControl = PLUGIN_UNKNOWN;
}
unloading = qfalse;
// Remove all server commands of the plugin
for(i=0;i<pluginFunctions.plugins[id].cmds;i++){
if(pluginFunctions.plugins[id].cmd[i].xcommand!=NULL){
Com_DPrintf("Removing command \"%s\"...\n",pluginFunctions.plugins[id].cmd[i].name);
Cmd_RemoveCommand(pluginFunctions.plugins[id].cmd[i].name);
}
}
lib_handle = pluginFunctions.plugins[id].lib_handle; // Save the lib handle
Com_Memset(&(pluginFunctions.plugins[id]), 0x00, sizeof(plugin_t)); // Wipe out all the data
Sys_CloseLibrary(lib_handle); // Close the dll as there are no more references to it
--pluginFunctions.loadedPlugins;
}else{
Com_Printf("Tried unloading a not loaded plugin!\nPlugin ID: %d.",id);
}
}
P_P_F void Plugin_Error(int code, char *string)
{
volatile int pID = PHandler_CallerID();
if(pID<0){
Com_PrintError("Plugin Error called from unknown plugin!\n");
return;
}
PHandler_Error(pID,code,string);
}
void* Sys_LoadLibrary(const char* dlfile)
{
void* handle = dlopen(dlfile, RTLD_LAZY);
currentLibHandle = handle;
if(handle == NULL)
{
Com_PrintError("Sys_LoadLibrary error: %s\n", dlerror());
}
return handle;
}
qboolean Sys_CreateNewThread(void* (*ThreadMain)(void*), threadid_t *tid, void* arg)
{
int err;
err = pthread_create(tid, NULL, ThreadMain, arg);
if(err != 0)
{
Com_PrintError("Thread creation failed with the following error: %s\n", strerror(errno));
return qfalse;
}
return qtrue;
}
const char* PHandler_OpenTempFile(char* name, char* fullfilepath, int fplen){ // Load a plugin, safe for use
void *buf;
int len;
int wlen;
char* file;
char tmpfile[MAX_QPATH];
char filepath[MAX_QPATH];
Com_sprintf(filepath, sizeof(filepath),"plugins/%s" DLL_EXT, name);
len = FS_ReadFile(filepath, &buf);
if(len < 100)
len = FS_SV_ReadFile( filepath, &buf );
if(len < 100)
{
Com_Printf("No such file found: %s. Can not load this plugin.\n", filepath);
return NULL;
}
if(PHandler_VerifyPlugin(buf, len) == qfalse)
{
Com_Printf("%s is not a plugin file or is corrupt or contains disallowed functions.\n", filepath);
FS_FreeFile(buf);
return NULL;
}
Com_sprintf(tmpfile, sizeof(tmpfile), "plugin.%s.tmp", name);
/* If there is already such a file remove it now */
file = FS_SV_GetFilepath( tmpfile, fullfilepath, fplen );
if(file)
{
FS_RemoveOSPath(file);
file = FS_SV_GetFilepath( tmpfile, fullfilepath, fplen );
if(file)
{
FS_RemoveOSPath(file);
}
}
wlen = FS_SV_HomeWriteFile( tmpfile, buf, len);
if(wlen != len)
{
Com_PrintError("fs_homepath is readonly. Can not load this plugin.\n");
FS_FreeFile(buf);
return NULL;
}
//Additional test if a file is there and creation of full filepath
FS_FreeFile(buf);
return FS_SV_GetFilepath( tmpfile, fullfilepath, fplen );
}
void SV_InitBanlist(){
Com_Memset(svse.ipBans,0,sizeof(svse.ipBans));
banlist = Cvar_RegisterString("banlistfile", "banlist.dat", CVAR_INIT, "Name of the file which holds the banlist");
current_banlist_size = BANLIST_DEFAULT_SIZE;
current_banindex = 0;
svse.banList = realloc(NULL, current_banlist_size);//Test for NULL ?
if(svse.banList){
SV_LoadBanlist();
}else{
Com_PrintError("Failed to allocate memory for the banlist. Banlist is disabled\n");
}
}
void SV_InitBanlist(){
Com_Memset(ipBans,0,sizeof(ipBans));
banlistfile = Cvar_RegisterString("banlist_filename", "banlist.dat", CVAR_INIT, "Name of the file which holds the banlist");
ipbantime = Cvar_RegisterInt("banlist_maxipbantime", MAX_DEFAULT_IPBAN_MINUTES, 0, 20160, 0, "Limit of minutes to keep a ban against an ip-address up");
current_banlist_size = BANLIST_DEFAULT_SIZE;
current_banindex = 0;
banlist = realloc(NULL, current_banlist_size);//Test for NULL ?
if(banlist){
SV_LoadBanlist();
}else{
Com_PrintError("Failed to allocate memory for the banlist. Banlist is disabled\n");
}
}
void Sys_ReplaceProcess( char *cmdline )
{
int i;
char *argv[256];
Cmd_TokenizeString(cmdline);
if(Cmd_Argc() < 256)
{
for(i = 0; i < Cmd_Argc(); i++)
{
argv[i] = CopyString(Cmd_Argv(i));
}
argv[i] = NULL;
execv( argv[0], argv );
Com_PrintError( "Sys_ReplaceProcess: execv failed: %s\n", strerror( errno ) );
}else{
Com_PrintError( "Sys_ReplaceProcess: Exceeded limit of 256 commandline arguments.\nCommandline is: %s\n", cmdline);
}
Cmd_EndTokenizedString();
_exit( 0 );
}
/*
============
Cbuf_InsertText
Adds command text immediately after the current command
Adds a \n to the text
============
*/
void Cbuf_InsertText( const char *text ) {
int len;
int i;
byte* new_buf;
len = strlen( text ) + 1;
Sys_EnterCriticalSection(CRIT_CBUF);
if ( len + cmd_text.cursize > cmd_text.maxsize ) {
if(cmd_text.data == cmd_text_buf)
{
new_buf = realloc(NULL, len + cmd_text.cursize);
if(new_buf != NULL)
{
Com_Memcpy(new_buf, cmd_text_buf, len + cmd_text.cursize);
}
}else{
new_buf = realloc(cmd_text.data, len + cmd_text.cursize);
}
if(new_buf == NULL)
{
Com_PrintError( "Cbuf_InsertText overflowed ; realloc failed\n" );
Sys_LeaveCriticalSection(CRIT_CBUF);
return;
}
cmd_text.data = new_buf;
cmd_text.maxsize = len + cmd_text.cursize;
}
// move the existing command text
for ( i = cmd_text.cursize - 1 ; i >= 0 ; i-- ) {
cmd_text.data[ i + len ] = cmd_text.data[ i ];
}
// copy the new text in
Com_Memcpy( cmd_text.data, text, len - 1 );
// add a \n
cmd_text.data[ len - 1 ] = '\n';
cmd_text.cursize += len;
Sys_LeaveCriticalSection(CRIT_CBUF);
}
P_P_F int Plugin_TcpGetData(int connection, void* buf, int size)
{
int pID;
//Identify the calling plugin
pID = PHandler_CallerID();
if(pID<0){
Com_Printf("Plugin_TcpGetData: Error! Tried get TCP data for unknown plugin!\n");
return -1;
}
if(pluginFunctions.plugins[pID].enabled==qfalse){
Com_Printf("^1WARNING^7: Plugin_TcpGetData: Tried get TCP data for a disabled plugin!\n");
return -1;
}
if(connection >= PLUGIN_MAX_SOCKETS || connection < 0){
Com_PrintError("Plugin_TcpGetData: First argument can only be a value inside the range: 0...%d plugin ID: #%d\n", PLUGIN_MAX_SOCKETS, pID);
return -1;
}
if(buf == NULL){
Com_PrintError("Plugin_TcpGetData: Third argument can not be a NULL-Pointer for plugin ID: #%d\n", pID);
return -1;
}
return PHandler_TcpGetData(pID, connection, buf, size);
}
P_P_F void Plugin_AddCommand(char *name, xcommand_t xcommand, int power)
{
volatile int pID;
pID = PHandler_CallerID();
if(pID>=MAX_PLUGINS){
Com_PrintError("Tried adding a command for a plugin with non existent pID. pID supplied: %d.\n",pID);
return;
}else if(pID<0){
Com_PrintError("Plugin_AddCommand called from not within a plugin or from a disabled plugin!\n");
return;
}
if(!pluginFunctions.plugins[pID].loaded){
Com_PrintError("Tried adding a command for not loaded plugin! PID: %d.\n",pID);
}
Com_DPrintf("Adding a plugin command for plugin %d, command name: %s.\n",pID,name);
Cmd_AddCommand(name,PHandler_CmdExecute_f);
Cmd_SetPower(name, power);
pluginFunctions.plugins[pID].cmd[pluginFunctions.plugins[pID].cmds].xcommand = xcommand;
strcpy(pluginFunctions.plugins[pID].cmd[pluginFunctions.plugins[pID].cmds++].name,name);
Com_DPrintf("Command added.\n");
// pluginFunctions.plugins[pID].
}
qboolean PHandler_TcpConnect(int pID, const char* remote, int connection)
{
if(pluginFunctions.plugins[pID].sockets[connection].sock < 1){
pluginFunctions.plugins[pID].sockets[connection].sock = NET_TcpClientConnect( remote );
if(pluginFunctions.plugins[pID].sockets[connection].sock < 1){
Com_Printf("Plugins: Notice! Error connecting to server: %s for plugin #%d!\n", remote, pID);
return qfalse;
}
NET_StringToAdr(remote, &pluginFunctions.plugins[pID].sockets[connection].remote, NA_UNSPEC);
return qtrue;
}
Com_PrintError("Plugin_TcpConnect: Connection id %d is already in use for plugin #%d!\n",connection ,pID );
return qfalse;
}
P_P_F void Plugin_SetPlayerUID(unsigned int clientslot, unsigned int uid)
{
client_t *cl;
int PID = PHandler_CallerID();
mvabuf;
#ifndef COD4X17A
Com_PrintError("Plugin_SetPlayerUID: This command is in CoD4X18+ deprecated. Nothing is set\n");
return;
#endif
if(clientslot > sv_maxclients->integer)
{
PHandler_Error(PID,P_ERROR_DISABLE, va("Plugin tried to set UID for bad client: %d\n", clientslot));
}
cl = &svs.clients[clientslot];
cl->uid = uid;
}
P_P_F void Plugin_Error(int code, const char *fmt, ...)
{
va_list argptr;
char msg[1024];
volatile int pID = PHandler_CallerID();
if(pID<0){
Com_PrintError("Plugin Error called from unknown plugin!\n");
return;
}
va_start (argptr,fmt);
Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
va_end (argptr);
PHandler_Error(pID,code,msg);
}
void SV_WriteBanlist(){
banList_t *this;
time_t aclock;
time(&aclock);
fileHandle_t file;
char infostring[1024];
int i;
file = FS_SV_FOpenFileWrite(va("%s.tmp", banlistfile->string));
if(!file){
Com_PrintError("SV_WriteBanlist: Can not open %s for writing\n",banlistfile->string);
return;
}
this = banlist;
if(!this)
return;
for(i = 0 ; i < current_banindex; this++, i++){
if(this->expire == (time_t)-1 || this->expire > aclock){
*infostring = 0;
if(this->playeruid > 0){
Info_SetValueForKey(infostring, "uid", va("%i", this->playeruid));
}else if(this->pbguid[7]){
Info_SetValueForKey(infostring, "guid", this->pbguid);
}else{
continue;
}
Info_SetValueForKey(infostring, "nick", this->playername);
Info_SetValueForKey(infostring, "rsn", this->reason);
Info_SetValueForKey(infostring, "exp", va("%i", this->expire));
Info_SetValueForKey(infostring, "auid", va("%i", this->adminuid));
Q_strcat(infostring, sizeof(infostring), "\\\n");
FS_Write(infostring,strlen(infostring),file);
}
}
FS_FCloseFile(file);
FS_SV_HomeCopyFile(va("%s.tmp", banlistfile->string) ,banlistfile->string);
// FS_SV_Rename(va("%s.tmp", banlist->string),banlist->string);
}
qboolean SV_OversizeBanlistAlign(){
banList_t *new_blist;
int newSize;
if(current_banlist_size <= (current_banindex + 1) * sizeof(banList_t)){//Memory extension
newSize = current_banlist_size + current_banlist_size / 4;
new_blist = realloc(banlist, newSize);
if(new_blist){
banlist = new_blist;
current_banlist_size = newSize;
}else{
Com_PrintError("Could not allocate enougth memory to extend the size of banlist. Failed to add new bans\n");
return qfalse;
}
}
return qtrue;
}
P_P_F void Plugin_TcpCloseConnection(int connection)
{
int pID;
//Identify the calling plugin
pID = PHandler_CallerID();
if(pID<0){
Com_Printf("Plugin_TcpCloseConnection: Error! Tried get close a connection for unknown plugin!\n");
return;
}
if(pluginFunctions.plugins[pID].enabled==qfalse){
Com_Printf("^1WARNING^7: Plugin_TcpCloseConnection: Tried to close a connection for a disabled plugin!\n");
return;
}
if(connection >= PLUGIN_MAX_SOCKETS || connection < 0){
Com_PrintError("Plugin_TcpCloseConnection: Second argument can only be a value inside the range: 0...%d plugin ID: #%d\n", PLUGIN_MAX_SOCKETS, pID);
return;
}
PHandler_TcpCloseConnection(pID, connection);
}
P_P_F qboolean Plugin_TcpConnect( int connection, const char* remote)
{
int pID;
//Identify the calling plugin
pID = PHandler_CallerID();
if(pID<0){
Com_Printf("Plugins: Error! Tried open a TCP-Connection for unknown plugin!\n");
return qfalse;
}
if(pluginFunctions.plugins[pID].enabled==qfalse){
Com_Printf("^1WARNING^7: Tried open a TCP-Connection for a disabled plugin!\n");
return qfalse;
}
if(connection >= PLUGIN_MAX_SOCKETS || connection < 0){
Com_PrintError("Plugin_TcpConnect: Second argument can only be a value inside the range: 0...%d plugin ID: #%d\n", PLUGIN_MAX_SOCKETS);
return qfalse;
}
return PHandler_TcpConnect(pID, remote, connection);
}
/*
============
Cmd_TokenizeString
============
*/
static void Cmd_TokenizeString2( const char *text_in, qboolean ignore_quotes ) {
cmdTokenizeParams_t param;
int oldargc;
int occupiedBuf;
oldargc = tokenStrings.cmd_argc;
if(tokenStrings.currentString < MAX_TOKENIZE_STRINGS)
{
param.cmd_argc = tokenStrings.cmd_argc;
param.cmd_argv = tokenStrings.cmd_argv;
if(tokenStrings.currentString > 0)
{
if(tokenStrings.cmd_argv[tokenStrings.cmd_argc] == NULL)
{
Com_Error(ERR_FATAL, "Cmd_TokenizeString( ): Free string is a NULL pointer...");
}
param.cmd_tokenized = tokenStrings.cmd_argv[tokenStrings.cmd_argc];
}else{
param.cmd_tokenized = tokenStrings.cmd_tokenized;
}
occupiedBuf = param.cmd_tokenized - tokenStrings.cmd_tokenized;
param.availableBuf = sizeof(tokenStrings.cmd_tokenized) - occupiedBuf;
Cmd_TokenizeStringInternal( text_in, ignore_quotes, ¶m );
tokenStrings.cmd_argcList[tokenStrings.currentString] = param.cmd_argc - oldargc;
tokenStrings.cmd_argc = param.cmd_argc;
}else{
Com_PrintError("Cmd_TokenizeString(): MAX_TOKENIZE_STRINGS exceeded\n");
}
tokenStrings.currentString++;
}