initial importHEADmain

1 files changed, 1544 insertions, 0 deletions

diff --git a/src/parsec_server/e_packethandler.cpp b/src/parsec_server/e_packethandler.cpp
new file mode 100755
index 0000000..29cd315
--- /dev/null
+++ b/src/parsec_server/e_packethandler.cpp
@@ -0,0 +1,1544 @@
+/*
+ * PARSEC - Packet handler
+ *
+ * $Author: uberlinuxguy $ - $Date: 2004/09/26 03:43:46 $
+ *
+ * Orginally written by:
+ *   Copyright (c) Clemens Beer        <cbx@parsec.org>   2001-2003
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */ 
+
+// C library
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <vector>
+
+// compilation flags/debug support
+#include "config.h"
+#include "debug.h"
+
+// general definitions
+#include "general.h"
+#include "objstruc.h"
+
+// global externals
+#include "globals.h"
+
+// subsystem headers
+#include "net_defs.h"
+
+// UNP header
+#include "net_wrap.h"
+
+// mathematics header
+#include "utl_math.h"
+
+// subsystem & server headers 
+#include "net_defs.h"
+#include "e_defs.h"
+#include "e_global_sv.h"
+#include "sys_defs.h"
+
+// network code config
+#include "net_conf.h"
+
+// net game header
+#include "net_game_sv.h"
+
+// local module header
+#include "e_packethandler.h"
+
+// SYS subsystem
+
+// proprietary module headers
+#include "con_aux_sv.h"
+#include "net_csdf.h"
+#include "net_packetdriver.h"
+#include "net_udpdriver.h"
+#include "net_stream.h"
+#include "e_simplayerinfo.h"
+#include "e_simnetinput.h"
+#include "g_main_sv.h"
+#include "e_connmanager.h"
+#include "e_gameserver.h"
+#include "e_relist.h"
+#include "e_simulator.h"
+#include "MasterServer.h"
+
+// ----------------------------------------------------------------------------
+// public methods
+// ----------------------------------------------------------------------------
+
+// handle the content of a packet received ------------------------------------
+//
+void E_PacketHandler::HandlePacket( PacketChainBlock* block )
+{
+	ASSERT( block != NULL );
+
+	NetPacket_GMSV*	gamepacket	= block->gamepacket;
+	int				nSenderID   = gamepacket->SendPlayerId;
+	int				bufid		= block->bufferno;
+	
+	UPDTXT2(MSGOUT( "e_PacketHandler::HandlePacket(): command:%d", gamepacket->Command ));
+
+	// check for senderid spoofing
+	if ( !_IsLegitSender( gamepacket, bufid ) ) {
+		return;
+	}
+	
+	// if we are a Master server, process packets a bit differently
+	if(TheServer->GetServerIsMaster()){
+		// TODO: Process Master Server Packets
+		switch( gamepacket->Command ) {
+			case PKTP_COMMAND:
+
+
+				/*if ( nSenderID == PLAYERID_MASTERSERVER ) {
+
+					// Hmmmm... PLAYERID_MASTERSERVER is us.. we shouldn't
+					// be sending packets to ourselves....  log an error
+					// and return
+					MSGOUT("e_PacketHandler::HandlePacket(): We sent ourselves a packet?! I think *not*!!!");
+					return;
+
+				} else {*/
+
+					// handle a command packet from a client
+					_Handle_COMMAND_MASTER( gamepacket, bufid );
+				//}
+
+
+				break;
+			case PKTP_STREAM:
+				if ( nSenderID == PLAYERID_MASTERSERVER ) {
+
+					// Hmmmm... PLAYERID_MASTERSERVER is us.. we shouldn't
+					// be sending packets to ourselves....  log an error
+					// and return
+					MSGOUT("e_PacketHandler::HandlePacket(): We sent ourselves a packet?! I think *not*!!!");
+					return;
+
+				} else {
+
+					// handle a command packet from a client
+					_Handle_STREAM_MASTER( gamepacket, bufid );
+				}
+
+				break;
+
+			default:
+				MSGOUT("Curious Packet Received: %d", gamepacket->Command);
+				break;
+		}
+		// return to do no further processing.
+		return;
+	}
+
+	// perform action according to packet type
+	switch( gamepacket->Command ) {
+		
+			// these must not be received
+		case PKTP_CONNECT:
+		case PKTP_CONNECT_REPLY:
+		case PKTP_DISCONNECT:
+		case PKTP_SLOT_REQUEST:
+		case PKTP_SUBDUE_SLAVE:
+			DBGTXT( MSGOUT( "e_PacketHandler::HandlePacket: received PEER-only packet ( command: %d )", gamepacket->Command ); );
+			
+			//NOTE:
+			// these should be ignored transparently since somebody
+			// might try to connect peer-to-peer on the same
+			// segment 
+			
+			//			ASSERT( 0 );
+			break;
+
+		case PKTP_JOIN:
+		case PKTP_UNJOIN:
+		case PKTP_GAME_STATE:
+		case PKTP_NODE_ALIVE:
+			//NOTE: legacy packet - removed in new GameServer ( >= build 0198 )
+			DBGTXT( MSGOUT( "e_PacketHandler::HandlePacket: received legacy packet ( command: %d )", gamepacket->Command ); );
+			break;
+
+		case PKTP_STREAM:
+			// handle all the events/proc.calls in the stream packet
+			_Handle_STREAM( gamepacket );
+			break;
+
+		case PKTP_COMMAND:
+
+			if ( nSenderID == PLAYERID_MASTERSERVER ) {
+
+				// handle a command packet from the masterserver
+				_Handle_COMMAND_MASV( gamepacket, bufid );
+
+			} else {
+
+				// handle a command packet from a client
+				_Handle_COMMAND( gamepacket, bufid );
+			}
+
+			break;
+
+		default:
+			MSGOUT( "gameloop: received packet of unknown type: %d.", gamepacket->Command );
+			ASSERT( 0 );
+	}
+}
+
+// notify a client that another client connected ------------------------------
+//
+void E_PacketHandler::SendNotifyConnected( int nDestSlot, int nClientSlot )
+{
+	// get the client information for the client, we want to inform
+	E_ClientInfo* pDestClientInfo = TheConnManager->GetClientInfo( nDestSlot );
+	
+	// get the client information for the client, we want the destnode to inform about
+	E_ClientInfo* pAboutClientInfo = TheConnManager->GetClientInfo( nClientSlot );
+	
+	ASSERT( pDestClientInfo  != NULL );
+	ASSERT( pAboutClientInfo != NULL );
+
+	ASSERT( !pDestClientInfo->IsSlotFree() );
+	
+	// we do not notify the client about himself
+	if ( NODE_Compare( &pAboutClientInfo->m_node, &pDestClientInfo->m_node ) == NODECMP_EQUAL ) {
+		ASSERT( FALSE );
+		return;
+	}
+
+	// prepare the command string
+	char sendline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	snprintf( sendline, sizeof( sendline ), LISTSTR_ADDED_IN_SLOT, nClientSlot, pAboutClientInfo->m_szName );
+	
+	// send the server command ( RELIABLE )
+	Send_COMMAND( sendline, &pDestClientInfo->m_node, nDestSlot, TRUE );
+}
+
+// notify a client that another client is disconnected ------------------------
+//
+void E_PacketHandler::SendNotifyDisconnected( int nDestSlot, int nClientSlot )
+{
+	// get the client information for the client, we want to inform
+	E_ClientInfo* pDestClientInfo = TheConnManager->GetClientInfo( nDestSlot );
+	
+	// get the client information for the client, we want the destnode to inform about
+	E_ClientInfo* pAboutClientInfo = TheConnManager->GetClientInfo( nClientSlot );
+	
+	ASSERT( pDestClientInfo  != NULL );
+	ASSERT( pAboutClientInfo != NULL );
+
+	ASSERT( !pDestClientInfo->IsSlotFree() );
+	
+	// we do not notify the client about himself
+	if ( NODE_Compare( &pAboutClientInfo->m_node, &pDestClientInfo->m_node ) == NODECMP_EQUAL ) {
+		ASSERT( FALSE );
+		return;
+	}
+	
+	// prepare the command string
+	char sendline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	snprintf( sendline, sizeof(sendline), LISTSTR_REMOVED_FROM_SLOT, nClientSlot );
+
+	// send the server command ( RELIABLE )
+	Send_COMMAND( sendline, &pDestClientInfo->m_node, nDestSlot, TRUE );
+}
+
+// notify a client that another client's name changed -------------------------
+//
+void E_PacketHandler::SendNotifyNameChange( int nDestSlot, int nClientSlot )
+{
+	// get the client information for the client, we want to inform
+	E_ClientInfo* pDestClientInfo = TheConnManager->GetClientInfo( nDestSlot );
+	
+	// get the client information for the client, we want the destnode to inform about
+	E_ClientInfo* pAboutClientInfo = TheConnManager->GetClientInfo( nClientSlot );
+	
+	ASSERT( pDestClientInfo  != NULL );
+	ASSERT( pAboutClientInfo != NULL );
+	
+	// we do not notify the client about himself
+	if ( NODE_Compare( &pAboutClientInfo->m_node, &pDestClientInfo->m_node ) == NODECMP_EQUAL ) {
+		ASSERT( FALSE );
+		return;
+	}
+	
+	// prepare the command string
+	char sendline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	snprintf( sendline, sizeof(sendline), LISTSTR_NAME_UPDATED, nClientSlot, pAboutClientInfo->m_szName );
+	
+	// send the server command ( RELIABLE )
+	Send_COMMAND( sendline, &pDestClientInfo->m_node, nDestSlot, TRUE );
+}
+
+
+// send a challenge response back to a client ---------------------------------
+//
+void E_PacketHandler::SendChallengeResponse( E_ClientChallengeInfo* pChallengeInfo, node_t* clientnode )
+{
+	ASSERT( pChallengeInfo != NULL );
+	ASSERT( clientnode     != NULL );
+	
+	// prepare response
+	char sendline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	snprintf( sendline, sizeof(sendline), RECVSTR_CHALLENGE, pChallengeInfo->m_challenge );
+	
+	// send response datagram
+	Send_COMMAND_Datagram( sendline, clientnode, PLAYERID_ANONYMOUS );
+}
+
+// send a connect response back to a client -----------------------------------
+//
+int E_PacketHandler::SendConnectResponse( E_ConnManager::ConnResults rc, E_ClientConnectInfo* pClientConnectInfo )
+{
+	ASSERT( rc >= E_ConnManager::CONN_CHALLENGE_INVALID );
+	ASSERT( rc <= E_ConnManager::CONN_OK );
+	ASSERT( pClientConnectInfo != NULL );
+	
+	char sendline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	
+	// prepare correct response command
+	switch( rc ) {
+		case E_ConnManager::CONN_CHALLENGE_INVALID:
+			ASSERT( pClientConnectInfo->m_selected_slot == -1 );
+			snprintf( sendline, sizeof(sendline), RECVSTR_CHALL_INVALID );
+			break;
+		case E_ConnManager::CONN_CLIENT_INCOMAPTIBLE:
+			ASSERT( pClientConnectInfo->m_selected_slot == -1 );
+			snprintf( sendline, sizeof(sendline), RECVSTR_SERVER_INCOMP );
+			break;
+		case E_ConnManager::CONN_CLIENT_BANNED:
+			ASSERT( pClientConnectInfo->m_selected_slot == -1 );
+			snprintf( sendline, sizeof(sendline), RECVSTR_CLIENT_BANNED );
+			break;
+		case E_ConnManager::CONN_SERVER_FULL:
+			ASSERT( pClientConnectInfo->m_selected_slot == -1 );
+			snprintf( sendline, sizeof(sendline), RECVSTR_SERVER_FULL );
+			break;
+		case E_ConnManager::CONN_NAME_TAKEN:
+			ASSERT( pClientConnectInfo->m_selected_slot == -1 );
+			snprintf( sendline, sizeof(sendline), RECVSTR_NAME_INVALID );
+			break;
+		case E_ConnManager::CONN_OK:
+			ASSERT( pClientConnectInfo->m_selected_slot != -1 );
+			
+			//FIXME: check whether IP/port is necessary in the connect reply packet
+			//FIXME: NebulaID and other worldstate should be sent as a sync burst at the beginning
+			snprintf( sendline, sizeof(sendline), RECVSTR_ACCEPTED, 
+				pClientConnectInfo->m_szHostName, 
+				NODE_GetPort( &pClientConnectInfo->m_node ),
+				pClientConnectInfo->m_selected_slot, 
+				MAX_NUM_CLIENTS,	//FIXME: remove this ????
+				SV_SERVERID,
+				TheServer->GetServerName()		//FIXME: remove this ????
+				);
+
+			break;
+		default:
+			ASSERT( FALSE );
+			return FALSE;
+	}
+	
+	// ensure proper destination id ( PLAYERID_ANONYMOUS on connection refused )
+	int nClientID = ( pClientConnectInfo->m_selected_slot == -1 ) ? PLAYERID_ANONYMOUS : pClientConnectInfo->m_selected_slot;
+
+	// send response datagram
+	Send_COMMAND_Datagram( sendline, &pClientConnectInfo->m_node, nClientID );
+
+	return TRUE;
+}
+
+// send a disconnect request response ------------------------------------------
+//
+int E_PacketHandler::SendDisconnectResponse( E_ConnManager::DisconnResults rc, node_t* clientnode, int nClientID )
+{
+	ASSERT( rc >= E_ConnManager::DISC_NOT_CONNECTED );
+	ASSERT( rc <= E_ConnManager::DISC_OK );
+	ASSERT( ( ( nClientID >= 0 ) && ( nClientID <= MAX_NET_ALLOC_SLOTS ) ) || ( nClientID == PLAYERID_ANONYMOUS ) );
+	ASSERT( clientnode != NULL );
+	
+	char sendline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	
+	// prepare correct response command
+	switch( rc ) {
+		case E_ConnManager::DISC_NOT_CONNECTED:
+			snprintf( sendline, sizeof(sendline), RECVSTR_NOT_CONNECTED );
+			break;
+		case E_ConnManager::DISC_OK:
+			snprintf( sendline, sizeof(sendline), RECVSTR_REMOVE_OK );
+			break;
+		default:
+			ASSERT( FALSE );
+			return FALSE;
+	}
+
+	// flush any pending NACK reliable 
+	ThePacketDriver->FlushReliableBuffer( nClientID );
+	
+	// send response ( UNRELIABLE ) 
+	//NOTE: disconnect response is not sent reliable, if packet is lost, client gets a "NOT CONNECTED" reply upon next try
+	Send_COMMAND( sendline, clientnode, nClientID, FALSE );
+	
+	return TRUE;
+}
+
+// send a namechange response back to the client ------------------------------
+//
+int E_PacketHandler::SendNameChangeRepsponse( E_ConnManager::NameChangeResults rc, node_t* clientnode, int nClientID )
+{
+	ASSERT( rc >= E_ConnManager::NAMECHANGE_NOT_CONNECTED );
+	ASSERT( rc <= E_ConnManager::NAMECHANGE_OK );
+	ASSERT( ( nClientID >= 0 ) && ( nClientID <= MAX_NET_ALLOC_SLOTS ) );
+	ASSERT( clientnode != NULL );
+	
+	char sendline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	
+	// prepare correct response command
+	switch( rc ) {
+		case E_ConnManager::NAMECHANGE_NOT_CONNECTED:
+			snprintf( sendline, sizeof(sendline), RECVSTR_NOT_CONNECTED );
+			break;
+		case E_ConnManager::NAMECHANGE_ALREADY_TAKEN:
+			snprintf( sendline, sizeof(sendline), RECVSTR_NAME_INVALID );
+			break;
+		case E_ConnManager::NAMECHANGE_OK:
+			snprintf( sendline, sizeof(sendline), RECVSTR_NAME_OK );
+			break;
+		default:
+			ASSERT( FALSE );
+			return FALSE;
+	}
+	
+	// send response ( RELIABLE )
+	Send_COMMAND( sendline, clientnode, nClientID, TRUE );
+
+	return TRUE;
+}
+
+// send a INFO response back to the client ------------------------------------
+// 
+int E_PacketHandler::SendInfoResponse( refframe_t client_ping_send_frame, node_t* clientnode, int nClientID )
+{
+	ASSERT( ( ( nClientID >= 0 ) && ( nClientID <= MAX_NET_ALLOC_SLOTS ) ) || ( nClientID == PLAYERID_ANONYMOUS ) );
+	ASSERT( clientnode != NULL );
+	
+	E_REList* pUnreliable = E_REList::CreateAndAddRef( RE_LIST_MAXAVAIL );
+
+	// prepare the command string
+	char szBuffer[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	snprintf( szBuffer, MAX_RE_COMMANDINFO_COMMAND_LEN, 
+				RECVSTR_INFO_REPLY,
+				SV_SERVERID,
+				(unsigned int)client_ping_send_frame,
+				TheConnManager->GetNumConnected(),
+				MAX_NUM_CLIENTS,
+				CLSV_PROTOCOL_MAJOR, CLSV_PROTOCOL_MINOR,
+				TheServer->GetServerName()
+			);
+
+	// append a remote event containing the command
+	int rc = pUnreliable->NET_Append_RE_CommandInfo( szBuffer );
+	ASSERT( rc == TRUE );
+
+	// send a datagram
+	ThePacketHandler->Send_STREAM_Datagram( pUnreliable, clientnode, nClientID );
+
+	// release the RE list from here
+	pUnreliable->Release();
+
+	return TRUE;
+}
+
+
+// send a PING response back to the client ------------------------------------
+//
+int E_PacketHandler::SendPingResponse( refframe_t client_ping_send_frame, node_t* clientnode, int nClientID )
+{
+	ASSERT( ( ( nClientID >= 0 ) && ( nClientID <= MAX_NET_ALLOC_SLOTS ) ) || ( nClientID == PLAYERID_ANONYMOUS ) );
+	ASSERT( clientnode != NULL );
+	
+	E_REList* pUnreliable = E_REList::CreateAndAddRef( RE_LIST_MAXAVAIL );
+
+	// prepare the command string
+	char szBuffer[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	snprintf( szBuffer, MAX_RE_COMMANDINFO_COMMAND_LEN, 
+				RECVSTR_PING_REPLY,
+				SV_SERVERID,
+				(unsigned int)client_ping_send_frame,
+				TheConnManager->GetNumConnected(),
+				MAX_NUM_CLIENTS
+			);
+
+	// append a remote event containing the command
+	int rc = pUnreliable->NET_Append_RE_CommandInfo( szBuffer );
+	ASSERT( rc == TRUE );
+
+	// send a datagram
+	ThePacketHandler->Send_STREAM_Datagram( pUnreliable, clientnode, nClientID );
+
+	// release the RE list from here
+	pUnreliable->Release();
+
+	return TRUE;
+}
+
+/*
+// store gamestate as RE_List head --------------------------------------------
+//
+RE_GameState* NET_RmEvSingleGameState( NetPacket_GMSV* gamepacket )
+{
+	ASSERT( gamepacket != NULL );
+	RE_GameState* re_gamestate = (RE_GameState*) &gamepacket->RE_List;
+	re_gamestate->RE_Type		= RE_GAMESTATE;
+	re_gamestate->RE_BlockSize	= sizeof( RE_GameState );
+
+	// fill in the server gametime
+	re_gamestate->GameTime = TheServer->GetCurGameTime();
+	
+	re_gamestate++;
+	re_gamestate->RE_Type = RE_EMPTY;
+
+	return re_gamestate;
+}
+*/
+
+// send a STREAM packet to a client -------------------------------------------
+//
+size_t E_PacketHandler::Send_STREAM( int nClientID, E_REList* pReliable, E_REList* pUnreliable )
+{
+	ASSERT( ( nClientID >= 0 ) && ( nClientID <= MAX_NUM_CLIENTS ) );	
+
+	char			buffer[ NET_MAX_NETPACKET_INTERNAL_LEN ];
+	NetPacket_GMSV*	gamepacket = (NetPacket_GMSV*) buffer;
+	
+	E_ClientInfo* pClientInfo = TheConnManager->GetClientInfo( nClientID );
+	ASSERT( pClientInfo != NULL );
+	
+	node_t* node = &pClientInfo->m_node;
+	
+	UPDTXT2( MSGOUT( "PKTP_STREAM S -> C to: %d node: %s", nClientID, NODE_Print( node ) ); );
+
+	// fill gamepacket header
+	ThePacketDriver->FillStdGameHeader( PKTP_STREAM, gamepacket );
+
+	// send the packet
+	return ThePacketDriver->SendPacket( gamepacket, node, nClientID, pReliable, pUnreliable );
+}
+
+// ----------------------------------------------------------------------------
+// protected methods
+// ----------------------------------------------------------------------------
+
+// check whether the sender node matches the node for the senderid ------------
+//
+int E_PacketHandler::_IsLegitSender( NetPacket_GMSV* gamepacket, int bufid )
+{
+	ASSERT( gamepacket != NULL );
+	
+	// identify sender
+	int senderid = gamepacket->SendPlayerId;
+	
+	if (TheServer->GetServerIsMaster() && senderid == PLAYERID_SERVER) {
+		// this is a HB packet...
+		return TRUE;
+	}
+
+	if(TheServer->GetServerIsMaster() && senderid >= 0) {
+		// this is for the master server from a client.
+		return TRUE;
+	}
+
+	// NODE_ALIVE only valid for normal clients
+	if ( ( senderid >= 0 ) && ( senderid < MAX_NUM_CLIENTS ) ) {
+		
+		// get the clientinfo
+		E_ClientInfo* pClientInfo = TheConnManager->GetClientInfo( senderid );
+		
+		// get the sending node of the packet
+		node_t* packetnode = ThePacketDriver->GetPktSender( bufid );
+		
+		// check whether someone tries to spoof the senderid
+		if ( NODE_AreSame( packetnode, &pClientInfo->m_node ) == FALSE ) {
+
+			char szBuffer1[ 128 ];
+			char szBuffer2[ 128 ];
+			strcpy( szBuffer1, NODE_Print( packetnode )           );
+			strcpy( szBuffer2, NODE_Print( &pClientInfo->m_node ) );
+			
+			MSGOUT( "Filtering spoofed packet for %d. packet from %s - should be %s.\n", 
+				senderid, 
+				szBuffer1, 
+				szBuffer2 );
+			
+			//FIXME: check whether clients behind firewalls keep the same node ( ports might get remapped )
+			return FALSE ;
+		} 
+	} else if ( senderid == PLAYERID_MASTERSERVER ) {
+
+		// get the sending node of the packet
+		node_t* packetnode = ThePacketDriver->GetPktSender( bufid );
+		if ( !TheServer->IsMasterServerNode( packetnode ) ) {
+			MSGOUT( "Filtering spoofed packet. claims to be from masterserver - is from %s.\n", NODE_Print( packetnode ) );
+			return FALSE ;
+		}
+	}
+	
+	return TRUE;
+}
+
+
+// send a datagram to a node --------------------------------------------------
+//
+int E_PacketHandler::Send_STREAM_Datagram( E_REList* pUnreliable, node_t* node, int nClientID )
+{
+	ASSERT( pUnreliable != NULL );
+	ASSERT( node != NULL );
+	ASSERT( ( nClientID == PLAYERID_MASTERSERVER ) || ( nClientID == PLAYERID_ANONYMOUS ) || ( ( nClientID >= 0 ) && ( nClientID < MAX_NUM_CLIENTS ) ) );
+
+	char			buffer[ NET_MAX_NETPACKET_INTERNAL_LEN ];
+	NetPacket_GMSV*	gamepacket = (NetPacket_GMSV *) buffer;
+
+	// fill game data header
+	ThePacketDriver->FillStdGameHeader( PKTP_STREAM, gamepacket );
+
+	if ( nClientID == PLAYERID_MASTERSERVER ) {
+
+		UPDTXT2( MSGOUT( "DATAGRAM: PKTP_STREAM S -> M: node: %s id: %d msg: %d", 
+						NODE_Print( node ), 
+						nClientID, 
+						gamepacket->MessageId ); );
+
+	} else {
+
+		UPDTXT2( MSGOUT( "DATAGRAM: PKTP_STREAM S -> C: node: %s id: %d msg: %d", 
+						NODE_Print( node ), 
+						nClientID, 
+						gamepacket->MessageId ); );
+
+	}
+
+
+	// send the datagram
+	int rc = ThePacketDriver->SendDatagram( gamepacket, node, nClientID, pUnreliable );
+	
+	return rc;
+}
+
+
+// send a datagram command to a specific client node --------------------------
+//
+int E_PacketHandler::Send_COMMAND_Datagram( const char* clientcommand, node_t* node, int nClientID )
+{
+	char			buffer[ NET_MAX_NETPACKET_INTERNAL_LEN ];
+	NetPacket_GMSV*	gamepacket = (NetPacket_GMSV *) buffer;
+
+	// fill game data header
+	ThePacketDriver->FillStdGameHeader( PKTP_COMMAND, gamepacket );
+
+	if ( nClientID == PLAYERID_MASTERSERVER ) {
+
+		UPDTXT2( MSGOUT( "DATAGRAM: PKTP_COMMAND S -> M: node: %s msg: %d cmd: '%s'", 
+						NODE_Print( node ), 
+						nClientID, 
+						clientcommand ); );
+
+	} else {
+
+		UPDTXT2( MSGOUT( "DATAGRAM: PKTP_COMMAND S -> C: node: %s msg: %d cmd: '%s'", 
+						NODE_Print( node ), 
+						nClientID, 
+						clientcommand ); );
+
+	}
+
+	// append a remote event containing the command
+	E_REList* pUnreliable = E_REList::CreateAndAddRef( RE_LIST_MAXAVAIL );
+	if ( !pUnreliable->NET_Append_RE_CommandInfo( clientcommand ) ) {
+		DBGTXT( MSGOUT( "e_PacketHandler::Send_COMMAND_Datagram(): RE list choke." ); );
+	}
+	
+	// send the packet
+	int rc = ThePacketDriver->SendDatagram( gamepacket, node, nClientID, pUnreliable );
+
+	// release the RE list from here
+	pUnreliable->Release();
+	
+	return rc;
+}
+
+
+// send a server command to a specific client node ----------------------------
+//
+int E_PacketHandler::Send_COMMAND( char* clientcommand, node_t* node, int nClientID, int reliable )
+{
+	char			buffer[ NET_MAX_NETPACKET_INTERNAL_LEN ];
+	NetPacket_GMSV*	gamepacket = (NetPacket_GMSV *) buffer;
+
+	// fill game data header
+	ThePacketDriver->FillStdGameHeader( PKTP_COMMAND, gamepacket );
+
+	if ( nClientID == PLAYERID_MASTERSERVER ) {
+
+		UPDTXT2( MSGOUT( "PKTP_COMMAND S -> M: node: %s id: %d msg: %d cmd: '%s'", 
+						NODE_Print( node ), 
+						nClientID, 
+						gamepacket->MessageId,
+						clientcommand ); );
+
+	} else {
+
+		UPDTXT2( MSGOUT( "PKTP_COMMAND S -> C: node: %s id: %d msg: %d cmd: '%s'", 
+						NODE_Print( node ), 
+						nClientID, 
+						gamepacket->MessageId,
+						clientcommand ); );
+
+	}
+
+	// append a remote event containing the command
+	E_REList* pREList = E_REList::CreateAndAddRef( RE_LIST_MAXAVAIL );
+	if ( !pREList->NET_Append_RE_CommandInfo( clientcommand ) ) {
+		DBGTXT( MSGOUT( "e_PacketHandler::_Send_COMMAND(): RE list choke." ); );
+	}
+
+	// determine whether to send reliable or unreliable
+	E_REList* pReliable	= NULL;
+	E_REList* pUnreliable	= NULL;
+	if ( reliable ) { 
+		pReliable = pREList;
+	} else {
+		pUnreliable = pREList;
+	}
+	
+	// send the packet
+	int rc = ThePacketDriver->SendPacket( gamepacket, node, nClientID, pReliable, pUnreliable );
+
+	// release the RE list from here
+	pREList->Release();
+	
+	return rc;
+}
+
+
+// do safe parsing of challenge request ---------------------------------------
+//
+int E_PacketHandler::_ParseChallengeRequest( char* recvline )
+{
+	ASSERT( recvline != NULL );
+
+	// copy parseline for safe processing
+	char parseline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	strncpy( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	parseline[ MAX_RE_COMMANDINFO_COMMAND_LEN ] = 0;
+	
+	// check for request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	if ( strncmp( recvline, GIVECHALLSTRING1, len ) != 0 )
+		return FALSE;
+	
+	return TRUE;
+}
+
+
+// do safe parsing of connect request ---------------------------------------
+//
+int E_PacketHandler::_ParseConnectRequest( char* recvline, E_ClientConnectInfo* pClientConnectInfo )
+{
+	ASSERT( recvline			!= NULL );
+	ASSERT( pClientConnectInfo	!= NULL );
+
+	// copy parseline for safe processing
+	SAFE_STR_DUPLICATE( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	
+	// check for request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	
+	if ( strncmp( ident_str, CONNSTRING2, len ) != 0 ) {
+		return FALSE;
+	}
+	
+	// get major version number
+	char* v_str1 = strtok( NULL, "." );
+	if ( v_str1 == NULL ) {
+		return FALSE;
+	}
+	char* errpart;
+	pClientConnectInfo->m_nVersionMajor = (int) strtol( v_str1, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+	
+	// get minor version number
+	char* v_str2 = strtok( NULL, " " );
+	if ( v_str2 == NULL ) {
+		return FALSE;
+	}
+	pClientConnectInfo->m_nVersionMinor = (int) strtol( v_str2, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+	
+	// get challenge
+	strtok( NULL, " " );
+	char* ch_str = strtok( NULL, " " );
+	if ( ch_str == NULL ) {
+		return FALSE;
+	}
+	pClientConnectInfo->m_challenge = (int) strtol( ch_str, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+	
+	// get playername
+	strtok( NULL, " " );
+	char* n_str = strtok( NULL, " " );
+	if ( n_str == NULL ) {
+		return FALSE;
+	}
+	strncpy( pClientConnectInfo->m_szName, n_str, MAX_PLAYER_NAME );
+	pClientConnectInfo->m_szName[ MAX_PLAYER_NAME ] = 0;
+	
+	// get NET.CLIENTRATE
+	strtok( NULL, " " );
+	char* clientrate_str = strtok( NULL, " " );
+	if ( clientrate_str == NULL ) {
+		return FALSE;
+	}
+	pClientConnectInfo->m_nSendFreq = (int) strtol( clientrate_str, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+
+	// get NET.SERVERTRATE
+	strtok( NULL, " " );
+	char* serverrate_str = strtok( NULL, " " );
+	if ( serverrate_str == NULL ) {
+		return FALSE;
+	}
+	pClientConnectInfo->m_nRecvRate = (int) strtol( serverrate_str, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+
+	// get operating system specifier
+	strtok( NULL, " " );
+	char* os_str = strtok( NULL, "\n" );
+	if ( os_str == NULL ) {
+		return FALSE;
+	}
+	
+	strncpy( pClientConnectInfo->m_szOSLine, os_str, MAX_OSNAME_LEN );
+	pClientConnectInfo->m_szOSLine[ MAX_OSNAME_LEN ] = 0;
+	
+	return TRUE;
+}
+
+
+// do safe parsing of disconnect request --------------------------------------
+//
+int E_PacketHandler::_ParseDisconnectRequest( char* recvline )
+{
+	ASSERT( recvline != NULL );
+	
+	// copy parseline for safe processing
+	SAFE_STR_DUPLICATE( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	
+	// check for request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	if ( strncmp( recvline, RMVSTRING1, len ) != 0 )
+		return FALSE;
+	
+	return TRUE;
+}
+
+// do safe parsing of namechange request --------------------------------------
+//
+int E_PacketHandler::_ParseNameChangeRequest( char* recvline, char* playername )
+{
+	ASSERT( recvline != NULL );
+	
+	// copy parseline for safe processing
+	SAFE_STR_DUPLICATE( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	
+	// check for request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	if ( strncmp( recvline, NAMESTRING1, len ) != 0 )
+		return FALSE;
+
+	//FIXME: we MUST get rid of all NEWLINES in the commands
+	//NOTE: the order of the token DOES matter here
+	char *n_str = strtok( NULL, "\n\0" );
+	if ( n_str == NULL )
+		return FALSE;
+	
+	memset( playername, 0, MAX_PLAYER_NAME + 1 );
+	strncpy( playername, n_str, MAX_PLAYER_NAME );
+	playername[ MAX_PLAYER_NAME ] = 0;
+	
+	return TRUE;
+}
+
+// do safe parsing of INFO request --------------------------------------------
+//
+int E_PacketHandler::_ParseInfoRequest( char* recvline, refframe_t* client_ping_send_frame )
+{
+	ASSERT( recvline != NULL );
+	ASSERT( client_ping_send_frame != NULL );
+	
+	// copy parseline for safe processing
+	SAFE_STR_DUPLICATE( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	
+	// check for PING request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	if ( strncmp( recvline, INFOSTRING1, len ) != 0 ) {
+		return FALSE;
+	}
+
+	// get frame
+	char* frame_str = strtok( NULL, " \n" );
+	if ( frame_str == NULL ) {
+		return FALSE;
+	}
+	
+	char* errpart;
+	*client_ping_send_frame = (refframe_t) strtol( frame_str, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+
+// do safe parsing of PING request --------------------------------------------
+//
+int E_PacketHandler::_ParsePingRequest( char* recvline, refframe_t* client_ping_send_frame )
+{
+	ASSERT( recvline != NULL );
+	ASSERT( client_ping_send_frame != NULL );
+	
+	// copy parseline for safe processing
+	SAFE_STR_DUPLICATE( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	
+	// check for PING request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	if ( strncmp( recvline, PINGSTRING1, len ) != 0 ) {
+		return FALSE;
+	}
+
+	// get frame
+	char* frame_str = strtok( NULL, " \n" );
+	if ( frame_str == NULL ) {
+		return FALSE;
+	}
+	
+	char* errpart;
+	*client_ping_send_frame = (refframe_t) strtol( frame_str, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+int E_PacketHandler::_ParseListRequest_MASTER( char* recvline, int *serverid){
+
+	ASSERT( recvline != NULL );
+
+	// copy parseline for safe processing
+	SAFE_STR_DUPLICATE( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	MSGOUT("E_PacketHandler::_ParseListRequest_MASTER(): parseline: x%sx", parseline);
+
+	// check for Master Sever List request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL ){
+		MSGOUT("Returning NNULL on first strtok");
+		return FALSE;
+	}
+
+	int len = strlen( ident_str );
+	if ( strncmp( recvline, MASV_LIST, len ) != 0 ) {
+		MSGOUT("first STRCMP: x%sx x%sx %d", recvline, MASV_LIST, len);
+		if (strncmp (recvline, "info", 4) != 0) {
+			MSGOUT("returning on second strcmp");
+			return false;
+		}
+	}
+
+	// check for the server id
+	ident_str = strtok( NULL , " " );
+	if(ident_str == NULL){
+		*serverid = -1;
+		return TRUE;
+	}
+		// this should be the requested server id
+		*serverid = atoi(ident_str);
+	//}
+	if(*serverid == 0){
+		*serverid = -1;
+	}
+
+
+
+	return TRUE;
+}
+
+int E_PacketHandler::_ParseHBPacket_MASTER(char* recvline) {
+
+	ASSERT( recvline != NULL );
+
+
+
+	// copy parseline for safe processing
+	SAFE_STR_DUPLICATE( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+
+	// check for Master Sever List request identifier
+	char* ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	if ( strncmp( recvline, MASV_CHALLSTRING, len ) != 0 ) {
+		return FALSE;
+	}
+
+	// ok we have a HeartBeat packet, lets get some information...
+
+	// some declares
+	int PMajor = 0;
+	int PMinor = 0;
+	int Challenge = 0;
+	int CurrPlayers = 0;
+	int MaxPlayers = 0;
+	int ServerID = 0;
+	char ServerName[ MAX_SERVER_NAME + 1 ];
+
+	node_t _Node;
+	char OS[MAX_OSNAME_LEN + 1 ];
+	int srv_port = 0;
+
+	ident_str = strtok( NULL, ".");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the Protocol Major number
+		PMajor = atoi(ident_str);
+	}
+
+	ident_str = strtok( NULL, " ");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the Protocol Minor number
+		PMinor = atoi(ident_str);
+	}
+
+	ident_str = strtok( NULL, " ");// skip a field, as it should just denote "ch" for the challenge.
+	// FIXME: Check to make sure this is "ch" for proper packet structure maybe?
+
+	// next....
+	ident_str = strtok( NULL, " ");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the Challenge
+		Challenge = atoi(ident_str);
+	}
+
+	ident_str = strtok( NULL, " ");// skip a field, as it should just denote "n" for the name.
+	// FIXME: Check to make sure this is "n" for proper packet structure maybe?
+
+	// next....
+	ident_str = strtok( NULL, " ");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the Server Name
+		strncpy(ServerName, ident_str, MAX_SERVER_NAME -1);
+		ServerName[MAX_SERVER_NAME] = '\0';
+	}
+
+	ident_str = strtok( NULL, " ");// skip a field, as it should just denote "p" for the player date
+	// FIXME: Check to make sure this is "p" for proper packet structure maybe?
+
+	// next....
+	ident_str = strtok( NULL, "/");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the current players
+		CurrPlayers = atoi(ident_str);
+	}
+	ident_str = strtok( NULL, " ");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the max players
+		MaxPlayers = atoi(ident_str);
+	}
+	ident_str = strtok( NULL, " ");// skip a field, as it should just denote "s" for the server id
+	// FIXME: Check to make sure this is "s" for proper packet structure maybe?
+
+	// next....
+	ident_str = strtok( NULL, " ");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the requested server id
+		ServerID = atoi(ident_str);
+	}
+
+	ident_str = strtok( NULL, " ");// skip a field, as it should just denote "os" for the server os
+	// FIXME: Check to make sure this is "os" for proper packet structure maybe?
+
+	// next....
+	ident_str = strtok( NULL, " ");
+	if(ident_str == NULL){
+		return FALSE;
+	} else {
+		// this should be the server os
+		strncpy(OS, ident_str, MAX_OSNAME_LEN - 1 );
+		OS[MAX_OSNAME_LEN] = '\0';
+	}
+
+	// if we get this far, then we should have everything to try to add the node to the MasterServer->ServerList.
+	// BUT first let's see if the node's IP resolves...
+	int result = TheUDPDriver->ResolveHostName(ServerName, &_Node);
+	if(!result) {
+		return FALSE;
+	}
+
+	// resolved host name, let's see if they sent us a port
+	ident_str = strtok( NULL, " ");// skip a field, as it should just denote "p" for the server port
+	// FIXME: Check to make sure this is "p" for proper packet structure maybe?
+	if(ident_str == NULL) {
+		// null here means they didn't denote a port.  Let's use the default
+		// one
+		NODE_StorePort(&_Node, DEFAULT_GAMESERVER_UDP_PORT);
+	} else {
+		// next....
+		ident_str = strtok( NULL, " ");
+		if(ident_str != NULL){
+			// this should be the server port
+			srv_port = atoi(ident_str);
+		}
+		if(srv_port > 0 ) {
+			NODE_StorePort(&_Node, srv_port);
+		} else {
+			// error parsing the server port,
+			// use the default one perhaps.
+			NODE_StorePort(&_Node, DEFAULT_GAMESERVER_UDP_PORT);
+		}
+	}
+
+
+	// check to see if the server already exists in the ServerList.  If so, update it.  If not, add it.
+	// if the info doesn't match, ignore the packet
+	int i = 0;
+	for(i=0; i<TheMaster->ServerList.size(); i++){
+
+
+		word SrvID = (word)TheMaster->ServerList[i].GetSrvID();
+		if(SrvID == ServerID) {
+			// double check the ID against the node address.
+			node_t node_ck;
+			TheMaster->ServerList[i].GetNode(&node_ck);
+			if(NODE_AreSame(&node_ck, &_Node)){
+				// they are the same, so update the record in the server list
+				TheMaster->ServerList[i].update(ServerID,CurrPlayers,MaxPlayers,PMajor,PMinor,ServerName,OS,&_Node);
+				return TRUE;
+			} else {
+				// if we get here, the requested ServerID exists, but the node address
+				// doesn't match.  Ignore the packet
+				// XXX: Perhaps send a packet back to the server to notify them the ID is taken?
+				return FALSE;
+			}
+		}
+
+	}
+
+	//MasterServerItem *tmp = ;
+	TheMaster->ServerList.push_back( MasterServerItem (ServerID,
+			 CurrPlayers,
+			 MaxPlayers,
+			 PMajor,
+			 PMinor,
+			 ServerName,
+			 OS,
+			 &_Node ));
+
+	// if we get this far, we should have successfully parsed the packet.  So return true.
+	return TRUE;
+}
+
+void E_PacketHandler::_Handle_STREAM_MASTER(NetPacket_GMSV* gamepacket, int bufid) {
+
+	ASSERT( gamepacket != NULL );
+	ASSERT( gamepacket->Command == PKTP_STREAM );
+	ASSERT( gamepacket->SendPlayerId != PLAYERID_MASTERSERVER );
+
+	// handle an incoming stream for the master server.
+	RE_Header* relist = (RE_Header*)&gamepacket->RE_List;
+	ASSERT( relist != NULL );
+
+	// do not handle empty remote event lists
+	if ( relist->RE_Type == RE_EMPTY ) {
+		DBGTXT( MSGOUT( "E_PacketHandler::_Handle_STREAM_MASTER(): ignoring - no input" ); );
+		return;
+	}
+
+	int nNumEventsAppended = 0;
+	RE_CommandInfo * re_commandinfo = NULL;
+	node_t*			clientnode		= ThePacketDriver->GetPktSender( bufid );
+
+	char clientIP [ MAX_IPADDR_LEN + 1 ];
+	inet_ntop( AF_INET, &clientnode, clientIP, MAX_IPADDR_LEN + 1 );
+
+	// process remote event list
+	while ( relist->RE_Type != RE_EMPTY ) {
+
+		// determine size of the remote event
+		size_t size = E_REList::RmEvGetSize( relist );
+		int serverid = 0;
+		// check whether RE is valid
+		if ( !E_REList::ValidateRE( relist, size ) ) {
+			DBGTXT( MSGOUT( "E_PacketHandler::_Handle_STREAM_MASTER(): ignoring invalid RE %d", relist->RE_Type ); );
+			continue;
+		}
+
+		switch( relist->RE_Type ) {
+
+			case RE_COMMANDINFO:
+				// valid in master server in streams.
+				// pass this off to the Master Server Command Packet handler
+				// trick the packet handler a little bit... just a little...
+				re_commandinfo = (RE_CommandInfo *)relist;
+
+				if ( _ParseListRequest_MASTER( re_commandinfo->command, &serverid ) ) {
+					/*
+					// walk the MasterServer->ServerList and send out IPV4 packets for all
+					std::vector<MasterServerItem>::iterator MSI;
+					for(MSI = TheMaster->ServerList.begin(); MSI != TheMaster->ServerList.end(); ++MSI){
+						SendIPV4Response(clientnode, (MasterServerItem *)&MSI,  nClientID);
+					}*/
+					MSGOUT("E_PacketHandler::_Handle_STREAM_MASTER(): Got LIST from client %s\n", clientIP);
+				}
+				if ( _ParseHBPacket_MASTER(re_commandinfo->command)) {
+					MSGOUT("E_PacketHandler::_Handle_STREAM_MASTER(): Got HB from client: %s\n", clientIP);
+					return;
+				} else {
+					MSGOUT("E_PacketHandler::_Handle_STREAM_MASTER(): Failed to parse HeartBeat Packet from: %s\n", clientIP);
+					return;
+				}
+
+				break;
+			case RE_SERVERLINKINFO:
+				// server link information.
+
+				break;
+
+			default:
+				MSGOUT( "E_PacketHandler::_Handle_STREAM_MASTER(): Invalid Packet type %d for Master Server from client %s", relist->RE_Type, clientIP);
+				break;
+
+		}
+
+		// advance to next event in list
+		ASSERT( ( relist->RE_BlockSize == RE_BLOCKSIZE_INVALID ) || ( relist->RE_BlockSize == size ) );
+		relist = (RE_Header *) ( (char *) relist + size );
+	}
+
+	// dump the input RE list
+	UPDTXT2( m_pInputREList->Dump(); );
+
+}
+
+// do safe parsing of new challenge from MASV ---------------------------------
+//
+int E_PacketHandler::_ParseMASVChallenge( char* recvline, int* pChallenge )
+{
+	ASSERT( recvline != NULL );
+	ASSERT( pChallenge != NULL );
+	
+	// copy parseline for safe processing
+	char parseline[ MAX_RE_COMMANDINFO_COMMAND_LEN + 1 ];
+	strncpy( parseline, recvline, MAX_RE_COMMANDINFO_COMMAND_LEN );
+	parseline[ MAX_RE_COMMANDINFO_COMMAND_LEN ] = 0;
+	
+	// check for string identifier
+	char *ident_str = strtok( parseline, " " );
+	if ( ident_str == NULL )
+		return FALSE;
+
+	int len = strlen( ident_str );
+	if ( strncmp( ident_str, RECVSTR_CHALLENGE, len ) != 0 )
+		return FALSE;
+	
+	// get challenge number
+	char* chall_str = strtok( NULL, "\0" );
+	if ( chall_str == NULL )
+		return FALSE;
+	
+	char *errpart;
+	*pChallenge = (int) strtol( chall_str, &errpart, 10 );
+	if ( *errpart != 0 ) {
+		return FALSE;
+	}
+	
+
+	return TRUE;
+}
+
+
+// handle a packet containing a command from the masterserver -----------------
+//
+void E_PacketHandler::_Handle_COMMAND_MASV( NetPacket_GMSV* gamepacket, int bufid )
+{
+	ASSERT( gamepacket != NULL );
+	ASSERT( gamepacket->Command == PKTP_COMMAND );
+	ASSERT( gamepacket->SendPlayerId == PLAYERID_MASTERSERVER );
+
+	// check whether from masterserver
+	if ( gamepacket->SendPlayerId != PLAYERID_MASTERSERVER ) {
+		return;
+	}
+
+	// get the commandstring
+	RE_CommandInfo* re_commandinfo	= (RE_CommandInfo*) &gamepacket->RE_List;
+
+	UPDTXT2( MSGOUT( "PKTP_COMMAND M -> S: id: %d msg: %d cmd: '%s'", nClientID, gamepacket->MessageId, re_commandinfo->command ); );
+
+
+	// parse for challenge request
+	int nMASVChallenge = 0;
+	if ( _ParseMASVChallenge( re_commandinfo->command, &nMASVChallenge ) ) {
+		
+		// set the new challenge
+		TheServer->SetMasterServerChallenge( nMASVChallenge );
+	}
+}
+
+
+// handle a packet containing a client command --------------------------------
+//
+void E_PacketHandler::_Handle_COMMAND( NetPacket_GMSV* gamepacket, int bufid )
+{
+	ASSERT( gamepacket != NULL );
+	ASSERT( gamepacket->Command == PKTP_COMMAND );
+
+	// identify sender, get the commandstring & get the sender node
+	int				nClientID		= gamepacket->SendPlayerId;
+	RE_CommandInfo* re_commandinfo	= (RE_CommandInfo*) &gamepacket->RE_List;
+	node_t*			clientnode		= ThePacketDriver->GetPktSender( bufid );
+
+	UPDTXT2( MSGOUT( "PKTP_COMMAND C -> S: id: %d msg: %d cmd: '%s'", nClientID, gamepacket->MessageId, re_commandinfo->command ); );
+
+	// temporary storage for client connection info
+	E_ClientConnectInfo _ClientConnectInfo;
+	char playername[ MAX_PLAYER_NAME + 1 ];
+
+	refframe_t client_ping_send_frame;
+
+	// parse for challenge request
+	if ( _ParseChallengeRequest( re_commandinfo->command ) ) {
+
+		// handle challenge request
+		ASSERT( TheConnManager != NULL );
+		TheConnManager->RequestChallenge( clientnode );
+		
+		// parse for connect request
+	} else if ( _ParseConnectRequest( re_commandinfo->command, &_ClientConnectInfo ) ) {
+		
+		// store the sender node
+		NODE_Copy( &_ClientConnectInfo.m_node, clientnode );
+		
+		// retrieve client hostname from address structure
+		inet_ntop( AF_INET, &_ClientConnectInfo.m_node, _ClientConnectInfo.m_szHostName, MAX_IPADDR_LEN + 1 );
+
+		// check whether client connection is valid ( version/banned/server full etc. )
+		ASSERT( TheConnManager != NULL );
+		TheConnManager->CheckClientConnect( &_ClientConnectInfo );
+		
+		// parse for disconnect request
+	} else if ( _ParseDisconnectRequest( re_commandinfo->command ) ) {
+		
+		// handle disconnect request
+		ASSERT( TheConnManager != NULL );
+		TheConnManager->CheckClientDisconnect( clientnode );
+		
+		// parse for namechange request
+	} else if ( _ParseNameChangeRequest( re_commandinfo->command, playername ) ) {
+		
+		// handle namechange request
+		ASSERT( TheConnManager != NULL );
+		TheConnManager->CheckNameChange( clientnode, playername );
+
+	// parse for a PING request
+	} else if ( _ParsePingRequest( re_commandinfo->command, &client_ping_send_frame ) ) {
+
+		// send the PING response
+		SendPingResponse( client_ping_send_frame, clientnode, nClientID );
+
+	// parse for a INFO request
+	} else if ( _ParseInfoRequest( re_commandinfo->command, &client_ping_send_frame ) ) {
+
+		// send the INFO response
+		SendInfoResponse( client_ping_send_frame, clientnode, nClientID );
+	}
+}
+
+// handle a packet containing a client command --------------------------------
+//
+void E_PacketHandler::_Handle_COMMAND_MASTER( NetPacket_GMSV* gamepacket, int bufid )
+{
+	ASSERT( gamepacket != NULL );
+	ASSERT( gamepacket->Command == PKTP_COMMAND );
+
+	// identify sender, get the commandstring & get the sender node
+	int				nClientID		= gamepacket->SendPlayerId;
+	RE_CommandInfo* re_commandinfo	= (RE_CommandInfo*) &gamepacket->RE_List;
+	node_t*			clientnode		= ThePacketDriver->GetPktSender( bufid );
+
+	char clientIP [ MAX_IPADDR_LEN + 1 ];
+	inet_ntop( AF_INET, &clientnode, clientIP, MAX_IPADDR_LEN + 1 );
+
+	UPDTXT2( MSGOUT( "PKTP_COMMAND C -> S: id: %d msg: %d cmd: '%s'", nClientID, gamepacket->MessageId, re_commandinfo->command ); );
+
+	// temporary storage for client connection info
+	E_ClientConnectInfo _ClientConnectInfo;
+	char playername[ MAX_PLAYER_NAME + 1 ];
+
+	refframe_t client_ping_send_frame;
+
+	int serverid = 0;
+	if ( _ParseListRequest_MASTER( re_commandinfo->command, &serverid ) ) {
+
+		// walk the MasterServer->ServerList and send out IPV4 packets for all or the one
+
+			SendIPV4Response(clientnode,   nClientID, serverid);
+
+		MSGOUT("E_PacketHandler::_Handle_COMMAND_MASTER(): Got LIST from client: %s\n", clientIP);
+		return;
+	}
+	if ( _ParseHBPacket_MASTER(re_commandinfo->command)) {
+		MSGOUT("E_PacketHandler::_Handle_COMMAND_MASTER(): Got HB from client: %s\n", clientIP);
+		return;
+	} else {
+		MSGOUT("E_PacketHandler::_Handle_COMMAND_MASTER(): Failed to parse HeartBeat Packet from: %s\n", clientIP);
+		return;
+	}
+	MSGOUT("E_PacketHandler::_Handle_COMMAND_MASTER(): Unimplemented packet %s from client %s\n", re_commandinfo->command, clientIP);
+
+}
+
+// handle a stream packet -----------------------------------------------------
+//
+void E_PacketHandler::_Handle_STREAM( NetPacket_GMSV* gamepacket )
+{
+	ASSERT( gamepacket != NULL );
+	ASSERT( gamepacket->Command == PKTP_STREAM );
+	ASSERT( gamepacket->SendPlayerId != PLAYERID_MASTERSERVER );
+	
+	// identify sender & get the sender node
+	int	nClientID = gamepacket->SendPlayerId;
+
+	UPDTXT2( MSGOUT( "PKTP_STREAM C -> S: id: %d msg: %d", nClientID, gamepacket->MessageId ); );
+
+	// ignore PKTP_STREAM packets from invalid senders
+	if ( ( nClientID < 0 ) || ( nClientID >= MAX_NUM_CLIENTS ) ) {
+		MSGOUT( "ignoring PKTP_STREAM packet from invalid sender id: %d", nClientID );
+		return;
+	}
+
+	E_ClientInfo* pClientInfo = TheConnManager->GetClientInfo( nClientID );
+	
+	// player must be connected in order to send NODE_ALIVE
+	if ( pClientInfo->IsSlotFree() ) {
+		DBGTXT( MSGOUT( "_Handle_STREAM(): filtering GAME_STATE for player who is not connected: %d.", nClientID ); );
+		return;
+	}
+	
+	// get the player info
+	E_SimPlayerInfo* pSimPlayerInfo = TheSimulator->GetSimPlayerInfo( nClientID );
+	ASSERT( pSimPlayerInfo != NULL );
+	ASSERT( pSimPlayerInfo->IsPlayerDisconnected() == FALSE );
+	
+	// mark the sender alive
+	pClientInfo->MarkAlive();
+
+	// handle the network input
+	TheSimNetInput->HandleOneClient( nClientID, (RE_Header*)&gamepacket->RE_List );
+}
+
+
+
+int E_PacketHandler::SendIPV4Response(node_t* clientnode, int nClientID, int serverid) {
+
+
+	ASSERT( ( ( nClientID >= 0 ) && ( nClientID <= MAX_NET_ALLOC_SLOTS ) ) || ( nClientID == PLAYERID_ANONYMOUS ) );
+	ASSERT( clientnode != NULL );
+	int i = 0;
+	for(i=0; i<TheMaster->ServerList.size(); i++){
+
+		if(serverid == -1 || serverid == TheMaster->ServerList[i].GetSrvID()){
+
+			E_REList* pUnreliable = E_REList::CreateAndAddRef( RE_LIST_MAXAVAIL );
+			// append a remote event containing the command
+
+
+			node_t node;
+			TheMaster->ServerList[i].GetNode( &node);
+			word SrvID = (word)TheMaster->ServerList[i].GetSrvID();
+
+
+			int rc = pUnreliable->NET_Append_RE_IPv4ServerInfo( &node, SrvID, SrvID, SrvID, 0 );
+			ASSERT( rc == TRUE );
+
+			// send a datagram
+			ThePacketHandler->Send_STREAM_Datagram( pUnreliable, clientnode, nClientID );
+
+			// release the RE list from here
+			pUnreliable->Release();
+		}
+	}
+	return TRUE;
+}