void SV_EndClientSnapshot(client_t *client, msg_t *msg)
{
if ( client->state != CS_ZOMBIE )
SV_WriteDownloadToClient(client, msg);
MSG_WriteByte(msg, svc_EOF);
if ( msg->overflowed == qtrue)
{
Com_PrintWarning( "WARNING: msg overflowed for %s, trying to recover\n", client->shortname);
if ( client->state == CS_ACTIVE || client->state == CS_ZOMBIE )
{
SV_ShowClientUnAckCommands(client);
MSG_Clear( msg );
MSG_WriteLong(msg, client->lastClientCommand);
SV_UpdateServerCommandsToClientRecover( client, msg );
MSG_WriteByte(msg, svc_EOF);
}
if ( msg->overflowed == qtrue)
{
Com_PrintWarning("WARNING: client disconnected for msg overflow: %s\n", client->shortname);
NET_OutOfBandPrint(NS_SERVER, &client->netchan.remoteAddress, "disconnect");
SV_DropClient(client, "EXE_SERVERMESSAGEOVERFLOW");
}
}
SV_SendMessageToClient(msg, client);
}
void G_AddRule(const char* newtext){
char* textbuf = messages.msgBuff;
int len;
int i;
int newstrlen = strlen(newtext);
if(newstrlen < 3)
return;
//Find an empty slot to reference this string
for(i = 0; i < MAX_MESSAGES; i++)
{
if(messages.ruleStrings[i] == NULL)
break;
}
if(i == MAX_MESSAGES){
Com_PrintWarning("Exceeded the limit of %i rules\n", MAX_MESSAGES);
return;
}
int j = 0;
while(j < MAX_MSGBUFF)
{
//Is our text already there
if(!Q_stricmp(newtext, textbuf))
{
return; //Already an added rule
}
len = strlen(textbuf);
if(!len) //No more added textstrings in buffer
break;
textbuf = &textbuf[len+1];
j += (len + 1);
}
if(newstrlen >= MAX_MSGBUFF - j){
Com_PrintWarning("Exceeded the maximum combined length of all advert and rules\n");
return;
}
//append the new text string to our buffer
Q_strncpyz(textbuf, newtext, newstrlen+1);
//Reference it now
messages.ruleStrings[i] = textbuf;
}
qboolean NV_ParseConfigLine(char* line, int linenumber){
if(!Q_stricmp(Info_ValueForKey(line, "type") , "cmdMinPower")){
if(!Cmd_InfoSetPower( line )){
Com_DPrintf("Warning at line: %d\n", linenumber);
return qtrue; //Don't rise errors here! This can happen for commands we add at a later stage
}
return qtrue;
}else if(!Q_stricmp(Info_ValueForKey(line, "type") , "rconAdmin")){
Com_PrintWarning("HL2 Rcon admin is unsupported. Please use the general admin system instead\n");
return qtrue;
}else if(!Q_stricmp(Info_ValueForKey(line, "type") , "authAdmin")){
if(!Auth_InfoAddAdmin( line ))
{
Com_Printf("Error at line: %d\n", linenumber);
return qfalse;
}
return qtrue;
}else{
Com_Printf("Error: unknown type (line: %d)\n", linenumber);
return qfalse;
}
}
P_P_F void PHandler_Error(int pID,int code,char *string)
{
if(pluginFunctions.plugins[pID].enabled==qfalse){
Com_PrintWarning("An error of ID %d and string \"%s\" occured in a disabled plugin with ID %d!\n",code,string,pID);
return;
}
switch(code)
{
case P_ERROR_WARNING:
Com_Printf("Plugin #%d ('%s') issued a warning: \"%s\"\n",pID,pluginFunctions.plugins[pID].name, string);
break;
case P_ERROR_DISABLE:
Com_Printf("Plugin #%d ('%s') returned an error and will be disabled! Error string: \"%s\".\n",pID,pluginFunctions.plugins[pID].name,string);
pluginFunctions.plugins[pID].enabled = qfalse;
break;
case P_ERROR_TERMINATE:
Com_Printf("Plugin #%d ('%s') reported a critical error, the server will be terminated. Error string: \"%s\".\n",pID,pluginFunctions.plugins[pID].name,string);
Com_Error(ERR_FATAL, "%s", string);
break;
default:
Com_DPrintf("Plugin #%d ('%s') reported an unknown error! Error string: \"%s\", error code: %d.\n",pID,pluginFunctions.plugins[pID].name,string,code);
break;
}
}
/*
============
Cmd_AddCommand
============
*/
qboolean Cmd_AddCommandGeneric( const char *cmd_name, const char* helptext, xcommand_t function, qboolean warn, int power ) {
cmd_function_t *cmd;
// fail if the command already exists
for ( cmd = cmd_functions ; cmd ; cmd = cmd->next ) {
if ( !strcmp( cmd_name, cmd->name )) {
// allow completion-only commands to be silently doubled
if ( function != NULL && warn) {
Com_PrintWarning( "Cmd_AddCommand: %s already defined\n", cmd_name );
}
return qfalse;
}
}
// use a small malloc to avoid zone fragmentation
if(helptext != NULL)
{
cmd = S_Malloc( sizeof( cmd_function_t ) + strlen(cmd_name) + 1 + strlen(helptext) + 1);
strcpy((char*)(cmd +1) + strlen(cmd_name) +1, helptext);
cmd->helptext = (char*)(cmd +1) + strlen(cmd_name) +1;
}else{
cmd = S_Malloc( sizeof( cmd_function_t ) + strlen(cmd_name) + 1);
}
strcpy((char*)(cmd +1), cmd_name);
cmd->name = (char*)(cmd +1);
cmd->function = function;
cmd->minPower = power;
cmd->next = cmd_functions;
cmd_functions = cmd;
return qtrue;
}
__cdecl int PbSvSendToClient(int msgsize, char* message, int clientnum){
client_t *cl;
cl = &svs.clients[clientnum];
if(cl->state >= CS_CONNECTED){
byte string[MAX_PACKETLEN];
int i;
// set the OutOfBand header
string[0] = 0xff;
string[1] = 0xff;
string[2] = 0xff;
string[3] = 0xff;
if(msgsize + 4 > MAX_PACKETLEN){
Com_PrintWarning("Buffer Overflow in NET_OutOfBandData %i bytes\n", msgsize);
return 0;
}
for ( i = 0; i < msgsize ; i++ ) {
string[i+4] = message[i];
}
NET_SendPacket( NS_SERVER, i+4, string, &cl->netchan.remoteAddress );
}
return 0;
}
void G_HudSetFont(game_hudelem_t* element ,float fontscale, fonttype_t fonttype){
if(fontscale > 4.6 || fontscale < 1.399999)
{
Com_PrintWarning("Fontscale: %f is out of range. Range is 1.4 to 4.6\n", fontscale);
fontscale = 1.4;
}
element->fontscale = fontscale;
element->fonttype = fonttype;
}
qboolean HStorage_LoadDataFromFile(varStorage_t* vobj, const char* filename)
{
char buf[8192];
buf[0] = 0;
fileHandle_t file;
int read;
int error;
int i;
vsMemObj_t* obj;
if(vobj->memObj == NULL)
{
obj = HStorage_NewObjectInternal( VSINITIAL_STORAGE_SIZE );
if(obj == NULL)
{
return qfalse;
}
vobj->memObj = obj;
}
FS_SV_FOpenFileRead(filename, &file);
if(!file){
Com_DPrintf("HStorage_LoadDataFromFile: Can not open %s for reading\n", filename);
return qfalse;
}
for(i = 0, error = 0 ;error < 32 ;i++){
read = FS_ReadLine(buf, sizeof(buf), file);
if(read == 0)
{
Com_Printf("%i lines parsed from %s, %i errors occured\n",i , filename, error);
FS_FCloseFile(file);
return qtrue;
}
if(read == -1)
{
Com_Printf("Can not read from %s\n", filename);
FS_FCloseFile(file);
return qfalse;
}
if(!*buf || *buf == '/' || *buf == '\n')
{
continue;
}
if(!HStorage_ParseLine(vobj, buf, i+1)) error++; //Executes the function given as argument in execute
}
Com_PrintWarning("More than 32 errors occured by reading from %s\n", filename);
FS_FCloseFile(file);
return qfalse;
}
void PHandler_TcpCloseConnection(int pID, int connection)
{
pluginTcpClientSocket_t* ptcs = &pluginFunctions.plugins[pID].sockets[connection];
if(ptcs->sock < 1){
Com_PrintWarning("Plugin_TcpCloseConnection: Called on a non open socket for plugin ID: #%d\n", pID);
return;
}
NET_TcpCloseSocket(ptcs->sock);
ptcs->sock = -1;
}
void Sys_InitCrashDumps(){
// core dumps may be disallowed by parent of this process; change that
struct rlimit core_limit;
core_limit.rlim_cur = RLIM_INFINITY;
core_limit.rlim_max = RLIM_INFINITY;
if (setrlimit(RLIMIT_CORE, &core_limit) < 0)
Com_PrintWarning("setrlimit: %s\nCore dumps may be truncated or non-existant\n", strerror(errno));
}
void G_HudSetFadingOverTime(game_hudelem_t* element ,int time, ucolor_t newcolor){
if(time > 60000 || time < 0)
{
Com_PrintWarning("G_HudSetFadeingOverTime: time: %i is out of range. Range is 0 to 60000\n", time);
time = 0;
}
element->fadestarttime = level.time;
element->fadecolor = element->color;
element->fadetime = time;
element->color = newcolor;
}
int PHandler_TcpGetData(int pID, int connection, void* buf, int size )
{
int len;
pluginTcpClientSocket_t* ptcs = &pluginFunctions.plugins[pID].sockets[connection];
if(ptcs->sock < 1){
Com_PrintWarning("Plugin_TcpGetData: called on a non open socket for plugin ID: #%d\n", pID);
return -1;
}
len = NET_TcpClientGetData(ptcs->sock, buf, size);
if(len == -1)
{
ptcs->sock = -1;
}
return len;
}
void G_HudSetMovingOverTime(game_hudelem_t* element ,int time, float newx, float newy){
if(time > 60000 || time < 0)
{
Com_PrintWarning("G_HudSetMovingOverTime: time: %i is out of range. Range is 0 to 60000\n", time);
time = 0;
}
element->movestarttime = level.time;
element->movex = element->x;
element->movey = element->y;
element->x = newx;
element->y = newy;
element->movealign = element->align;
element->movescralign = element->screenalign;
element->movingtime = time;
}
qboolean PHandler_TcpSendData(int pID, int connection, void* data, int len)
{
int state;
pluginTcpClientSocket_t* ptcs = &pluginFunctions.plugins[pID].sockets[connection];
if(ptcs->sock < 1){
Com_PrintWarning("Plugin_TcpSendData: called on a non open socket for plugin ID: #%d\n", pID);
return qfalse;
}
state = NET_TcpSendData(ptcs->sock, data, len);
if(state == -1)
{
ptcs->sock = -1;
return qfalse;
}
return qtrue;
}
void SV_LoadBanlist(){
time_t aclock;
time(&aclock);
char buf[256];
buf[0] = 0;
fileHandle_t file;
int read;
int error;
int i;
FS_SV_FOpenFileRead(banlistfile->string,&file);
if(!file){
Com_DPrintf("SV_ReadBanlist: Can not open %s for reading\n",banlistfile->string);
return;
}
for(i = 0, error = 0 ;error < 32 ;i++){
read = FS_ReadLine(buf,sizeof(buf),file);
if(read == 0){
Com_Printf("%i lines parsed from %s, %i errors occured\n",i,banlistfile->string,error);
FS_FCloseFile(file);
return;
}
if(read == -1){
Com_Printf("Can not read from %s\n",banlistfile->string);
FS_FCloseFile(file);
return;
}
if(!*buf || *buf == '/' || *buf == '\n'){
continue;
}
if(!SV_ParseBanlist(buf, aclock, i+1)) error++; //Executes the function given as argument in execute
}
Com_PrintWarning("More than 32 errors occured by reading from %s\n",banlistfile->string);
FS_FCloseFile(file);
}
static int FTP_SendReceiveData(ftRequest_t* request)
{
char* line;
char command[MAX_STRING_CHARS];
int status, bytes;
byte* buf;
netadr_t pasvadr;
char stringlinebuf[MAX_STRING_CHARS];
status = FT_ReceiveData(request);
if (status == -1 && request->stage < 9999) {
return -1;
}
if(status == 0 && request->stage < 9999)
{
status = FT_SendData(request);
}
if (status == -1 && request->stage < 9999) {
return -1;
}
while ((line = MSG_ReadStringLine(&request->recvmsg, stringlinebuf, sizeof(stringlinebuf))) && line[0] != '\0' )
{
if(isNumeric(line, 0) == qfalse)
continue;
request->code = atoi(line);
if(request->stage > 60)
Com_DPrintf("\n");
Com_DPrintf("Response Code = %d\n", request->code);
if (request->stage < 0)
{
continue;
}
switch (request->code)
{
case 220:
if(request->stage == 0)
{
// Initial OK response received /
Com_DPrintf("FTP_SendReceiveData: Inital OK response received\n");
request->stage = 1;
}else {
Com_PrintWarning("\nFTP_SendReceiveData: Received: %s - Should not happen!\n", line);
}
break;
case 202:
if(request->stage < 21 && request->stage > 10)
{
request->stage = 21;
}else {
Com_Printf("\nFTP_SendReceiveData: Received unexpected response: %s - Will abort!\n", line);
request->stage = -20;
}
break;
case 331:
if(request->stage == 10)
{
Com_DPrintf("FTP_SendReceiveData: Need Password\n");
request->stage = 11;
}else if(request->stage == 16){
Com_DPrintf("FTP_SendReceiveData: Need Password\n");
request->stage = 17;
}else {
Com_Printf("FTP_SendReceiveData: Received unexpected response: %s - Will abort!\n", line);
request->stage = -20;
}
break;
case 332:
if(request->stage == 10 || request->stage == 12)
{
Com_DPrintf("FTP_SendReceiveData: Need Account\n");
request->stage = 15;
}else {
Com_Printf("\nFTP_SendReceiveData: Received unexpected response: %s - Will abort!\n", line);
request->stage = -20;
}
break;
case 230:
if (request->stage <= 20)
{
Com_DPrintf("FTP_SendReceiveData: Logged in OK\n");
request->stage = 21;
}else {
Com_Printf("\nFTP_SendReceiveData: Received unexpected response: %s - Will abort!\n", line);
request->stage = -20;
}
break;
case 227:
if(request->stage == 36)
{
FTP_GetPassiveAddress(line, &pasvadr);
if(pasvadr.type == NA_IP)
{
Com_DPrintf("FTP_SendReceiveData: Entering Passive Mode at %s OK\n", NET_AdrToString(&pasvadr));
request->transfersocket = NET_TcpClientConnect(NET_AdrToString(&pasvadr));
if(request->transfersocket < 0)
{
request->transfersocket = -1;
return -1;
}
request->stage = 41;
}else {
Com_PrintWarning("FTP_SendReceiveData: Couldn't read the address/port of passive mode response\n");
return -1;
}
}else {
Com_Printf("\nFTP_SendReceiveData: Received unexpected response: %s - Will abort!\n", line);
request->stage = -20;
}
break;
case 229:
if(request->stage == 32)
{
FTP_GetExtendedPassiveAddress(line, request->address, &pasvadr);
if(pasvadr.type == NA_IP || pasvadr.type == NA_IP6)
{
Com_DPrintf("FTP_SendReceiveData: Entering Extended Passive Mode at %s OK\n", NET_AdrToString(&pasvadr));
request->transfersocket = NET_TcpClientConnect(NET_AdrToString(&pasvadr));
if(request->transfersocket < 0)
{
request->transfersocket = -1;
return -1;
}
request->stage = 41;
}else {
Com_PrintWarning("FTP_SendReceiveData: Couldn't read the address/port of passive mode response\n");
return -1;
}
}else {
Com_Printf("\nFTP_SendReceiveData: Received unexpected response: %s - Will abort!\n", line);
request->stage = -20;
}
break;
case 213:
if(request->stage == 50)
{
bytes = atoi(&line[4]);
Com_DPrintf("FTP_SendReceiveData: Requested file will have %d bytes\n", bytes);
if(bytes < 1 || bytes > 1024*1024*1024)
{
Com_PrintWarning("FTP_SendReceiveData: Requested file would exceed %d bytes. Will not download!\n", 1024*1024*1024);
}
buf = Z_Malloc(bytes);
if( buf == NULL)
{
Com_PrintWarning("FTP_SendReceiveData: Failed to allocate %d bytes for download file!\n", bytes);
return -1;
}
MSG_Init(&request->transfermsg, buf, bytes);
request->stage = 51;
}
break;
case 150:
case 125:
if (request->stage == 60) {
request->stage = 61;
Com_DPrintf("FTP_SendReceiveData: Begin File Transfer\n");
}
break;
case 226:
/* File transfer is completed from the servers view */
if(request->stage < 9999)
request->stage = 9999;
break;
case 221:
if(request->stage < 10000)
{
Com_Printf("\nThe FTP server closed the control connection before the transfer was completed!\n");
request->stage = -1;
}
break;
case 228:
Com_Printf( "\nLong Passive Mode not supported and not requested!\n" );
request->stage = -20;
break;
case 120:
Com_Printf( "The FTP server is not ready at the moment!\n" );
request->stage = -20;
break;
case 231:
if(request->stage < 10000)
{
Com_Printf("\nThe FTP server logged us out before the transfer was completed!\n");
request->stage = -20;
}
break;
case 350:
if(request->stage < 10000)
{
Com_Printf("\nThe FTP server returned \'%s\' before the transfer was completed. Must not happen!\n", line);
request->stage = -20;
}
break;
case 421:
request->stage = -1;
break;
case 500:
case 501:
case 502:
case 503:
if (request->stage == 32) {
request->stage = 35;
Com_DPrintf("FTP_SendReceiveData: Command EPSV is not implemented on FTP server. Trying PASV...\n");
break;
}else if (request->stage == 36) {
Com_Printf("FTP_SendReceiveData: FTP Server does not support passive mode. Request failed!\n");
request->stage = -10;
}
default:
if (request->code >= 200 && request->code < 300 && request->stage >= 30){
Com_DPrintf("\n");
Com_DPrintf("FTP_SendReceiveData: %s\n", line);
request->stage ++;
break;
}else if (request->code >= 400) {
Com_Printf("\nThe FTP server connection got ended with the message: %s\n", line);
request->stage = -20;
}
break;
}
}
switch(request->stage)
{
case 1:
/* Waiting for OK response code (220) */
Com_sprintf(command, sizeof(command), "USER %s\r\n", "anonymous");
FT_AddData(request, command, strlen(command));
request->stage = 10;
break;
case 11:
Com_sprintf(command, sizeof(command), "PASS %s\r\n", "*****@*****.**");
FT_AddData(request, command, strlen(command));
request->stage = 12;
break;
case 15:
Com_sprintf(command, sizeof(command), "ACCT %s\r\n", "nil");
FT_AddData(request, command, strlen(command));
request->stage = 16;
break;
case 17:
Com_sprintf(command, sizeof(command), "PASS %s\r\n", "*****@*****.**");
FT_AddData(request, command, strlen(command));
request->stage = 20;
break;
case 21:
Com_sprintf(command, sizeof(command), "TYPE I\r\n");
FT_AddData(request, command, strlen(command));
request->stage = 30;
break;
case 31:
Com_sprintf(command, sizeof(command), "EPSV\r\n");
FT_AddData(request, command, strlen(command));
request->stage = 32;
break;
case 35:
Com_sprintf(command, sizeof(command), "PASV\r\n");
FT_AddData(request, command, strlen(command));
request->stage = 36;
break;
case 41:
Com_sprintf(command, sizeof(command), "SIZE %s\r\n", request->url);
FT_AddData(request, command, strlen(command));
request->stage = 50;
break;
case 51:
Com_sprintf(command, sizeof(command), "RETR %s\r\n", request->url);
FT_AddData(request, command, strlen(command));
request->stage = 60;
break;
case 61:
/* Receive new bytes */
request->transferactive = qtrue;
status = NET_ReceiveData(request->transfersocket, &request->transfermsg);
if (status == -1){
request->transfersocket = -1;
}else if(status == -2){
request->transfersocket = -1;
}
if(request->transfermsg.cursize == request->transfermsg.maxsize && request->transfermsg.maxsize != 0)
{
/* Comple file retrived */
request->stage = 9999;
break;
}else if(request->transfersocket == -1){
request->stage = -20;
}
break;
case 9999:
status = -1;
request->transferactive = qfalse;
if(request->transfersocket >= 0)
status = NET_ReceiveData(request->transfersocket, &request->transfermsg);
if (status == -1 || status == -2){
request->transfersocket = -1;
}
if(request->transfermsg.cursize == request->transfermsg.maxsize && request->transfermsg.maxsize != 0)
{
/* Comple file retrived */
Com_sprintf(command, sizeof(command), "QUIT\r\n");
FT_AddData(request, command, strlen(command));
request->stage = 10000;
break;
}else {
Com_Printf("\nThe FTP server closed the data connection before the transfer was completed!\n");
request->stage = -20;
break;
}
case -20:
request->transferactive = qfalse;
Com_Printf("\nFTP File Transfer has failed!\n");
case -10:
request->transferactive = qfalse;
if(request->socket >= 0 )
{
Com_sprintf(command, sizeof(command), "QUIT\r\n", request->url);
FT_AddData(request, command, strlen(command));
}
request->stage = -1;
break;
case -1:
Com_Printf("\n");
return -1;
break;
case 10000:
request->transferactive = qfalse;
if(request->socket >= 0)
{
NET_TcpCloseSocket(request->socket);
request->socket = -1;
}
if(request->transfersocket >= 0)
{
NET_TcpCloseSocket(request->transfersocket);
request->transfersocket = -1;
}
if(request->recvmsg.data != NULL)
{
Z_Free(request->recvmsg.data);
request->recvmsg.data = NULL;
}
if(request->transfermsg.data == NULL)
{
request->stage = -1;
Com_PrintError("\nReceived complete message but message buffer is NULL!\n");
break;
}
Com_Memcpy(&request->recvmsg, &request->transfermsg, sizeof(msg_t));
Com_Memset(&request->transfermsg, 0, sizeof(msg_t));
request->contentLength = request->recvmsg.cursize;
request->headerLength = 0;
request->stage = 10001;
request->code = 200;
Q_strncpyz(request->status, "OK", sizeof(request->status));
break;
case 10001:
Com_Printf("\n");
return 1;
default:
return 0;
}
return 0;
}
game_hudelem_t* G_GetNewHudElem(unsigned int clientnum){
int i;
game_hudelem_t* element = g_hudelems;
for(i = 0; i < MAX_HUDELEMS; i++, element++)
{
if(element->inuse)
continue;
element->inuse = qtrue;
element->x = 0;
element->y = 0;
element->var_03 = 0;
element->var_04 = 1023;
element->fonttype = 0;
element->align = 0;
element->screenalign = 0;
element->color.red = 255;
element->color.green = 255;
element->color.blue = 255;
element->color.alpha = 255;
element->glowcolor.red = 0;
element->glowcolor.green = 0;
element->glowcolor.blue = 0;
element->glowcolor.alpha = 0;
element->fadecolor.red = 0;
element->fadecolor.green = 0;
element->fadecolor.blue = 0;
element->fadecolor.alpha = 0;
element->fadestarttime = 0;
element->fadetime = 0;
element->var_13 = 0;
element->sort = 0;
element->displayoption = 0;
element->var_34 = 0;
element->var_35 = 0;
element->var_36 = 0;
element->var_37 = 0;
element->var_38 = 0;
element->movestarttime = 0;
element->movingtime = 0;
element->fontscale = 1.4;
element->archived = 1;
element->var_14 = 0;
element->var_15 = 0;
element->movex = 0;
element->movey = 0;
element->movealign = 0;
element->movescralign = 0;
element->var_18 = 0;
element->var_19 = 0;
element->var_20 = 0;
element->var_21 = 0;
element->var_28 = 0;
element->var_29 = 0;
element->var_30 = 0;
element->hudTextConfigStringIndex = 0;
if(clientnum > 63)
element->entitynum = 1023;
else
element->entitynum = clientnum;
element->teamnum = 0;
return element;
}
Com_PrintWarning("G_CreateHudElem: Exceeded limit of Hudelems\n");
return NULL;
}
void PB_SystemDummy(const char* cmdline)
{
Com_PrintWarning("system( %s ) of PunkBuster is blocked while running in securemode\n", cmdline);
}
void Sec_Update( qboolean getbasefiles ){
char buff[SEC_UPDATE_INITIALBUFFSIZE];
char *ptr,*ptr2, *testfile;
char filepathbuf[MAX_OSPATH];
char baseurl[1024];
char name1[256],name2[256];
sec_file_t files, *currFile = &files;
qboolean dlExec = qfalse;
int len;
char hash[128];
long unsigned size;
ftRequest_t* filetransferobj;
ftRequest_t* curfileobj;
int transret;
mvabuf;
if(!Sec_Initialized()){
return;
}
#ifdef CAN_UPDATE
Com_Printf("\n-----------------------------\n");
Com_Printf(" CoD4X Auto Update\n");
Com_Printf(" Current version: %g\n",SEC_VERSION);
Com_Printf(" Current build: %d\n",BUILD_NUMBER);
Com_Printf(" Current type: %s\n",SEC_TYPE == 's' ? "stable " : "experimental");
Com_Printf("-----------------------------\n\n");
canupdate = Cvar_RegisterBool("allowupdating", qtrue, 0, "This enables autoupdating of CoD4 server with new versions.");
if(getbasefiles == qtrue)
{
Com_sprintf(buff, sizeof(buff), "http://" SEC_UPDATE_HOST SEC_UPDATE_GETGROUNDVERSION);
}else{
if(canupdate->boolean == qfalse)
return;
Com_sprintf(buff, sizeof(buff), "http://" SEC_UPDATE_HOST SEC_UPDATE_GETVERSION);
}
#else
if(getbasefiles == qtrue)
{
Com_sprintf(buff, sizeof(buff), "http://" SEC_UPDATE_HOST SEC_UPDATE_GETGROUNDVERSION);
}else{
return;
}
#endif
filetransferobj = FileDownloadRequest( buff );
if(filetransferobj == NULL){
return;
}
do {
transret = FileDownloadSendReceive( filetransferobj );
usleep(20000);
} while (transret == 0);
if(transret < 0)
{
FileDownloadFreeRequest(filetransferobj);
return;
}
/* Need to catch errors */
// FS_WriteFile("tmp.txt", va("%d", status), 1);
// TODO: Do something with the status?
// FS_WriteFile("tmp2.txt", packet.header, packet.headerLength);
// FS_WriteFile("tmp3.txt", packet.content, packet.contentLength);
if(filetransferobj->code <= 0){
Com_PrintError("Receiving data. Error code: %d.\n", filetransferobj->code);
FileDownloadFreeRequest(filetransferobj);
return;
}
if(filetransferobj->code == 204){
Com_Printf("\nServer is up to date.\n\n");
FileDownloadFreeRequest(filetransferobj);
return;
}
else if(filetransferobj->code != 200){
Com_PrintWarning("The update server's malfunction.\nStatus code: %d.\n", filetransferobj->code);
FileDownloadFreeRequest(filetransferobj);
return;
}
Com_Memset(&files, 0, sizeof(files));
/* We need to parse filenames etc */
ptr = Sec_StrTok((char*)(filetransferobj->recvmsg.data + filetransferobj->headerLength),"\n",42); // Yes, 42.
if(ptr == NULL || Q_stricmpn("baseurl: ", ptr, 9))
{
Com_PrintWarning("Sec_Update: Corrupt data from update server. Update aborted.\n");
FileDownloadFreeRequest(filetransferobj);
return;
}
Q_strncpyz(baseurl, ptr +9, sizeof(baseurl));
ptr = Sec_StrTok(NULL,"\n",42); // Yes, 42 again.
while(ptr != NULL){
currFile->next = Sec_GMalloc(sec_file_t,1);
currFile = currFile->next;
Com_Memset(currFile,0,sizeof(sec_file_t));
ptr2 = strchr(ptr,' ');
if(ptr2 == NULL){
Com_PrintWarning("Sec_Update: Corrupt data from update server. Update aborted.\nDebug:\"%s\"\n",ptr);
FileDownloadFreeRequest(filetransferobj);
return;
}
*ptr2++ = 0;
Q_strncpyz(currFile->path,ptr,sizeof(currFile->path));
ptr = ptr2;
ptr2 = strchr(ptr,' ');
if(ptr2 == NULL){
Com_PrintWarning("Sec_Update: Corrupt data from update server. Update aborted.\nDebug:\"%s\"\n",ptr);
FileDownloadFreeRequest(filetransferobj);
return;
}
*ptr2++ = 0;
if(!isInteger(ptr, 0)){
Com_PrintWarning("Sec_Update: Corrupt data from update server - size is not a number. Update aborted.\nDebug:\"%s\"\n",ptr);
FileDownloadFreeRequest(filetransferobj);
return;
}
currFile->size = atoi(ptr);
Q_strncpyz(currFile->hash,ptr2,sizeof(currFile->hash));
Q_strncpyz(currFile->name,currFile->path, sizeof(currFile->name));
//printf("DEBUG: File to download: link: \"%s\", name: \"%s\", size: %d, hash: \"%s\"\n\n",file.path,file.name,file.size,file.hash);
Com_sprintf(buff, sizeof(buff), SEC_UPDATE_DOWNLOAD(baseurl, currFile->path));
curfileobj = FileDownloadRequest(buff);
if(curfileobj == NULL)
{
FileDownloadFreeRequest(filetransferobj);
return;
}
Com_Printf("Downloading file: \"%s\"\n\n",currFile->name);
do {
transret = FileDownloadSendReceive( curfileobj );
Com_Printf("%s", FileDownloadGenerateProgress( curfileobj ));
usleep(20000);
} while (transret == 0);
Com_Printf("\n");
if(transret < 0)
{
FileDownloadFreeRequest(curfileobj);
FileDownloadFreeRequest(filetransferobj);
return;
}
Q_strncpyz(buff,currFile->name, sizeof(buff));
Q_strcat(buff, sizeof(buff),".new");
if(curfileobj->code != 200){
Com_PrintError("Downloading has failed! Error code: %d. Update aborted.\n", curfileobj->code);
FileDownloadFreeRequest(filetransferobj);
FileDownloadFreeRequest(curfileobj);
return;
}
len = FS_SV_BaseWriteFile(buff, curfileobj->recvmsg.data + curfileobj->headerLength, curfileobj->contentLength);
if(len != curfileobj->contentLength){
len = FS_SV_HomeWriteFile(buff, curfileobj->recvmsg.data + curfileobj->headerLength, curfileobj->contentLength);
if(len != curfileobj->contentLength)
{
Com_PrintError("Opening \"%s\" for writing! Update aborted.\n",buff);
FileDownloadFreeRequest(filetransferobj);
FileDownloadFreeRequest(curfileobj);
return;
}
}
ptr = Sec_StrTok(NULL,"\n",42); // Yes, 42 again.
size = sizeof(hash);
if(!Sec_HashMemory(SEC_HASH_SHA256, curfileobj->recvmsg.data + curfileobj->headerLength, curfileobj->contentLength, hash, &size,qfalse)){
Com_PrintError("Hashing the file \"%s\". Error code: %s.\nUpdate aborted.\n",currFile->name,Sec_CryptErrStr(SecCryptErr));
FileDownloadFreeRequest(filetransferobj);
FileDownloadFreeRequest(curfileobj);
return;
}
FileDownloadFreeRequest(curfileobj);
if(!Q_strncmp(hash, currFile->hash, size)){
Com_Printf("Successfully downloaded file \"%s\".\n", currFile->name);
}
else{
Com_PrintError("File \"%s\" is corrupt!\nUpdate aborted.\n",currFile->name);
Com_DPrintf("Hash: \"%s\", correct hash: \"%s\".\n",hash,currFile->hash);
FileDownloadFreeRequest(filetransferobj);
return;
}
}
FileDownloadFreeRequest(filetransferobj);
Com_Printf("All files downloaded successfully. Applying update...\n");
currFile = files.next;
do{
Com_Printf("Updating file %s...\n", currFile->name);
Q_strncpyz(name1, currFile->name, sizeof(name1));
Q_strcat(name1, sizeof(name1), ".old");
Q_strncpyz(name2, currFile->name, sizeof(name2));
Q_strcat(name2, sizeof(name2), ".new");
testfile = FS_SV_GetFilepath(name1, filepathbuf, sizeof(filepathbuf));
if(testfile != NULL)
{ // Old file exists, back it up
FS_SV_BaseRemove( name1 );
FS_SV_HomeRemove( name1 );
testfile = FS_SV_GetFilepath(name1, filepathbuf, sizeof(filepathbuf));
if(testfile != NULL)
{
Com_PrintWarning("Couldn't remove backup file: %s\n", testfile);
}
if(FS_SV_HomeFileExists(name1) == qtrue)
{
Com_PrintError("Couldn't remove backup file from fs_homepath: %s\n", name1);
}
}
// Check if an old file exists with this name
testfile = FS_SV_GetFilepath(currFile->name, filepathbuf, sizeof(filepathbuf));
if(testfile != NULL)
{ // Old file exists, back it up
FS_SV_Rename(currFile->name, name1);
}
testfile = FS_SV_GetFilepath(currFile->name, filepathbuf, sizeof(filepathbuf));
// We couldn't back it up. Now we try to just delete it.
if(testfile != NULL)
{
FS_SV_BaseRemove( currFile->name );
FS_SV_HomeRemove( currFile->name );
testfile = FS_SV_GetFilepath( currFile->name, filepathbuf, sizeof(filepathbuf) );
if(testfile != NULL)
{
Com_PrintWarning("Couldn't remove file: %s\n", testfile);
}
if(FS_SV_HomeFileExists(currFile->name) == qtrue)
{
Com_PrintError("Couldn't remove file from fs_homepath: %s\n", currFile->name);
Com_PrintError("Update has failed!\n");
return;
}
}
if(Q_strncmp(currFile->name, EXECUTABLE_NAME, 15)){
/* This is not the executable file */
FS_SV_Rename(name2, currFile->name);
testfile = FS_SV_GetFilepath(currFile->name, filepathbuf, sizeof(filepathbuf));
if(testfile == NULL)
{
Com_PrintError("Failed to rename file %s to %s\n", name2,currFile->name);
Com_PrintError("Update has failed!\n");
return;
}
Com_Printf("Update on file %s successfully applied.\n",currFile->name);
}else{
/* This is the executable file */
testfile = FS_SV_GetFilepath(name2, filepathbuf, sizeof(filepathbuf));
if(testfile == NULL)
{
Com_PrintError("Can not find file %s\n", name2);
Com_PrintError("Update has failed!\n");
return;
}
if(FS_SetPermissionsExec(name2) == qfalse)
{
Com_PrintError("CRITICAL ERROR: failed to change mode of the file \"%s\"! Aborting, manual installation might be required.\n", name2);
return;
}
FS_RenameOSPath(Sys_ExeFile(), va("%s.dead", Sys_ExeFile()));
FS_RemoveOSPath(va("%s.dead", Sys_ExeFile()));
FS_RemoveOSPath(Sys_ExeFile());
if(FS_FileExistsOSPath(Sys_ExeFile()))
{
Com_PrintError("Failed to delete file %s\n", Sys_ExeFile());
Com_PrintError("Update has failed!\n");
return;
}
FS_RenameOSPath(testfile, Sys_ExeFile());
if(!FS_FileExistsOSPath(Sys_ExeFile()))
{
Com_PrintError("Failed to rename file %s\n", testfile);
Com_PrintError("Update has failed! Manual reinstallation of file %s is required. This server is now broken!\n", Sys_ExeFile());
return;
}
Com_Printf("Update on file %s successfully applied.\n", Sys_ExeFile());
dlExec = qtrue;
}
currFile = currFile->next;
}while(currFile != NULL);
Sec_FreeFileStruct(files.next);
Com_Printf("Finalizing update...\n");
if(dlExec == qtrue)
{
Sys_Restart("System has been updated and will restart now.");
}else{
FS_Restart( 0 );
}
}
__cdecl void SV_WriteSnapshotToClient(client_t* client, msg_t* msg){
snapshotInfo_t snapInfo;
int lastframe;
int from_num_entities;
int newindex, oldindex, newnum, oldnum;
clientState_ts *newcs, *oldcs;
entityState_t *newent, *oldent;
clientSnapshot_t *frame, *oldframe;
int i;
int snapFlags;
int var_x, from_first_entity, from_num_clients, from_first_client;
snapInfo.clnum = client - svsHeader.clients;
snapInfo.cl = (void*)client;
snapInfo.var_01 = 0;
snapInfo.var_02 = 0;
snapInfo.var_03 = 0;
frame = &client->frames[client->netchan.outgoingSequence & PACKET_MASK];
frame->var_03 = svsHeader.time;
if(client->deltaMessage <= 0 || client->state != CS_ACTIVE) {
oldframe = NULL;
lastframe = 0;
var_x = 0;
} else if(client->netchan.outgoingSequence - client->deltaMessage >= PACKET_BACKUP - 3) {
Com_DPrintf("%s: Delta request from out of date packet.\n", client->name);
oldframe = NULL;
lastframe = 0;
var_x = 0;
} else if(client->demoDeltaFrameCount <= 0 && client->demorecording){
oldframe = NULL;
lastframe = 0;
var_x = 0;
client->demowaiting = qfalse;
Com_DPrintf("Force a nondelta frame for %s for demo recording\n", client->name);
if(client->demoMaxDeltaFrames < 1024)
{
client->demoMaxDeltaFrames <<= 1;
}
client->demoDeltaFrameCount = client->demoMaxDeltaFrames;
} else {
oldframe = &client->frames[client->deltaMessage & PACKET_MASK];
lastframe = client->netchan.outgoingSequence - client->deltaMessage;
var_x = oldframe->var_03;
client->demoDeltaFrameCount--;
if(oldframe->first_entity < svsHeader.nextSnapshotEntities - svsHeader.numSnapshotEntities) {
Com_PrintWarning("%s: Delta request from out of date entities - delta against entity %i, oldest is %i, current is %i. Their old snapshot had %i entities in it\n",
client->name, oldframe->first_entity, svs.nextSnapshotEntities - svs.numSnapshotEntities, svs.nextSnapshotEntities, oldframe->num_entities );
oldframe = NULL;
lastframe = 0;
var_x = 0;
} else if(oldframe->first_client < svsHeader.nextSnapshotClients - svsHeader.numSnapshotClients) {
Com_PrintWarning("%s: Delta request from out of date clients - delta against client %i, oldest is %i, current is %i. Their old snapshot had %i clients in it\n",
client->name, oldframe->first_client, svs.nextSnapshotClients - svs.numSnapshotClients, svs.nextSnapshotClients, oldframe->num_clients);
oldframe = NULL;
lastframe = 0;
var_x = 0;
}
}
MSG_WriteByte(msg, svc_snapshot);
MSG_WriteLong(msg, svsHeader.time);
MSG_WriteByte(msg, lastframe);
snapInfo.var_01 = var_x;
snapFlags = svsHeader.snapFlagServerBit;
if(client->rateDelayed){
snapFlags |= 1;
}
if(client->state == CS_ACTIVE) {
client->unksnapshotvar = 1;
} else {
if(client->state != CS_ZOMBIE){
client->unksnapshotvar = 0;
}
}
if(!client->unksnapshotvar){
snapFlags |= 2;
}
MSG_WriteByte(msg, snapFlags);
if(oldframe) {
MSG_WriteDeltaPlayerstate( &snapInfo, msg, svsHeader.time, &oldframe->ps, &frame->ps);
from_num_entities = oldframe->num_entities;
from_first_entity = oldframe->first_entity;
from_num_clients = oldframe->num_clients;
from_first_client = oldframe->first_client;
} else {
MSG_WriteDeltaPlayerstate( &snapInfo, msg, svsHeader.time, 0, &frame->ps);
from_num_entities = 0;
from_first_entity = 0;
from_num_clients = 0;
from_first_client = 0;
}
MSG_ClearLastReferencedEntity(msg);
newindex = 0;
oldindex = 0;
// Com_Printf("\nDelta client: %i:\n", snapInfo.clnum);
while ( newindex < frame->num_entities || oldindex < from_num_entities){
if ( newindex >= frame->num_entities ) {
newnum = 9999;
newent = NULL;
} else {
newent = &svsHeader.snapshotEntities[( frame->first_entity + newindex ) % svsHeader.numSnapshotEntities];
newnum = newent->number;
}
if ( oldindex >= from_num_entities ) {
oldnum = 9999;
oldent = NULL;
} else {
oldent = &svsHeader.snapshotEntities[( from_first_entity + oldindex ) % svsHeader.numSnapshotEntities];
oldnum = oldent->number;
}
if ( newnum == oldnum ) {
// delta update from old position
// because the force parm is qfalse, this will not result
// in any bytes being emited if the entity has not changed at all
// if(newent->number < 64 || oldent->number < 64)
// Com_Printf(" Delta Update Entity - New delta: %i, %x Old delta: %i, %x\n", newent->number, newent, oldent->number, oldent);
MSG_WriteDeltaEntity( &snapInfo, msg, svsHeader.time, oldent, newent, qfalse );
oldindex++;
newindex++;
continue;
}
if ( newnum < oldnum ) {
// this is a new entity, send it from the baseline
snapInfo.var_02 = 1;
// if(newent->number < 64)
// Com_Printf(" Delta Add Entity: %i, %x\n", newent->number, newent);
MSG_WriteDeltaEntity( &snapInfo, msg, svsHeader.time, &svsHeader.svEntities[newnum].baseline, newent, qtrue );
snapInfo.var_02 = 0;
newindex++;
continue;
}
if ( newnum > oldnum ) {
// the old entity isn't present in the new message
// if(oldent->number < 64)
// Com_Printf(" Delta Remove Entity: %i, %x\n", oldent->number, oldent);
MSG_WriteDeltaEntity( &snapInfo, msg, svsHeader.time, oldent, NULL, qtrue );
oldindex++;
continue;
}
}
MSG_WriteEntityIndex(&snapInfo, msg, ( MAX_GENTITIES - 1 ), GENTITYNUM_BITS);
MSG_ClearLastReferencedEntity(msg);
newindex = 0;
oldindex = 0;
while(newindex < frame->num_clients || oldindex < from_num_clients){
if(newindex >= frame->num_clients){
newnum = 9999;
newcs = NULL;
}else{
newcs = &svsHeader.snapshotClients[(frame->first_client + newindex) % svsHeader.numSnapshotClients];
newnum = newcs->number;
}
if(oldindex >= from_num_clients){
oldnum = 9999;
oldcs = NULL;
}else{
oldcs = &svsHeader.snapshotClients[(from_first_client + oldindex) % svsHeader.numSnapshotClients];
oldnum = oldcs->number;
}
if ( newnum == oldnum ) {
// delta update from old position
// because the force parm is qfalse, this will not result
// in any bytes being emited if the entity has not changed at all
MSG_WriteDeltaClient( &snapInfo, msg, svsHeader.time, oldcs, newcs, qfalse );
oldindex++;
newindex++;
continue;
}
if ( newnum < oldnum ) {
MSG_WriteDeltaClient( &snapInfo, msg, svsHeader.time, NULL, newcs, qtrue );
newindex++;
continue;
}
if ( newnum > oldnum ) {
MSG_WriteDeltaClient( &snapInfo, msg, svsHeader.time, oldcs, NULL, qtrue );
oldindex++;
continue;
}
}
MSG_WriteBit0(msg);
if(sv_padPackets->integer){
for( i=0 ; i < sv_padPackets->integer ; i++){
MSG_WriteByte( msg, 0); //svc_nop
}
}
}
qboolean __cdecl Com_LoadDvarsFromBuffer(const char **inputbuf, unsigned int length, const char *data_p, const char *filename)
{
const char *cvar_name;
int i, count;
char buf[16384];
const char* line;
Com_Memset(buf, 0, sizeof(buf));
for(i = 0; i < length; i++)
{
Cvar_Reset(inputbuf[i]);
}
Com_BeginParseSession(filename);
count = 0;
while ( (cvar_name = Com_Parse(&data_p)) && cvar_name[0])
{
for(i = 0; i < length; i++)
{
if(!Q_stricmp(cvar_name, inputbuf[i]))
break;
}
if(i == length)
{
if(com_developer && com_developer->integer)
{
Com_PrintWarning("WARNING: unknown cvar '%s' in file '%s'\n", cvar_name, filename);
}
Com_SkipRestOfLine(&data_p);
}else{
line = Com_ParseOnLine(&data_p);
if(com_developer && com_developer->integer)
{
Cvar_Set(inputbuf[i], line);
}else{
if((!Q_strncmp(inputbuf[i],"bg_shock_viewKickPeriod", 23) || !Q_strncmp(inputbuf[i],"bg_shock_viewKickFadeTime", 25)) && (line[0] == '0' && line[1] == '\0'))
{
/* Quite this spam */
}else{
Cvar_Set(inputbuf[i], line);
}
}
if ( !buf[i] )
{
buf[i] = 1;
++count;
}
}
}
Com_EndParseSession();
if ( length == count )
{
/* No Errors */
return 1;
}
Com_PrintError("ERROR: the following cvars were not specified in file '%s'\n", filename);
for(i = 0; i < length; i++)
{
while ( buf[i] && i < length )
{
++i;
}
if(i < length)
Com_PrintError(" %s\n", inputbuf[i]);
}
return 0;
}
/*
============
Cmd_ExecuteString
A complete command line has been parsed, so try to execute it
============
*/
void Cmd_ExecuteString( const char *text )
{
cmd_function_t *cmd, **prev;
char arg0[MAX_TOKEN_CHARS];
#ifdef PUNKBUSTER
/* Trap commands going to PunkBuster here */
if(!Q_stricmpn(text, "pb_sv_", 6))
{
if(gamebinary_initialized == qtrue)
PbSvAddEvent(14, -1, strlen(text), (char*)text);
return;
}
#endif
// execute the command line
Cmd_TokenizeString( text );
if ( !Cmd_Argc() ) {
Cmd_EndTokenizedString( );
return; // no tokens
}
Q_strncpyz(arg0, Cmd_Argv(0), sizeof(arg0));
//Legacy fallback
if(!Q_stricmpn(arg0, "dvar", 4))
{
arg0[0] = 'c';
}else if(!Q_stricmpn(arg0, "auth", 4)){
if(!Q_stricmp(arg0, "authChangePassword"))
{
Q_strncpyz(arg0, "changePassword", sizeof(arg0));
Com_PrintWarning("\"authchangePassword\" is deprecated and will be removed soon. Use \"changePassword\" instead\n");
}
else if(!Q_stricmp(arg0, "authSetAdmin"))
{
Q_strncpyz(arg0, "AdminAddAdminWithPassword", sizeof(arg0));
Com_PrintWarning("\"authSetAdmin\" is deprecated and will be removed soon. Use \"AdminAddAdminWithPassword\" instead\n");
}
else if(!Q_stricmp(arg0, "authUnsetAdmin"))
{
Q_strncpyz(arg0, "AdminRemoveAdmin", sizeof(arg0));
Com_PrintWarning("\"authUnsetAdmin\" is deprecated and will be removed soon. Use \"AdminRemoveAdmin\" instead\n");
}
else if(!Q_stricmp(arg0, "authListAdmins"))
{
Q_strncpyz(arg0, "adminListAdmins", sizeof(arg0));
Com_PrintWarning("\"authListAdmins\" is deprecated and will be removed soon. Use \"adminListAdmins\" instead\n");
}
}else if(!Q_stricmp(arg0, "cmdpowerlist")){
Q_strncpyz(arg0, "AdminListCommands", sizeof(arg0));
Com_PrintWarning("\"cmdpowerlist\" is deprecated and will be removed soon. Use \"AdminListCommands\" instead\n");
}
else if(!Q_stricmp(arg0, "setCmdMinPower")){
Q_strncpyz(arg0, "AdminChangeCommandPower", sizeof(arg0));
Com_PrintWarning("\"setCmdMinPower\" is deprecated and will be removed soon. Use \"AdminChangeCommandPower\" instead\n");
}
// check registered command functions
for ( prev = &cmd_functions ; *prev ; prev = &cmd->next ) {
cmd = *prev;
if ( !Q_stricmp( arg0, cmd->name ) ) {
// rearrange the links so that the command will be
// near the head of the list next time it is used
*prev = cmd->next;
cmd->next = cmd_functions;
cmd_functions = cmd;
// perform the action
if ( !cmd->function ) {
// let the cgame or game handle it
break;
} else {
cmd->function ();
}
Cmd_EndTokenizedString( );
return;
}
}
// check cvars
if ( Cvar_Command() ) {
Cmd_EndTokenizedString( );
return;
}
// check server game commands
if ( com_sv_running && com_sv_running->boolean && SV_GameCommand() ) {
Cmd_EndTokenizedString( );
return;
}
Cmd_EndTokenizedString( );
if(!Q_stricmpn(arg0, "bind", 4))
return;
if(!Q_stricmpn(arg0, "unbindall", 9))
return;
if(!Q_stricmpn(arg0, "con_showchannel", 15))
return;
Com_Printf("Bad command or cvar: %s\n", arg0);
}
