Descent3/mac/MACGAMESPY.CPP

/*
 * $Logfile: /DescentIII/Main/mac/MACGAMESPY.CPP $
 * $Revision: 1.1.1.1 $
 * $Date: 2003/08/26 03:58:15 $
 * $Author: kevinb $
 *
 * Gamespy client code
 * This library knows about the game and is responsible for telling the
 * gamespy client and server about everything it wants to know
 *	
 *
 * $Log: MACGAMESPY.CPP,v $
 * Revision 1.1.1.1  2003/08/26 03:58:15  kevinb
 * initial 1.5 import
 *
 * 
 * 2     10/21/99 1:55p Kevin
 * Mac Merge!
 * 
 * 1     7/28/99 2:31p Kevin
 * Mac only stuff
 * 
 * 
 * 
 * $NoKeywords: $
*/
#include "pstypes.h"
#include "pserror.h"
#include "player.h"
#include "multi.h"
#include "networking.h"
#include "descent.h"
#include "ddio.h"
#include "args.h"
#include "CFILE.H"
#include "program.h"
#include <stdlib.h>
#include <memory.h>
#include "gamespyutils.h"
#include "gamespy.h"
#ifdef FIXED
extern short Multi_kills[MAX_NET_PLAYERS];
extern short Multi_deaths[MAX_NET_PLAYERS];
//Secret code... encrypted using some really high tech method...
char gspy_d3_secret[10];// = "feWh2G";
const char origstring[] = {(const char)0x50,(const char)0xf8,(const char)0xa4,(const char)0xba,(const char)0xc7,(const char)0x7c};
char gspy_cfgfilename[_MAX_PATH];
#define MAX_GAMESPY_SERVERS	5
#define MAX_GAMESPY_BUFFER	1400
#define MAX_HOSTNAMELEN	300
#define GSPY_HEARBEAT_INTERVAL	300			//Seconds between heartbeats.
#define GAMESPY_PORT	27900
#define GAMESPY_LISTENPORT	20142
#define THISGAMENAME	"descent3"
#ifdef DEMO
#define THISGAMEVER		"Demo2"
#elif defined(OEM)
#define THISGAMEVER		"OEM"
#else
#define THISGAMEVER	"Retail"
#endif
SOCKET gspy_socket;
SOCKADDR_IN	gspy_server[MAX_GAMESPY_SERVERS];
extern ushort Gameport;
int gspy_region = 0;
char gspy_outgoingbuffer[MAX_GAMESPY_BUFFER] = "";
float gspy_last_heartbeat;
bool gspy_game_running = false;
int gspy_packetnumber = 0;
int gspy_queryid = 0;
char gspy_validate[MAX_GAMESPY_BUFFER] = "";
unsigned short gspy_listenport;
#endif	// FIXED
//Register a game with this library so we will tell the servers about it...
void gspy_StartGame(char *name)
{
#ifdef FIXED
	gspy_last_heartbeat = timer_GetTime()-GSPY_HEARBEAT_INTERVAL;
	gspy_game_running = true;
#endif	// FIXED
}
// Let the servers know that the game is over
void gspy_EndGame()
{
#ifdef FIXED
	gspy_game_running = false;
#endif	// FIXED
}
//Initialize gamespy with the info we need to talk to the servers
int gspy_Init(void)
{
#ifdef FIXED
#ifndef OEM	
	char cfgpath[_MAX_PATH*2];
	int argnum = FindArg("-gspyfile");
	if(argnum)
	{
		strcpy(gspy_cfgfilename,GameArgs[argnum+1]);
	}
	else
	{
		strcpy(gspy_cfgfilename,"gamespy.cfg");
	}
	
	for(int a=0;a<MAX_GAMESPY_SERVERS;a++)
	{
		//gspy_server[a].sin_addr.S_un.S_addr = INADDR_NONE;
		INADDR_SET_SUN_SADDR(&gspy_server[a].sin_addr,INADDR_NONE);
		gspy_server[a].sin_port = htons(GAMESPY_PORT);
		gspy_server[a].sin_family = AF_INET;
	}
	unsigned char keychars[] = {0x36,0x9d,0xf3,0xd2,0xf5,0x3b,0x42,0xcc,0x58};
	for(int i=0;i<6;i++)
	{
		gspy_d3_secret[i] = (char)(origstring[i] ^ keychars[i]);		
	}
	gspy_d3_secret[6] = NULL;
	gspy_d3_secret[7] = NULL;
	
	//strcpy(gspy_d3_secret,"feWh2G\0\0");
	//Read the config, resolve the name if needed and setup the server addresses
	ddio_MakePath(cfgpath,Base_directory,gspy_cfgfilename,NULL);
	
	gspy_socket = socket( AF_INET, SOCK_DGRAM,IPPROTO_UDP);;
	if(SOCKET_ERROR == gspy_socket)
	{
		int lerror = WSAGetLastError();
		mprintf((0,"Unable to init gamespy socket! (%d)\n",lerror));
		return 0;
	}
	SOCKADDR_IN sock_addr;
	memset(&sock_addr,0,sizeof(SOCKADDR_IN));
	sock_addr.sin_family = AF_INET; 
	
	unsigned int my_ip;
	
	my_ip = nw_GetThisIP();
	memcpy(&sock_addr.sin_addr.s_addr,&my_ip,sizeof(uint));
	int portarg = FindArg("-gamespyport");
	if(portarg)
	{
		gspy_listenport = htons(atoi(GameArgs[portarg+1]));
	}
	else
	{
		gspy_listenport = htons(GAMESPY_LISTENPORT);
	}
	mprintf((0,"Using port %d for gamespy requests.\n",GAMESPY_LISTENPORT));
	sock_addr.sin_port = gspy_listenport;
	if ( bind(gspy_socket, (SOCKADDR*)&sock_addr, sizeof (sock_addr)) == SOCKET_ERROR)
	{	
		mprintf((0,"Couldn't bind gamespy socket (%d)!\n", WSAGetLastError() )); 				
		return 0;
	}
	int error;
	unsigned long arg;
	arg = TRUE;
	//make the socket non blocking
#ifdef WIN32
	error = ioctlsocket( gspy_socket, FIONBIO, &arg );
#elif defined(__LINUX__)
	error = ioctl(gspy_socket,FIONBIO,&arg);
#endif
	CFILE *cfp = cfopen(cfgpath,"rt");
	if(cfp)
	{
		mprintf((0,"Found a gamespy config file!\n"));
		char hostn[MAX_HOSTNAMELEN];
		
				
		for(int i=0;i<MAX_GAMESPY_SERVERS;i++)
		{
			
			//First in the config file is the region, which is a number from 0-12 (currently)
			if(cf_ReadString(hostn,MAX_HOSTNAMELEN-1,cfp))
			{
				gspy_region = atoi(hostn);
			}
			//next in the config file are the servers
			//Each gamespy server should appear in the file with the hostname:port
			//Or optionally, just the hostname
			//Examples:
			//192.168.1.100:27900
			//master01.gamespy.com:27900
			//master02.gamespy.com
			//192.168.1.100
			
			if(cf_ReadString(hostn,MAX_HOSTNAMELEN-1,cfp))
			{
				char *port = strstr(hostn,":");
				if(port)
				{
					//terminate the hostname
					*port = NULL;
					//Increment to the first character of the port name
					port++;					
					//get the port number
					gspy_server[i].sin_port = htons(atoi(port));
				}
				if(INADDR_NONE==inet_addr(hostn))
				{
					//This is a name we must resolve
					HOSTENT *he;
					mprintf((0,"Resolving hostname for gamespy: %s\n",hostn));
					he = gethostbyname(hostn);
					if(!he)
					{
						mprintf((0,"Unable to resolve %s\n",hostn));
						//gspy_server[i].sin_addr.S_un.S_addr = INADDR_NONE;
						INADDR_SET_SUN_SADDR(&gspy_server[i].sin_addr,INADDR_NONE);
					}
					else
					{
						//memcpy(&gspy_server[i].sin_addr.S_un.S_addr,he->h_addr_list[0],sizeof(unsigned int));
						memcpy(&gspy_server[i].sin_addr,he->h_addr_list[0],sizeof(unsigned int));
					}
				}
				else
				{
					//This is just a number
					//gspy_server[i].sin_addr.S_un.S_addr = inet_addr(hostn);
					INADDR_SET_SUN_SADDR(&gspy_server[i].sin_addr,inet_addr(hostn));
					//break;
				}
			}
			#if defined(WIN32)
			if(gspy_server[i].sin_addr.S_un.S_addr != INADDR_NONE)
			{
				mprintf((0,"Sending gamespy heartbeats to %s:%d\n",inet_ntoa(gspy_server[i].sin_addr),htons(gspy_server[i].sin_port)));
			}
			#elif defined(__LINUX__)
			if(gspy_server[i].sin_addr.s_addr != INADDR_NONE)
			{
				mprintf((0,"Sending gamespy heartbeats to %s:%d\n",inet_ntoa(gspy_server[i].sin_addr),htons(gspy_server[i].sin_port)));
			}
			#endif
		}		
	}
#endif
#endif	// FIXED
	return 1;
}
//Takes a gspy response and puts the appropriate validation code to the end
//Of the string. If crypt is something besides NULL, create and tack the proper 
//response to the end
#define VALIDATE_SIZE 6
bool gpsy_ValidateString(char *str,char *crypt)
{
#ifdef FIXED
	
	char keyvalue[80];
	unsigned char encrypted_val[VALIDATE_SIZE]; //don't need to num terminate
	unsigned char encoded_val[(VALIDATE_SIZE * 4) / 3 + 1];
		
	if(crypt)
	{
		strcpy((char *)encrypted_val,crypt);
		gspy_encrypt(encrypted_val,VALIDATE_SIZE, (unsigned char *)gspy_d3_secret);
		gspy_encode(encrypted_val,VALIDATE_SIZE, (unsigned char *)encoded_val);
		sprintf(keyvalue,"\\validate\\%s",encoded_val);
		strcat(str,keyvalue);
	}
	sprintf(keyvalue,"\\final\\");
	strcat(str,keyvalue);
#endif	// FIXED
	return false;
}
//Check the socket for data, and respond properly if needed
//Also send heartbeat when needed
void gspy_DoFrame()
{
#ifdef FIXED
#ifndef OEM
	SOCKADDR_IN fromaddr;
	int bytesin;
	int fromsize = sizeof(SOCKADDR_IN);
	char inbuffer[MAX_GAMESPY_BUFFER];
	
	
	if(!gspy_game_running)
		return;
	//If it's time, send the heartbeat
	if((timer_GetTime()-gspy_last_heartbeat)>GSPY_HEARBEAT_INTERVAL)
	{
		for(int a=0;a<MAX_GAMESPY_SERVERS;a++)
		{
			#if defined(WIN32)
			if(INADDR_NONE!=gspy_server[a].sin_addr.S_un.S_addr)
			{
				mprintf((0,"Sending heartbeat to %s:%d\n",inet_ntoa(gspy_server[a].sin_addr),htons(gspy_server[a].sin_port)));
				gspy_DoHeartbeat(&gspy_server[a]);
			}
			#elif defined(__LINUX__)
			if(INADDR_NONE!=gspy_server[a].sin_addr.s_addr)
			{
				mprintf((0,"Sending heartbeat to %s:%d\n",inet_ntoa(gspy_server[a].sin_addr),htons(gspy_server[a].sin_port)));
				gspy_DoHeartbeat(&gspy_server[a]);
			}
			#endif
		}
		gspy_last_heartbeat = timer_GetTime();
	}
	//Look for incoming network data
	do
	{
		bytesin = recvfrom(gspy_socket,inbuffer,MAX_GAMESPY_BUFFER,0,(SOCKADDR *)&fromaddr,&fromsize);
		if(bytesin > 0)
		{
			*(inbuffer+bytesin) = NULL;
			mprintf((0,"Got a gamespy request:\n%s\n",inbuffer));
			gspy_ParseReq(inbuffer,&fromaddr);
		}
		else if(bytesin == SOCKET_ERROR)
		{
			int lerror = WSAGetLastError();
			if(lerror != WSAEWOULDBLOCK)
			{
				mprintf((0,"Warning: recvfrom failed for gamespy! (%d)\n",lerror));				
			}
		}
	}while(bytesin > 0);
#endif
#endif	// FIXED
}
//Sends the packet out to whoever it is that we are sending to
int gspy_SendPacket(SOCKADDR_IN *addr)
{
#ifdef FIXED
	gspy_packetnumber++; //packet numbers start at 1
	char keyvalue[80];
	if(!*gspy_outgoingbuffer)
	{
		//It's an empty buffer, so don't send anything!!
		return 0;
	}
	gpsy_ValidateString(gspy_outgoingbuffer,*gspy_validate?gspy_validate:NULL);
	sprintf(keyvalue,"\\queryid\\%d.%d",gspy_queryid, gspy_packetnumber);
	strcat(gspy_outgoingbuffer,keyvalue);
	
	mprintf((0,"GSPYOUT:%s\n",gspy_outgoingbuffer));
	sendto(gspy_socket,gspy_outgoingbuffer,strlen(gspy_outgoingbuffer)+1,0,(SOCKADDR *)addr,sizeof(SOCKADDR_IN));
	*gspy_outgoingbuffer = NULL;
#endif	// FIXED
	return 0;
}
//Adds some values\keys to the send buffer and sends the packet if it overflows
int gspy_AddToBuffer(SOCKADDR_IN *addr,char *addstr)
{
#ifdef FIXED
	if(strlen(gspy_outgoingbuffer)+strlen(addstr)+50>=MAX_GAMESPY_BUFFER+1)
	{
		//package up this response and send this packet
		gspy_SendPacket(addr);
		
	}
	else
	{
		strcat(gspy_outgoingbuffer,addstr);
	}
#endif	// FIXED
	return 1;
}
//Looks for the secure key in the request and returns it if there is. If there isn't, it returns a NULL
char * gspy_GetSecure(char * req)
{
#ifdef FIXED
	char *tokp;
	char str[MAX_GAMESPY_BUFFER];
	strcpy(str,req);
	tokp = strtok(str,"\\");
	if(tokp)
	{
		while(tokp)
		{
			if(strcmpi(tokp,"secure")==0)
			{
				tokp = strtok(NULL,"\\");
				return tokp;
			}
			tokp = strtok(NULL,"\\");
		};
		return NULL;
	}
	else
	{
		return NULL;
	}
#endif	// FIXED
	return NULL;
}
int gspy_ContainsKey(char *buffer,char *key)
{
#ifdef FIXED
	char str[MAX_GAMESPY_BUFFER];
	char lowkey[MAX_GAMESPY_BUFFER];
	strcpy(str,buffer);
	int len = strlen(str);
	int i;
	//If it's an empty string return 0
	if(*buffer=='\0')
		return 0;
	for(i=0;i<len;i++) tolower(str[i]);
	strcpy(lowkey,key);
	len = strlen(str);
	for(i=0;i<len;i++) tolower(lowkey[i]);
	if(strstr(str,lowkey))
	{
		return 1;
	}
	else
	{
		return 0;
	}
#endif	// FIXED
}
int gspy_ParseReq(char *buffer,SOCKADDR_IN *addr)
{
#ifdef FIXED
	gspy_packetnumber=0;
	gspy_queryid++;
	char *validate = gspy_GetSecure(buffer);
	if(validate)
	{
		strcpy(gspy_validate,validate);
	}
	else
	{
		*gspy_validate=0;
	}
	if(gspy_ContainsKey(buffer,"basic"))
	{
		//Send basic
		gspy_DoBasic(addr);
	}
	if(gspy_ContainsKey(buffer,"info"))
	{
		//Send info
		gspy_DoGameInfo(addr);
	}
	if(gspy_ContainsKey(buffer,"rules"))
	{
		//Send rules
		gspy_DoRules(addr);
	}
	if(gspy_ContainsKey(buffer,"players"))
	{
		//Send players
		gspy_DoPlayers(addr);
	}
	if(gspy_ContainsKey(buffer,"status"))
	{
		//Send status
		gspy_DoStatus(addr);
	}
	if(gspy_ContainsKey(buffer,"echo"))
	{
		//Send echo
		gspy_DoEcho(addr,buffer);
	}
	
	gspy_SendPacket(addr);
#endif	// FIXED
	return 0;
}
int gspy_DoEcho(SOCKADDR_IN *addr,char *msg)
{
#ifdef FIXED
	char buf[MAX_GAMESPY_BUFFER];
	
	//All this is needed in case an echo packet was embedded with other stuff
	strcpy(buf,msg);
	char * p = strstr(buf,"\\echo\\");
	if(!p)
	{
		mprintf((0,"Couldn't find echo keyword in gamespy query, this is a wacky bug that should never happen!\n"));
		Int3();
		return 0;
	}
		
	//send back the string!
	gspy_AddToBuffer(addr,p);
#endif	// FIXED
	return 0;
}
int gspy_DoBasic(SOCKADDR_IN *addr)
{
#ifdef FIXED
	char buf[MAX_GAMESPY_BUFFER];
	
	sprintf(buf,"\\gamename\\%s",THISGAMENAME);
	gspy_AddToBuffer(addr,buf);
	//sprintf(buf,"\\gamever\\%d.%d",Program_version.major,Program_version.minor);
	sprintf(buf,"\\gamever\\%s %.1d.%.1d.%.1d",THISGAMEVER,Program_version.major,Program_version.minor,Program_version.build);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\location\\%d",gspy_region);
	gspy_AddToBuffer(addr,buf);
	
#endif	// FIXED
	return 0;
}
int gspy_DoStatus(SOCKADDR_IN *addr)
{
#ifdef FIXED
	gspy_DoBasic(addr);
	gspy_DoGameInfo(addr);
	gspy_DoRules(addr);
	gspy_DoPlayers(addr);
#endif	// FIXED
	return 0;
} 
int gspy_DoRules(SOCKADDR_IN *addr)
{
#ifdef FIXED
	char buf[MAX_GAMESPY_BUFFER];
	
	sprintf(buf,"\\teamplay\\%d",Num_teams);
	gspy_AddToBuffer(addr,buf);
	
	sprintf(buf,"\\timelimit\\%d",(Netgame.flags&NF_TIMER)?0:Netgame.timelimit);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\fraglimit\\%d",(Netgame.flags&NF_KILLGOAL)?0:Netgame.killgoal);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\cl_pxotrack\\%d",Game_is_master_tracker_game);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\mouselook\\%d",(Netgame.flags&NF_ALLOW_MLOOK)?1:0);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\permissable\\%d",(Netgame.flags&NF_PERMISSABLE)?1:0);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\brightships\\%d",(Netgame.flags&NF_BRIGHT_PLAYERS)?1:0);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\acccollisions\\%d",(Netgame.flags&NF_USE_ACC_WEAP)?1:0);
	gspy_AddToBuffer(addr,buf);
	
	sprintf(buf,"\\randpowerup\\%d",(Netgame.flags&NF_RANDOMIZE_RESPAWN)?1:0);
	gspy_AddToBuffer(addr,buf);
