Ginger88895
/
warzone2100
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
warzone2100/lib/netplay/netplay.c

1516 lines
36 KiB
C
Raw Blame History

/*
This file is part of Warzone 2100.
Copyright (C) 1999-2004 Eidos Interactive
Copyright (C) 2005-2007 Warzone Resurrection Project
Warzone 2100 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.
Warzone 2100 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 Warzone 2100; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* Netplay.c
*
* Alex Lee sep97-> june98
*/
// ////////////////////////////////////////////////////////////////////////
// includes
#include <time.h> // for stats
#include <SDL/SDL_thread.h>
#include <SDL/SDL_net.h>
#include <physfs.h>
#include <string.h>
#include "lib/framework/frame.h"
#include "netplay.h"
#include "netlog.h"
char* master_server = "warzone2100.kicks-ass.org";
#define MASTER_SERVER_PORT 9998
#define WARZONE_NET_PORT 9999
#define MAX_CONNECTED_PLAYERS 8
#define MAX_TMP_SOCKETS 16
#define NET_READ_TIMEOUT 0
#define NET_BUFFER_SIZE 1024
#define MSG_JOIN 90
#define MSG_ACCEPTED 91
#define MSG_PLAYER_INFO 92
#define MSG_PLAYER_DATA 93
#define MSG_PLAYER_JOINED 94
#define MSG_PLAYER_LEFT 95
#define MSG_GAME_FLAGS 96
//#define NET_DEBUG
static BOOL allow_joining = FALSE;
static void NETallowJoining(void);
BOOL MultiPlayerJoin(UDWORD dpid);
BOOL MultiPlayerLeave(UDWORD dpid);
// ////////////////////////////////////////////////////////////////////////
// Variables
NETPLAY NetPlay;
static GAMESTRUCT game;
void NETsetMessageSize(NETMSG* pMsg, unsigned int size) {
unsigned int tmp = 8 - (size % 8);
if (tmp == 8) {
pMsg->size = size;
pMsg->paddedBytes = 0;
} else {
pMsg->size = size + tmp;
pMsg->paddedBytes = tmp;
}
}
// *********** Socket with buffer that read NETMSGs ******************
typedef struct {
TCPsocket socket;
char* buffer;
unsigned int buffer_start;
unsigned int bytes;
} NETBUFSOCKET;
static NETBUFSOCKET* NET_createBufferedSocket(void) {
NETBUFSOCKET* bs = (NETBUFSOCKET*)malloc(sizeof(NETBUFSOCKET));
bs->socket = NULL;
bs->buffer = NULL;
bs->buffer_start = 0;
bs->bytes = 0;
return bs;
}
void NET_destroyBufferedSocket(NETBUFSOCKET* bs) {
free(bs->buffer);
free(bs);
}
void NET_initBufferedSocket(NETBUFSOCKET* bs, TCPsocket s) {
bs->socket = s;
if (bs->buffer == NULL) {
bs->buffer = (char*)malloc(NET_BUFFER_SIZE);
}
bs->buffer_start = 0;
bs->bytes = 0;
}
BOOL NET_fillBuffer(NETBUFSOCKET* bs, SDLNet_SocketSet socket_set)
{
int size;
char* bufstart = bs->buffer + bs->buffer_start + bs->bytes;
const int bufsize = NET_BUFFER_SIZE - bs->buffer_start - bs->bytes;
if (bs->buffer_start != 0) {
return FALSE;
}
if (SDLNet_SocketReady(bs->socket) <= 0) {
return FALSE;
}
size = SDLNet_TCP_Recv(bs->socket, bufstart, bufsize);
if (size > 0) {
bs->bytes += size;
return TRUE;
} else {
if (socket_set != NULL) {
SDLNet_TCP_DelSocket(socket_set, bs->socket);
}
SDLNet_TCP_Close(bs->socket);
bs->socket = NULL;
}
return FALSE;
}
BOOL NET_recvMessage(NETBUFSOCKET* bs, NETMSG* pMsg)
{
unsigned int size;
const NETMSG* message = (NETMSG*)(bs->buffer + bs->buffer_start);
const unsigned int headersize = sizeof(message->size)
+ sizeof(message->type)
+ sizeof(message->paddedBytes)
+ sizeof(message->destination);
if (headersize > bs->bytes) {
goto error;
}
size = message->size + headersize;
if (size > bs->bytes) {
goto error;
}
debug( LOG_NET, "NETrecvMessage: received message of type %i and size %i.\n", message->type, message->size );
memcpy(pMsg, message, size);
bs->buffer_start += size;
bs->bytes -= size;
return TRUE;
error:
if (bs->buffer_start != 0) {
static char* tmp_buffer = NULL;
char* buffer_start = bs->buffer + bs->buffer_start;
char* tmp;
//printf("Moving data in buffer\n");
// Create tmp buffer if necessary
if (tmp_buffer == NULL) {
//printf("Creating tmp buffer\n");
tmp_buffer = (char*)malloc(NET_BUFFER_SIZE);
}
// Move remaining contents into tmp buffer
memcpy(tmp_buffer, buffer_start, bs->bytes);
// swap tmp buffer with buffer
tmp = bs->buffer;
bs->buffer = tmp_buffer;
tmp_buffer = tmp;
// Now data is in the beginning of the buffer
bs->buffer_start = 0;
}
return FALSE;
}
static TCPsocket tcp_socket = NULL;
static NETBUFSOCKET* bsocket = NULL;
static NETBUFSOCKET* connected_bsocket[MAX_CONNECTED_PLAYERS] = { NULL };
static SDLNet_SocketSet socket_set = NULL;
static BOOL is_server = FALSE;
static TCPsocket tmp_socket[MAX_TMP_SOCKETS] = { 0 };
static SDLNet_SocketSet tmp_socket_set = NULL;
static NETMSG message;
static char* hostname;
// ////////////////////////////////////////////////////////////////////////
typedef struct { // data regarding the last one second or so.
UDWORD bytesRecvd;
UDWORD bytesSent; // number of bytes sent in about 1 sec.
UDWORD packetsSent;
UDWORD packetsRecvd;
} NETSTATS;
static NETSTATS nStats = { 0 };
#define PLAYER_HOST 1
#define PLAYER_SPECTATOR 2
// ////////////////////////////////////////////////////////////////////////
// Players stuff
typedef struct {
BOOL allocated;
unsigned int id;
char name[StringSize];
unsigned int flags;
} NET_PLAYER;
static NET_PLAYER players[MAX_CONNECTED_PLAYERS];
static void NET_InitPlayers(void) {
unsigned int i;
for (i = 0; i < MAX_CONNECTED_PLAYERS; ++i) {
players[i].allocated = FALSE;
players[i].id = i;
}
}
void NETBroadcastPlayerInfo(int dpid) {
message.type = MSG_PLAYER_INFO;
NETsetMessageSize(&message, sizeof(NET_PLAYER));
memcpy(message.body, &players[dpid], sizeof(NET_PLAYER));
NETbcast(&message, TRUE);
}
unsigned int NET_CreatePlayer(const char* name, unsigned int flags) {
unsigned int i;
for (i = 1; i < MAX_CONNECTED_PLAYERS; ++i) {
if (players[i].allocated == FALSE) {
players[i].allocated = TRUE;
strcpy(players[i].name, name);
players[i].flags = flags;
NETBroadcastPlayerInfo(i);
return i;
}
}
return 0;
}
void NET_DestroyPlayer(unsigned int id) {
players[id].allocated = FALSE;
}
// ////////////////////////////////////////////////////////////////////////
// count players. call with null to enumerate the game already joined.
UDWORD NETplayerInfo(void)
{
unsigned int i;
NetPlay.playercount = 0; // reset player counter
if(!NetPlay.bComms)
{
NetPlay.playercount = 1;
NetPlay.players[0].bHost = TRUE;
NetPlay.players[0].bSpectator = FALSE;
NetPlay.players[0].dpid = 1;
return 1;
}
memset(NetPlay.players, 0, (sizeof(PLAYER)*MaxNumberOfPlayers)); // reset player info
for (i = 0; i < MAX_CONNECTED_PLAYERS; ++i) {
if (players[i].allocated == TRUE) {
NetPlay.players[NetPlay.playercount].dpid = i;
strcpy(NetPlay.players[NetPlay.playercount].name, players[i].name);
if (players[i].flags & PLAYER_HOST) {
NetPlay.players[NetPlay.playercount].bHost = TRUE;
} else {
NetPlay.players[NetPlay.playercount].bHost = FALSE;
}
if (players[i].flags & PLAYER_SPECTATOR) {
NetPlay.players[NetPlay.playercount].bSpectator = TRUE;
} else {
NetPlay.players[NetPlay.playercount].bSpectator = FALSE;
}
NetPlay.playercount++;
}
}
return NetPlay.playercount;
}
// ////////////////////////////////////////////////////////////////////////
// rename the local player
// dont call this a lot, since it uses a guaranteed msg.
BOOL NETchangePlayerName(UDWORD dpid, char *newName)
{
if(!NetPlay.bComms)
{
strcpy(NetPlay.players[0].name, newName);
return TRUE;
}
strcpy(players[dpid].name, newName);
NETBroadcastPlayerInfo(dpid);
return TRUE;
}
typedef struct {
unsigned int size;
void* data;
unsigned int buffer_size;
} NET_PLAYER_DATA;
static NET_PLAYER_DATA local_player_data[MAX_CONNECTED_PLAYERS] = { { 0 } };
static NET_PLAYER_DATA global_player_data[MAX_CONNECTED_PLAYERS] = { { 0 } };
void resize_local_player_data(unsigned int i, unsigned int size) {
if (local_player_data[i].buffer_size < size) {
if (local_player_data[i].data != NULL) {
free(local_player_data[i].data);
}
local_player_data[i].data = malloc(size);
local_player_data[i].buffer_size = size;
}
}
void resize_global_player_data(unsigned int i, unsigned int size) {
if (global_player_data[i].buffer_size < size) {
if (global_player_data[i].data != NULL) {
free(global_player_data[i].data);
}
global_player_data[i].data = malloc(size);
global_player_data[i].buffer_size = size;
}
}
// ////////////////////////////////////////////////////////////////////////
BOOL NETgetLocalPlayerData(UDWORD dpid, void *pData, SDWORD *pSize)
{
memcpy(pData, local_player_data[dpid].data, local_player_data[dpid].size);
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
BOOL NETgetGlobalPlayerData(UDWORD dpid, void *pData, SDWORD *pSize)
{
if(!NetPlay.bComms)
{
memcpy(pData, local_player_data[dpid].data, local_player_data[dpid].size);
return TRUE;
}
memcpy(pData, global_player_data[dpid].data, global_player_data[dpid].size);
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
BOOL NETsetLocalPlayerData(UDWORD dpid,void *pData, SDWORD size)
{
local_player_data[dpid].size = size;
resize_local_player_data(dpid, size);
memcpy(local_player_data[dpid].data, pData, size);
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
BOOL NETsetGlobalPlayerData(UDWORD dpid, void *pData, SDWORD size)
{
if(!NetPlay.bComms)
{
local_player_data[dpid].size = size;
resize_local_player_data(dpid, size);
memcpy(local_player_data[dpid].data, pData, size);
return TRUE;
}
global_player_data[dpid].size = size;
resize_global_player_data(dpid, size);
memcpy(global_player_data[dpid].data, pData, size);
{ // broadcast player data
unsigned int* p_dpid = (unsigned int*)(message.body);
message.type = MSG_PLAYER_DATA;
NETsetMessageSize(&message, sizeof(unsigned int)+size);
*p_dpid = dpid;
memcpy(message.body+sizeof(unsigned int), pData, size);
}
NETBroadcastPlayerInfo(dpid);
return TRUE;
}
// ///////////////////////////////////////////////////////////////////////
// Game flags stuff...
SDWORD NetGameFlags[4];
// ////////////////////////////////////////////////////////////////////////
// return one of the four user flags in the current sessiondescription.
SDWORD NETgetGameFlags(UDWORD flag)
{
if (flag < 1 || flag > 4) {
return 0;
} else {
return NetGameFlags[flag-1];
}
}
// ////////////////////////////////////////////////////////////////////////
// Set a game flag
BOOL NETsetGameFlags(UDWORD flag, SDWORD value)
{
if(!NetPlay.bComms) {
return TRUE;
}
if (flag < 1 || flag > 4) {
return NetGameFlags[flag-1] = value;
}
message.type = MSG_GAME_FLAGS;
NETsetMessageSize(&message, sizeof(NetGameFlags));
memcpy(message.body, NetGameFlags, sizeof(NetGameFlags));
NETbcast(&message, TRUE);
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// setup stuff
BOOL NETinit(BOOL bFirstCall)
{
UDWORD i;
debug( LOG_NET, "NETinit" );
// NEThashFile("warzonedebug.exe");
if(bFirstCall)
{
debug( LOG_NEVER, "NETPLAY: Init called, MORNIN'\n" );
NetPlay.bLobbyLaunched = FALSE; // clean up
NetPlay.dpidPlayer = 0;
NetPlay.bHost = 0;
NetPlay.bComms = TRUE;
NetPlay.bEncryptAllPackets = FALSE;
NETsetKey(0x2fe8f810, 0xb72a5, 0x114d0, 0x2a7); // j-random key to get us started
NetPlay.bAllowCaptureRecord = FALSE;
NetPlay.bAllowCapturePlay = FALSE;
NetPlay.bCaptureInUse = FALSE;
for(i=0;i<MaxNumberOfPlayers;i++)
{
memset(&NetPlay.players[i], 0, sizeof(PLAYER));
memset(&NetPlay.games[i], 0, sizeof(GAMESTRUCT));
}
//GAME_GUID = g;
NETuseNetwork(TRUE);
NETstartLogging();
}
if (SDLNet_Init() == -1) {
debug( LOG_ERROR, "SDLNet_Init: %s\n", SDLNet_GetError() );
return FALSE;
}
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// SHUTDOWN THE CONNECTION.
BOOL NETshutdown(void)
{
unsigned int i;
debug( LOG_NET, "NETshutdown" );
for( i = 0; i < MAX_CONNECTED_PLAYERS; i++ )
{
if( local_player_data[i].data != NULL )
{
free( local_player_data[i].data );
}
}
NETstopLogging();
SDLNet_Quit();
return 0;
}
// ////////////////////////////////////////////////////////////////////////
//close the open game..
BOOL NETclose(void)
{
unsigned int i;
debug( LOG_NET, "NETclose\n" );
NEThaltJoining();
is_server=FALSE;
if(bsocket) {
NET_destroyBufferedSocket(bsocket);
bsocket=NULL;
}
for(i=0;i<MAX_CONNECTED_PLAYERS;i++) {
if(connected_bsocket[i]) {
NET_destroyBufferedSocket(connected_bsocket[i]);
connected_bsocket[i]=NULL;
}
NET_DestroyPlayer(i);
}
if(tmp_socket_set) {
SDLNet_FreeSocketSet(tmp_socket_set);
tmp_socket_set=NULL;
}
for(i=0;i<MAX_TMP_SOCKETS;i++) {
if(tmp_socket[i]) {
SDLNet_TCP_Close(tmp_socket[i]);
tmp_socket[i]=NULL;
}
}
if(socket_set) {
SDLNet_FreeSocketSet(socket_set);
socket_set=NULL;
}
if(tcp_socket) {
SDLNet_TCP_Close(tcp_socket);
tcp_socket=NULL;
}
return FALSE;
}
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////
// Send and Recv functions
// ////////////////////////////////////////////////////////////////////////
// return bytes of data sent recently.
UDWORD NETgetBytesSent(void)
{
static UDWORD lastsec=0;
static UDWORD timy=0;
if( (UDWORD)clock() > (timy+CLOCKS_PER_SEC) )
{
timy = clock();
lastsec = nStats.bytesSent;
nStats.bytesSent = 0;
}
return lastsec;
}
UDWORD NETgetRecentBytesSent(void)
{
return nStats.bytesSent;
}
UDWORD NETgetBytesRecvd(void)
{
static UDWORD lastsec=0;
static UDWORD timy=0;
if( (UDWORD)clock() > (timy+CLOCKS_PER_SEC) )
{
timy = clock();
lastsec = nStats.bytesRecvd;
nStats.bytesRecvd = 0;
}
return lastsec;
}
UDWORD NETgetRecentBytesRecvd(void)
{
return nStats.bytesRecvd;
}
//return number of packets sent last sec.
UDWORD NETgetPacketsSent(void)
{
static UDWORD lastsec=0;
static UDWORD timy=0;
if( (UDWORD)clock() > (timy+CLOCKS_PER_SEC) )
{
timy = clock();
lastsec = nStats.packetsSent;
nStats.packetsSent = 0;
}
return lastsec;
}
UDWORD NETgetRecentPacketsSent(void)
{
return nStats.packetsSent;
}
UDWORD NETgetPacketsRecvd(void)
{
static UDWORD lastsec=0;
static UDWORD timy=0;
if( (UDWORD)clock() > (timy+CLOCKS_PER_SEC) )
{
timy = clock();
lastsec = nStats.packetsRecvd;
nStats.packetsRecvd = 0;
}
return lastsec;
}
UDWORD NETgetRecentPacketsRecvd(void)
{
return nStats.packetsRecvd;
}
// ////////////////////////////////////////////////////////////////////////
// Send a message to a player, option to guarantee message
BOOL NETsend(NETMSG *msg, UDWORD player, BOOL guarantee)
{
int size;
debug( LOG_NET, "NETsend\n" );
if(!NetPlay.bComms)
{
return TRUE;
}
if (player >= MAX_CONNECTED_PLAYERS) return FALSE;
//printf("Sending message %i to %i\n", msg->type, msg->destination);
msg->destination = player;
if ( NetPlay.bEncryptAllPackets
&& (msg->type!=AUDIOMSG)
&& (msg->type!=FILEMSG)) {
NETmanglePacket(msg);
}
//printf("NETsend %i\n", msg->type);
size = msg->size + sizeof(msg->size) + sizeof(msg->type) + sizeof(msg->paddedBytes) + sizeof(msg->destination);
if (is_server) {
if ( player < MAX_CONNECTED_PLAYERS
&& connected_bsocket[player] != NULL
&& connected_bsocket[player]->socket != NULL
&& SDLNet_TCP_Send(connected_bsocket[player]->socket,
msg, size) == size) {
nStats.bytesSent += size;
nStats.packetsSent += 1;
return TRUE;
}
} else {
if ( tcp_socket
&& SDLNet_TCP_Send(tcp_socket, msg, size) == size) {
return TRUE;
}
}
return FALSE;
}
// ////////////////////////////////////////////////////////////////////////
// broadcast a message to all players.
BOOL NETbcast(NETMSG *msg, BOOL guarantee)
{
int size;
if(!NetPlay.bComms)
{
return TRUE;
}
debug( LOG_NET, "NETbcast\n");
msg->destination = NET_ALL_PLAYERS;
if ( NetPlay.bEncryptAllPackets
&& (msg->type!=AUDIOMSG)
&& (msg->type!=FILEMSG)) {
NETmanglePacket(msg);
}
size = msg->size + sizeof(msg->size) + sizeof(msg->type) + sizeof(msg->paddedBytes) + sizeof(msg->destination);
//printf("NETbcast %i\n", msg->type);
if (is_server) {
unsigned int i;
for (i = 0; i < MAX_CONNECTED_PLAYERS; ++i) {
if ( connected_bsocket[i] != NULL
&& connected_bsocket[i]->socket != NULL) {
SDLNet_TCP_Send(connected_bsocket[i]->socket, msg, size);
}
}
} else {
if ( tcp_socket == NULL
|| SDLNet_TCP_Send(tcp_socket, msg, size) < size) {
return FALSE;
}
}
nStats.bytesSent += size;
nStats.packetsSent += 1;
return TRUE;
}
///////////////////////////////////////////////////////////////////////////
// Check if a message is a system message
BOOL NETprocessSystemMessage(NETMSG * pMsg)
{
debug( LOG_NET, "NETprocessSystemMessage\n" );
switch (pMsg->type) {
case MSG_PLAYER_INFO: {
NET_PLAYER* pi = (NET_PLAYER*)(pMsg->body);
int dpid = pi->id;
//printf("Receiving info for player %i\n", dpid);
memcpy(&players[dpid], pi, sizeof(NET_PLAYER));
NETplayerInfo();
if (is_server) {
NETBroadcastPlayerInfo(dpid);
}
//printf("Just received and processed MSG_PLAYER_INFO\n");
} break;
case MSG_PLAYER_DATA: {
unsigned int* pdpid = (unsigned int*)(pMsg->body);
int dpid = *pdpid;
unsigned int size = pMsg->size - sizeof(unsigned int);
//printf("Receiving DATA for player %i\n", dpid);
global_player_data[dpid].size = size;
resize_global_player_data(dpid, size);
memcpy(global_player_data[dpid].data, pMsg->body+sizeof(unsigned int), size);
if (is_server) {
NETbcast(pMsg, TRUE);
}
//printf("Just received and processed MSG_PLAYER_DATA\n");
} break;
case MSG_PLAYER_JOINED: {
unsigned int* pdpid = (unsigned int*)(pMsg->body);
int dpid = *pdpid;
MultiPlayerJoin(dpid);
} break;
case MSG_PLAYER_LEFT: {
unsigned int* pdpid = (unsigned int*)(pMsg->body);
int dpid = *pdpid;
NET_DestroyPlayer(dpid);
MultiPlayerLeave(dpid);
} break;
case MSG_GAME_FLAGS: {
//printf("Receiving game flags\n");
memcpy(NetGameFlags, pMsg->body, sizeof(NetGameFlags));
if (is_server) {
NETbcast(pMsg, TRUE);
}
//printf("Just received and processed MSG_GAME_FLAGS\n");
} break;
default:
return FALSE;
}
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// receive a message over the current connection
BOOL NETrecv(NETMSG * pMsg)
{
static unsigned int current = 0;
BOOL received;
int size;
if (!NetPlay.bComms)
{
return FALSE;
}
if (is_server) {
NETallowJoining();
}
do {
receive_message:
received = FALSE;
//printf("Receiving something\n");
if (is_server) {
if (connected_bsocket[current] == NULL) return FALSE;
received = NET_recvMessage(connected_bsocket[current], pMsg);
if (received == FALSE) {
unsigned int i = current + 1;
if ( socket_set == NULL
|| SDLNet_CheckSockets(socket_set, NET_READ_TIMEOUT) <= 0) {
return FALSE;
}
for (;;) {
if (connected_bsocket[i]->socket == NULL) {
} else if (NET_fillBuffer(connected_bsocket[i], socket_set)) {
received = NET_recvMessage(connected_bsocket[i], pMsg);
current = i;
break;
} else if (connected_bsocket[i]->socket == NULL) {
unsigned int* message_dpid = (unsigned int*)(message.body);
game.desc.dwCurrentPlayers--;
message.type = MSG_PLAYER_LEFT;
NETsetMessageSize(&message, 4);
*message_dpid = i;
NETbcast(&message, TRUE);
NET_DestroyPlayer(i);
MultiPlayerLeave(i);
}
if (++i == MAX_CONNECTED_PLAYERS) {
i = 0;
}
if (i == current+1) {
return FALSE;
}
}
}
} else {
if (bsocket == NULL) {
return FALSE;
} else {
received = NET_recvMessage(bsocket, pMsg);
if (received == FALSE) {
if ( socket_set != NULL
&& SDLNet_CheckSockets(socket_set, NET_READ_TIMEOUT) > 0
&& NET_fillBuffer(bsocket, socket_set)) {
received = NET_recvMessage(bsocket, pMsg);
}
}
}
}
if (received == FALSE) {
return FALSE;
} else {
size = pMsg->size + sizeof(pMsg->size) + sizeof(pMsg->type)
+ sizeof(pMsg->paddedBytes) + sizeof(pMsg->destination);
if (is_server == FALSE) {
} else if (pMsg->destination == NET_ALL_PLAYERS) {
unsigned int j;
for (j = 0; j < MAX_CONNECTED_PLAYERS; ++j) {
if ( j != current
&& connected_bsocket[j] != NULL
&& connected_bsocket[j]->socket != NULL) {
SDLNet_TCP_Send(connected_bsocket[j]->socket,
pMsg, size);
}
}
} else if (pMsg->destination != NetPlay.dpidPlayer) {
if ( pMsg->destination < MAX_CONNECTED_PLAYERS
&& connected_bsocket[pMsg->destination] != NULL
&& connected_bsocket[pMsg->destination]->socket != NULL) {
//printf("Reflecting message to UDWORD %i\n", pMsg->destination);
SDLNet_TCP_Send(connected_bsocket[pMsg->destination]->socket,
pMsg, size);
} else {
//printf("Cannot reflect message %i to UDWORD %i\n", pMsg->type, pMsg->destination);
}
goto receive_message;
}
if ( (pMsg->type>=ENCRYPTFLAG)
&& (pMsg->type!=AUDIOMSG)
&& (pMsg->type!=FILEMSG)) {
NETunmanglePacket(pMsg);
}
//printf("Received message : type = %i, size = %i, size = %i.\n", pMsg->type, pMsg->size, size);
nStats.bytesRecvd += size;
nStats.packetsRecvd += 1;
}
} while (NETprocessSystemMessage(pMsg) == TRUE);
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////
// Protocol functions
BOOL NETsetupTCPIP(void ** addr, char * machine)
{
debug( LOG_NET, "NETsetupTCPIP\n" );
if ( hostname != NULL
&& hostname != master_server) {
free(hostname);
}
if ( machine != NULL
&& machine[0] != '\0') {
hostname = strdup(machine);
} else {
hostname = master_server;
}
return TRUE;
}
// select a current protocol. Call with a connection returned by findprotocol.
BOOL NETselectProtocol(void * lpConnection)
{
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// call with true to enumerate available protocols.
BOOL NETfindProtocol(BOOL Lob)
{
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// File Transfer programs.
// uses guaranteed messages to send files between clients.
// send file. it returns % of file sent. when 100 it's complete. call until it returns 100.
UBYTE NETsendFile(BOOL newFile, const char *fileName, UDWORD player)
{
static PHYSFS_sint64 fileSize,currPos;
static PHYSFS_file *pFileHandle;
PHYSFS_sint64 bytesRead;
UBYTE inBuff[2048];
NETMSG msg;
if(newFile) //force it true for now -Q
{
// open the file.
pFileHandle = PHYSFS_openRead(fileName); // check file exists
if (pFileHandle == NULL)
{
debug( LOG_WZ, "NETsendFile: Failed\n" );
return 0; // failed
}
// get the file's size.
fileSize = 0;
currPos =0;
do
{
bytesRead = PHYSFS_read( pFileHandle, &inBuff, 1, sizeof(inBuff) );
fileSize += bytesRead;
} while(bytesRead != 0);
PHYSFS_seek(pFileHandle, 0 );
}
// read some bytes.
bytesRead = PHYSFS_read(pFileHandle, &inBuff, sizeof(inBuff), 1 );
// form a message
NetAdd(msg,0,fileSize); // total bytes in this file.
NetAdd(msg,4,bytesRead); // bytes in this packet
NetAdd(msg,8,currPos); // start byte
msg.body[12]=strlen(fileName);
msg.size = 13;
NetAddSt(msg,msg.size,fileName);
msg.size += strlen(fileName);
memcpy(&(msg.body[msg.size]),&inBuff,bytesRead);
msg.size += bytesRead;
msg.type = FILEMSG;
msg.paddedBytes = 0;
if(player==0)
{
NETbcast(&msg,TRUE); // send it.
}
else
{
NETsend(&msg,player,TRUE);
}
currPos += bytesRead; // update position!
if(currPos == fileSize)
{
PHYSFS_close(pFileHandle);
}
return (currPos*100)/fileSize;
}
// recv file. it returns % of the file so far recvd.
UBYTE NETrecvFile(NETMSG *pMsg)
{
UDWORD pos, fileSize, currPos, bytesRead;
char fileName[256];
unsigned int len;
static PHYSFS_file *pFileHandle;
//read incoming bytes.
NetGet(pMsg,0,fileSize);
NetGet(pMsg,4,bytesRead);
NetGet(pMsg,8,currPos);
// read filename
len = (unsigned int)(pMsg->body[12]);
memcpy(fileName,&(pMsg->body[13]),len);
fileName[len] = '\0'; // terminate string.
pos = 13+len;
//printf("NETrecvFile: Creating new file %s\n", fileName);
if(currPos == 0) // first packet!
{
//printf("NETrecvFile: Creating new file %s\n", fileName);
pFileHandle = PHYSFS_openWrite(fileName); // create a new file.
}
//write packet to the file.
PHYSFS_write( pFileHandle, &(pMsg->body[pos]), bytesRead, 1 );
if(currPos+bytesRead == fileSize) // last packet
{
PHYSFS_close(pFileHandle);
}
//return the percent count.
return ((currPos+bytesRead)*100) / fileSize;
}
void NETregisterServer(int state) {
static TCPsocket rs_socket = NULL;
static int registered = 0;
static int server_not_there = 0;
IPaddress ip;
if (server_not_there) {
return;
}
if (state != registered) {
switch(state) {
case 1: {
if(SDLNet_ResolveHost(&ip, master_server, MASTER_SERVER_PORT) == -1) {
debug( LOG_ERROR, "NETregisterServer: couldn't resolve master server (%s): %s\n", master_server, SDLNet_GetError() );
server_not_there = 1;
return;
}
if(!rs_socket) rs_socket = SDLNet_TCP_Open(&ip);
if(rs_socket == NULL) {
debug( LOG_ERROR, "NETregisterServer: Cannot connect to master server (%s): %s\n", master_server, SDLNet_GetError() );
server_not_there = 1;
return;
}
SDLNet_TCP_Send(rs_socket, "addg", 5);
SDLNet_TCP_Send(rs_socket, &game, sizeof(GAMESTRUCT));
}
break;
case 0:
SDLNet_TCP_Close(rs_socket);
rs_socket=NULL;
break;
}
registered=state;
}
}
// ////////////////////////////////////////////////////////////////////////
// Host a game with a given name and player name. & 4 user game flags
static void NETallowJoining(void) {
unsigned int i;
UDWORD numgames=1; // always 1 on normal server
char buffer[5];
if (allow_joining == FALSE) return;
NETregisterServer(1);
if (tmp_socket_set == NULL) {
tmp_socket_set = SDLNet_AllocSocketSet(MAX_TMP_SOCKETS+1);
if (tmp_socket_set == NULL) {
debug( LOG_ERROR, "Couldn't create socket set: %s\n", SDLNet_GetError() );
return;
}
SDLNet_TCP_AddSocket(tmp_socket_set, tcp_socket);
}
if (SDLNet_CheckSockets(tmp_socket_set, NET_READ_TIMEOUT) > 0) {
if (SDLNet_SocketReady(tcp_socket)) {
for (i = 0; i < MAX_TMP_SOCKETS; ++i) {
if (tmp_socket[i] == NULL) {
break;
}
}
tmp_socket[i] = SDLNet_TCP_Accept(tcp_socket);
SDLNet_TCP_AddSocket(tmp_socket_set, tmp_socket[i]);
if (SDLNet_CheckSockets(tmp_socket_set, 1000) > 0
&& SDLNet_SocketReady(tmp_socket)
&& SDLNet_TCP_Recv(tmp_socket[i], buffer, 5)) {
if(strcmp(buffer, "list")==0) {
SDLNet_TCP_Send(tmp_socket[i], &numgames, sizeof(UDWORD));
SDLNet_TCP_Send(tmp_socket[i], &game, sizeof(GAMESTRUCT));
} else if(strcmp(buffer, "join")==0) {
SDLNet_TCP_Send(tmp_socket[i], &game, sizeof(GAMESTRUCT));
}
} else {
return;
}
}
for(i = 0; i < MAX_TMP_SOCKETS; ++i) {
if ( tmp_socket[i] != NULL
&& SDLNet_SocketReady(tmp_socket[i]) > 0) {
int size = SDLNet_TCP_Recv(tmp_socket[i], &message, sizeof(NETMSG));
if (size <= 0) {
// socket probably disconnected.
SDLNet_TCP_DelSocket(tmp_socket_set, tmp_socket[i]);
SDLNet_TCP_Close(tmp_socket[i]);
tmp_socket[i] = NULL;
} else if (message.type == MSG_JOIN) {
int j;
char* name = message.body;
unsigned int dpid = NET_CreatePlayer(name, 0);
unsigned int* message_dpid = (unsigned int*)(message.body);
SDLNet_TCP_DelSocket(tmp_socket_set, tmp_socket[i]);
NET_initBufferedSocket(connected_bsocket[dpid], tmp_socket[i]);
SDLNet_TCP_AddSocket(socket_set, connected_bsocket[dpid]->socket);
tmp_socket[i] = NULL;
//printf("Creating player %i\n", dpid);
game.desc.dwCurrentPlayers++;
message.type = MSG_ACCEPTED;
NETsetMessageSize(&message, 4);
*message_dpid = dpid;
NETsend(&message, dpid, TRUE);
MultiPlayerJoin(dpid);
message.type = MSG_PLAYER_JOINED;
NETsetMessageSize(&message, 4);
// Send info about players to newcomer.
for (j = 0; j < MAX_CONNECTED_PLAYERS; ++j) {
if ( players[j].allocated
&& dpid != players[j].id) {
*message_dpid = players[j].id;
NETsend(&message, dpid, TRUE);
}
}
// Send info about newcomer to all players.
*message_dpid = dpid;
NETbcast(&message, TRUE);
for (j = 0; j < MAX_CONNECTED_PLAYERS; ++j) {
NETBroadcastPlayerInfo(j);
}
}
}
}
}
}
BOOL NEThostGame(const char* SessionName, const char* PlayerName,
SDWORD one, SDWORD two, SDWORD three, SDWORD four,
UDWORD plyrs) // # of players.
{
IPaddress ip;
unsigned int i;
debug( LOG_NET, "NEThostGame\n" );
if(!NetPlay.bComms)
{
NetPlay.dpidPlayer = 1;
NetPlay.bHost = TRUE;
return TRUE;
}
if(SDLNet_ResolveHost(&ip, NULL, WARZONE_NET_PORT) == -1) {
debug( LOG_ERROR, "NEThostGame: couldn't resolve master self: %s\n", SDLNet_GetError() );
return FALSE;
}
if(!tcp_socket) tcp_socket = SDLNet_TCP_Open(&ip);
if(tcp_socket == NULL) {
printf("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
return FALSE;
}
if(!socket_set) socket_set = SDLNet_AllocSocketSet(MAX_CONNECTED_PLAYERS);
if (socket_set == NULL) {
debug( LOG_ERROR, "Couldn't create socket set: %s\n", SDLNet_GetError() );
return FALSE;
}
for (i = 0; i < MAX_CONNECTED_PLAYERS; ++i) {
connected_bsocket[i] = NET_createBufferedSocket();
}
is_server = TRUE;
strcpy(game.name, SessionName);
memset(&game.desc, 0, sizeof(SESSIONDESC));
game.desc.dwSize = sizeof(SESSIONDESC);
//game.desc.guidApplication = GAME_GUID;
strcpy(game.desc.host, "");
game.desc.dwCurrentPlayers = 1;
game.desc.dwMaxPlayers = plyrs;
game.desc.dwFlags = 0;
game.desc.dwUser1 = one;
game.desc.dwUser2 = two;
game.desc.dwUser3 = three;
game.desc.dwUser4 = four;
NET_InitPlayers();
NetPlay.dpidPlayer = NET_CreatePlayer(PlayerName, PLAYER_HOST);
NetPlay.bHost = TRUE;
NetPlay.bSpectator = FALSE;
MultiPlayerJoin(NetPlay.dpidPlayer);
allow_joining = TRUE;
NETregisterServer(0);
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// Stop the dplay interface from accepting more players.
BOOL NEThaltJoining(void)
{
debug( LOG_NET, "NEThaltJoining\n" );
allow_joining = FALSE;
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// find games on open connection, option to do this asynchronously
// since it can sometimes take a while.
BOOL NETfindGame(BOOL async) /// may (not) want to use async here...
{
static UDWORD gamecount = 0, gamesavailable;
IPaddress ip;
char buffer[sizeof(GAMESTRUCT)*2];
GAMESTRUCT* tmpgame = (GAMESTRUCT*)buffer;
debug( LOG_NET, "NETfindGame\n" );
gamecount = 0;
NetPlay.games[0].desc.dwSize = 0;
NetPlay.games[0].desc.dwCurrentPlayers = 0;
NetPlay.games[0].desc.dwMaxPlayers = 0;
if(!NetPlay.bComms)
{
NetPlay.dpidPlayer = 1;
NetPlay.bHost = TRUE;
return TRUE;
}
if (SDLNet_ResolveHost(&ip, hostname, (hostname == master_server) ? MASTER_SERVER_PORT
: WARZONE_NET_PORT) == -1) {
debug( LOG_ERROR, "NETfindGame: couldn't resolve hostname (%s): %s\n", hostname, SDLNet_GetError() );
return FALSE;
}
if (tcp_socket != NULL) {
SDLNet_TCP_Close(tcp_socket);
}
tcp_socket = SDLNet_TCP_Open(&ip);
if (tcp_socket == NULL) {
debug( LOG_ERROR, "SDLNet_TCP_Open: %s\n", SDLNet_GetError() );
return FALSE;
}
socket_set = SDLNet_AllocSocketSet(1);
if (socket_set == NULL) {
debug( LOG_ERROR, "Couldn't create socket set: %s\n", SDLNet_GetError() );
return FALSE;
}
SDLNet_TCP_AddSocket(socket_set, tcp_socket);
SDLNet_TCP_Send(tcp_socket, "list", 5);
if ( SDLNet_CheckSockets(socket_set, 1000) > 0
&& SDLNet_SocketReady(tcp_socket)
&& SDLNet_TCP_Recv(tcp_socket, buffer, sizeof(int))) {
gamesavailable=(UDWORD)buffer[0];
}
debug( LOG_NET, "receiving info of %d game(s)\n", gamesavailable );
do {
if ( SDLNet_CheckSockets(socket_set, 1000) > 0
&& SDLNet_SocketReady(tcp_socket)
&& SDLNet_TCP_Recv(tcp_socket, buffer, sizeof(GAMESTRUCT)) == sizeof(GAMESTRUCT)
&& tmpgame->desc.dwSize == sizeof(SESSIONDESC)) {
strcpy(NetPlay.games[gamecount].name, tmpgame->name);
NetPlay.games[gamecount].desc.dwSize = tmpgame->desc.dwSize;
NetPlay.games[gamecount].desc.dwCurrentPlayers = tmpgame->desc.dwCurrentPlayers;
NetPlay.games[gamecount].desc.dwMaxPlayers = tmpgame->desc.dwMaxPlayers;
if (tmpgame->desc.host[0] == '\0') {
unsigned char* address = (unsigned char*)(&(ip.host));
sprintf(NetPlay.games[gamecount].desc.host,
"%i.%i.%i.%i",
(int)(address[0]),
(int)(address[1]),
(int)(address[2]),
(int)(address[3]));
} else {
strcpy(NetPlay.games[gamecount].desc.host, tmpgame->desc.host);
}
//printf("Received info for host %s\n", NetPlay.games[gamecount].desc.host);
gamecount++;
}
} while (gamecount<gamesavailable);
return TRUE;
}
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////
// Functions used to setup and join games.
BOOL NETjoinGame(UDWORD gameNumber, const char* playername)
{
char* name;
IPaddress ip;
char buffer[sizeof(GAMESTRUCT)*2];
GAMESTRUCT* tmpgame = (GAMESTRUCT*)buffer;
debug( LOG_NET, "NETjoinGame gameNumber=%d\n", gameNumber );
NETclose(); // just to be sure :)
if (hostname != master_server) {
free(hostname);
}
hostname = strdup(NetPlay.games[gameNumber].desc.host);
if(SDLNet_ResolveHost(&ip, hostname, WARZONE_NET_PORT) == -1) {
debug( LOG_ERROR, "NETjoinGame: couldn't resolve hostname (%s): %s\n", hostname, SDLNet_GetError() );
return FALSE;
}
if (tcp_socket != NULL) {
SDLNet_TCP_Close(tcp_socket);
}
tcp_socket = SDLNet_TCP_Open(&ip);
if (tcp_socket == NULL) {
debug( LOG_ERROR, "SDLNet_TCP_Open: %s\n", SDLNet_GetError() );
return FALSE;
}
socket_set = SDLNet_AllocSocketSet(1);
if (socket_set == NULL) {
debug( LOG_ERROR, "Couldn't create socket set: %s\n", SDLNet_GetError() );
return FALSE;
}
SDLNet_TCP_AddSocket(socket_set, tcp_socket);
SDLNet_TCP_Send(tcp_socket, "join", 5);
if ( SDLNet_CheckSockets(socket_set, 1000) > 0
&& SDLNet_SocketReady(tcp_socket)
&& SDLNet_TCP_Recv(tcp_socket, buffer, sizeof(GAMESTRUCT)*2) == sizeof(GAMESTRUCT)
&& tmpgame->desc.dwSize == sizeof(SESSIONDESC)) {
strcpy(NetPlay.games[gameNumber].name, tmpgame->name);
NetPlay.games[gameNumber].desc.dwSize = tmpgame->desc.dwSize;
NetPlay.games[gameNumber].desc.dwCurrentPlayers = tmpgame->desc.dwCurrentPlayers;
NetPlay.games[gameNumber].desc.dwMaxPlayers = tmpgame->desc.dwMaxPlayers;
strcpy(NetPlay.games[gameNumber].desc.host, tmpgame->desc.host);
if (tmpgame->desc.host[0] == '\0') {
unsigned char* address = (unsigned char*)(&(ip.host));
sprintf(NetPlay.games[gameNumber].desc.host,
"%i.%i.%i.%i",
(int)(address[0]),
(int)(address[1]),
(int)(address[2]),
(int)(address[3]));
} else {
strcpy(NetPlay.games[gameNumber].desc.host, tmpgame->desc.host);
}
//printf("JoinGame: Received info for host %s\n", NetPlay.games[gameNumber].desc.host);
}
bsocket = NET_createBufferedSocket();
NET_initBufferedSocket(bsocket, tcp_socket);
message.type = MSG_JOIN;
NETsetMessageSize(&message, 64);
name = message.body;
strcpy(name, playername);
NETsend(&message, 1, TRUE);
for (;;) {
NETrecv(&message);
if (message.type == MSG_ACCEPTED) {
unsigned int* message_dpid = (unsigned int*)(message.body);
NetPlay.dpidPlayer = *message_dpid;
//printf("I'm player %i\n", NetPlay.dpidPlayer);
NetPlay.bHost = FALSE;
NetPlay.bSpectator = FALSE;
players[NetPlay.dpidPlayer].allocated = TRUE;
players[NetPlay.dpidPlayer].id = NetPlay.dpidPlayer;
strcpy(players[NetPlay.dpidPlayer].name, playername);
players[NetPlay.dpidPlayer].flags = 0;
return TRUE;
}
}
return FALSE;
}
Reference in New Issue View Git Blame Copy Permalink