#endif	// FIXED
	return 0;
}
//Send the player list to whoever wants it.
int gspy_DoPlayers(SOCKADDR_IN *addr)
{
#ifdef FIXED
	char buf[MAX_GAMESPY_BUFFER];
	int player_count = 0;
	for(int i=0;i<MAX_NET_PLAYERS;i++)
	{
		if(NetPlayers[i].flags & NPF_CONNECTED)
		{
			sprintf(buf,"\\player_%d\\%s",player_count,Players[i].callsign);
			gspy_AddToBuffer(addr,buf);
			sprintf(buf,"\\frags_%d\\%d",player_count,Multi_kills[i]);
			gspy_AddToBuffer(addr,buf);
			sprintf(buf,"\\deaths_%d\\%d",player_count,Multi_deaths[i]);
			gspy_AddToBuffer(addr,buf);
			sprintf(buf,"\\team_%d\\%d",player_count,Players[i].team);
			gspy_AddToBuffer(addr,buf);
			sprintf(buf,"\\ping_%d\\%.0f",player_count,(NetPlayers[i].ping_time*1000.0));
			gspy_AddToBuffer(addr,buf);
			
			player_count++;
		}
	}
#endif	// FIXED
	return 0;
}
int gspy_DoGameInfo(SOCKADDR_IN *addr)
{
#ifdef FIXED
	char buf[MAX_GAMESPY_BUFFER];
	int curplayers=0;
	for(int i=0;i<MAX_NET_PLAYERS;i++)
	{
		if(NetPlayers[i].flags & NPF_CONNECTED)
			curplayers++;
	}
	
	
	sprintf(buf,"\\hostname\\%s",Netgame.name);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\hostport\\%d",Gameport);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\mapname\\%s",Netgame.mission);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\gametype\\%s",Netgame.scriptname);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\numplayers\\%d",curplayers);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\maxplayers\\%d",Netgame.max_players);
	gspy_AddToBuffer(addr,buf);
	sprintf(buf,"\\gamemode\\%s","openplaying");
	gspy_AddToBuffer(addr,buf);
#endif	// FIXED
	return 0;
}
int gspy_DoHeartbeat(SOCKADDR_IN *addr)
{
#ifdef FIXED
	char buf[MAX_GAMESPY_BUFFER];
	sprintf(buf,"\\heartbeat\\%d\\gamename\\%s",htons(gspy_listenport),THISGAMENAME);
	mprintf((0,"GSPYOUT:%s\n",buf));
	sendto(gspy_socket,buf,strlen(buf)+1,0,(SOCKADDR *)addr,sizeof(SOCKADDR_IN));
#endif	// FIXED
	return 0;
}