int NET_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data)
{
int r;
if (!sock)
return -1;
if (sock->disconnected)
{
Con_Printf("NET_SendMessage: disconnected socket\n");
return -1;
}
SetNetTime();
r = sfunc.SendUnreliableMessage(sock, data);
if (r == 1 && sock->driver)
unreliableMessagesSent++;
if (recording)
{
vcrSendMessage.time = host_time;
vcrSendMessage.op = VCR_OP_SENDMESSAGE;
vcrSendMessage.session = (long)sock;
vcrSendMessage.r = r;
Sys_FileWrite (vcrFile, &vcrSendMessage, 20);
}
return r;
}
void NET_Shutdown (void)
{
qsocket_t *sock;
SetNetTime();
for (sock = net_activeSockets; sock; sock = sock->next)
NET_Close(sock);
//
// shutdown the drivers
//
for (net_driverlevel = 0; net_driverlevel < net_numdrivers; net_driverlevel++)
{
if (net_drivers[net_driverlevel].initialized == true)
{
net_drivers[net_driverlevel].Shutdown ();
net_drivers[net_driverlevel].initialized = false;
}
}
if (vcrFile != -1)
{
Con_Printf ("Closing vcrfile.\n");
SystemFileManager::FileClose(vcrFile);
}
}
void NET_Poll(void)
{
PollProcedure *pp;
bool useModem;
if (!configRestored)
{
if (serialAvailable)
{
if (config_com_modem.getInt() == 1.0)
useModem = true;
else
useModem = false;
SetComPortConfig (0, config_com_port.getInt(), config_com_irq.getInt(), config_com_baud.getInt(), useModem);
SetModemConfig (0, config_modem_dialtype.getString(), config_modem_clear.getString(), config_modem_init.getString(), config_modem_hangup.getString());
}
configRestored = true;
}
SetNetTime();
for (pp = pollProcedureList; pp; pp = pp->next)
{
if (pp->nextTime > net_time)
break;
pollProcedureList = pp->next;
pp->procedure();//(pp->arg);
}
}
void NET_Poll(void)
{
PollProcedure *pp;
#if NET_USE_SERIAL
if (!configRestored)
{
if (serialAvailable)
{
qboolean useModem;
if (config_com_modem.value == 1.0)
useModem = true;
else
useModem = false;
SetComPortConfig (0, config_com_port.integer, config_com_irq.integer, config_com_baud.integer, useModem);
SetModemConfig (0, config_modem_dialtype.string, config_modem_clear.string, config_modem_init.string, config_modem_hangup.string);
}
configRestored = true;
}
#endif /* NET_USE_SERIAL */
SetNetTime();
for (pp = pollProcedureList; pp; pp = pp->next)
{
if (pp->nextTime > net_time)
break;
pollProcedureList = pp->next;
pp->procedure(pp->arg);
}
}
void NET_Poll(void)
{
PollProcedure *pp;
qboolean useModem;
if (!configRestored)
{
if (serialAvailable)
{
if (config_com_modem.value == 1.0)
useModem = true;
else
useModem = false;
SetComPortConfig (0, (int)config_com_port.value, (int)config_com_irq.value, (int)config_com_baud.value, useModem);
SetModemConfig (0, config_modem_dialtype.string, config_modem_clear.string, config_modem_init.string, config_modem_hangup.string);
}
configRestored = true;
}
SetNetTime();
for (pp = pollProcedureList; pp; pp = pp->next)
{
if (pp->nextTime > net_time)
break;
pollProcedureList = pp->next;
pp->procedure(); // jmarshall fix me was pp->arg
}
}
/*
==================
NET_CanSendMessage
Returns true or false if the given qsocket can currently accept a
message to be transmitted.
==================
*/
qboolean NET_CanSendMessage (qsocket_t *sock)
{
int r;
if (!sock)
return false;
if (sock->disconnected)
return false;
SetNetTime();
r = sfunc.CanSendMessage(sock);
if (recording)
{
vcrSendMessage.time = host_time;
vcrSendMessage.op = VCR_OP_CANSENDMESSAGE;
vcrSendMessage.session = (long)sock;
vcrSendMessage.r = r;
Sys_FileWrite (vcrFile, &vcrSendMessage, 20);
}
return r;
}
/*
==================
NET_CanSendMessage
Returns true or false if the given qsocket can currently accept a
message to be transmitted.
==================
*/
qboolean NET_CanSendMessage (qsocket_t *sock)
{
if (!sock)
return false;
if (sock->disconnected)
return false;
SetNetTime();
return sfunc.CanSendMessage(sock);
}
void NET_Poll(void)
{
PollProcedure *pp;
SetNetTime();
for (pp = pollProcedureList; pp; pp = pp->next)
{
if (pp->nextTime > net_time)
break;
pollProcedureList = pp->next;
pp->procedure(pp->arg);
}
}
/*
===================
NET_Close
===================
*/
void NET_Close (qsocket_t *sock)
{
if (!sock)
return;
if (sock->disconnected)
return;
SetNetTime();
// call the driver_Close function
sfunc.Close (sock);
NET_FreeQSocket(sock);
}
/*
==================
NET_CanSendMessage
Returns TRUE or FALSE if the given qsocket can currently accept a
message to be transmitted.
==================
*/
bool NET_CanSendMessage (qsocket_t *sock)
{
int r;
if (!sock)
return FALSE;
if (sock->disconnected)
return FALSE;
SetNetTime();
r = sfunc.CanSendMessage(sock);
return r;
}
/*
* ==================
* NET_CanSendMessage
*
* Returns true or false if the given qsocket can currently accept a
* message to be transmitted.
* ==================
*/
qboolean
NET_CanSendMessage(qsocket_t *sock)
{
int r;
if (!sock)
return false;
if (sock->disconnected)
return false;
SetNetTime();
r = sock->driver->CanSendMessage(sock);
return r;
}
void NET_Shutdown (void)
{
qsocket_t *sock;
SetNetTime();
for (sock = net_activeSockets; sock; sock = sock->next)
NET_Close(sock);
// shutdown the drivers
for (net_driverlevel = 0; net_driverlevel < net_numdrivers; net_driverlevel++)
if (net_drivers[net_driverlevel].initialized == TRUE)
{
net_drivers[net_driverlevel].Shutdown ();
net_drivers[net_driverlevel].initialized = FALSE;
}
}
/*
===================
NET_CheckNewConnections
===================
*/
qsocket_t *NET_CheckNewConnections (void)
{
qsocket_t *ret;
SetNetTime();
for (net_driverlevel = 0; net_driverlevel < net_numdrivers; net_driverlevel++)
{
if (net_drivers[net_driverlevel].initialized == false)
continue;
ret = dfunc.CheckNewConnections ();
if (ret)
{
return ret;
}
}
return NULL;
}
int NET_GetMessage (qsocket_t *sock)
{
int ret;
if (!sock)
return -1;
if (sock->disconnected)
{
Con_Printf("NET_GetMessage: disconnected socket\n");
return -1;
}
SetNetTime();
ret = sfunc.QGetMessage(sock);
// see if this connection has timed out
if (ret == 0 && sock->driver)
{
if (net_time - sock->lastMessageTime > net_messagetimeout.value)
{
NET_Close(sock);
return -1;
}
}
if (ret > 0)
{
if (sock->driver)
{
sock->lastMessageTime = net_time;
if (ret == 1)
messagesReceived++;
else if (ret == 2)
unreliableMessagesReceived++;
}
}
return ret;
}
/*
* ==================
* NET_SendMessage
*
* Try to send a complete length+message unit over the reliable stream.
* returns 0 : if the message cannot be delivered reliably, but the connection
* is still considered valid
* returns 1 : if the message was sent properly
* returns -1 : if the connection died
* ==================
*/
int
NET_SendMessage(qsocket_t *sock, sizebuf_t *data)
{
int r;
if (!sock)
return -1;
if (sock->disconnected) {
Con_Printf("%s: disconnected socket\n", __func__);
return -1;
}
SetNetTime();
r = sock->driver->QSendMessage(sock, data);
if (r == 1 && !IS_LOOP_DRIVER(sock->driver))
messagesSent++;
return r;
}
/*
==================
NET_SendMessage
Try to send a complete length+message unit over the reliable stream.
returns 0 if the message cannot be delivered reliably, but the connection
is still considered valid
returns 1 if the message was sent properly
returns -1 if the connection died
==================
*/
int NET_SendMessage (qsocket_t *sock, sizebuf_t *data)
{
int r;
if (!sock)
return -1;
if (sock->disconnected)
{
Con_Printf("%s: disconnected socket\n", __thisfunc__);
return -1;
}
SetNetTime();
r = sfunc.QSendMessage(sock, data);
if (r == 1)
messagesSent++;
return r;
}
int NET_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data)
{
int r;
if (!sock)
return -1;
if (sock->disconnected)
{
Con_Printf("NET_SendMessage: disconnected socket\n");
return -1;
}
SetNetTime();
r = sfunc.SendUnreliableMessage(sock, data);
if (r == 1 && sock->driver)
unreliableMessagesSent++;
return r;
}
qsocket_t *NET_CheckNewConnections(void)
{
qsocket_t *ret;
SetNetTime();
for (net_driverlevel=0 ; net_driverlevel<net_numdrivers; net_driverlevel++)
{
if (net_drivers[net_driverlevel].initialized == false)
{
continue;
}
if (net_driverlevel && listening == false)
{
continue;
}
ret = dfunc.CheckNewConnections();
if (ret)
{
if (recording)
{
vcrConnect.time = host_time;
vcrConnect.op = VCR_OP_CONNECT;
vcrConnect.session = (long)ret;
Sys_FileWrite(vcrFile, &vcrConnect, sizeof(vcrConnect));
Sys_FileWrite(vcrFile, ret->address, NET_NAMELEN);
}
return ret;
}
}
if (recording)
{
vcrConnect.time = host_time;
vcrConnect.op = VCR_OP_CONNECT;
vcrConnect.session = 0;
Sys_FileWrite(vcrFile, &vcrConnect, sizeof(vcrConnect));
}
return NULL;
}
/*
* ===================
* NET_CheckNewConnections
* ===================
*/
qsocket_t *
NET_CheckNewConnections(void)
{
int i;
qsocket_t *ret = NULL;
SetNetTime();
for (i = 0; i < net_numdrivers; i++) {
net_driver = &net_drivers[i];
if (net_driver->initialized == false)
continue;
if (!IS_LOOP_DRIVER(net_driver) && listening == false)
continue;
ret = net_driver->CheckNewConnections();
if (ret)
break;
}
return ret;
}
/*
* ====================
* NET_Shutdown
* ====================
*/
void
NET_Shutdown(void)
{
int i;
qsocket_t *sock;
SetNetTime();
for (sock = net_activeSockets; sock; sock = sock->next)
NET_Close(sock);
/*
* shutdown the drivers
*/
for (i = 0; i < net_numdrivers; i++) {
net_driver = &net_drivers[i];
if (net_driver->initialized == true) {
net_driver->Shutdown();
net_driver->initialized = false;
}
}
}
void
NET_Poll(void)
{
PollProcedure *pp;
SetNetTime();
/*
* FIXME - A procedure could schedule itself to the head of the list, but
* wouldn't be executed until next frame/tic; problem?
*/
for (pp = pollProcedureList; pp; pp = pp->next) {
if (pp->nextTime > net_time)
break;
pollProcedureList = pp->next;
#ifdef _WIN32
//not sure what is going on here - params is void in NQ/net.h?
pp->procedure();
#else
pp->procedure(pp->arg);
#endif
}
}
/*
* =================
* NET_GetMessage
*
* If there is a complete message, return it in net_message
*
* returns 0 if no data is waiting
* returns 1 if a message was received
* returns -1 if connection is invalid
* =================
*/
int
NET_GetMessage(qsocket_t *sock)
{
int ret;
if (!sock)
return -1;
if (sock->disconnected) {
Con_Printf("%s: disconnected socket\n", __func__);
return -1;
}
SetNetTime();
ret = sock->driver->QGetMessage(sock);
/* see if this connection has timed out (not for loop) */
if (ret == 0 && (!IS_LOOP_DRIVER(sock->driver))) {
if (net_time - sock->lastMessageTime > net_messagetimeout.value) {
NET_Close(sock);
return -1;
}
}
if (ret > 0) {
if (!IS_LOOP_DRIVER(sock->driver)) {
sock->lastMessageTime = net_time;
if (ret == 1)
messagesReceived++;
else if (ret == 2)
unreliableMessagesReceived++;
}
}
return ret;
}
qsocket_t *NET_Connect (char *host)
{
qsocket_t *ret;
int n;
SetNetTime();
if (host && *host == 0)
host = NULL;
if (host && hostCacheCount)
{
for (n = 0; n < hostCacheCount; n++)
if (Q_strcasecmp (host, hostcache[n].name) == 0)
{
host = hostcache[n].cname;
break;
}
if (n < hostCacheCount)
goto JustDoIt;
}
slistSilent = host ? true : false;
NET_Slist_f ();
while(slistInProgress)
NET_Poll();
if (host == NULL)
{
if (hostCacheCount != 1)
return NULL;
host = hostcache[0].cname;
Con_Printf("Connecting to...\n%s @ %s\n\n", hostcache[0].name, host);
}
if (hostCacheCount)
for (n = 0; n < hostCacheCount; n++)
if (Q_strcasecmp (host, hostcache[n].name) == 0)
{
host = hostcache[n].cname;
break;
}
JustDoIt:
for (net_driverlevel=0 ; net_driverlevel<net_numdrivers; net_driverlevel++)
{
if (net_drivers[net_driverlevel].initialized == false)
continue;
ret = dfunc.Connect (host);
if (ret)
return ret;
}
if (host)
{
Con_Printf("\n");
PrintSlistHeader();
PrintSlist();
PrintSlistTrailer();
}
return NULL;
}
static qsocket_t *_Datagram_Connect (char *host)
{
struct qsockaddr sendaddr;
struct qsockaddr readaddr;
qsocket_t *sock;
int newsock;
int ret;
int reps;
double start_time;
int control;
char *reason;
// see if we can resolve the host name
if (dfunc.GetAddrFromName(host, &sendaddr) == -1)
return NULL;
newsock = dfunc.OpenSocket (0);
if (newsock == -1)
return NULL;
sock = NET_NewQSocket ();
if (sock == NULL)
goto ErrorReturn2;
sock->socket = newsock;
sock->landriver = net_landriverlevel;
// connect to the host
if (dfunc.Connect (newsock, &sendaddr) == -1)
goto ErrorReturn;
// send the connection request
Con_Printf("trying...\n"); SCR_UpdateScreen ();
start_time = net_time;
for (reps = 0; reps < 3; reps++)
{
SZ_Clear(&net_message);
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_CONNECT);
MSG_WriteString(&net_message, "QUAKE");
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
*((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write (newsock, net_message.data, net_message.cursize, &sendaddr);
SZ_Clear(&net_message);
do
{
ret = dfunc.Read (newsock, net_message.data, net_message.maxsize, &readaddr);
// if we got something, validate it
if (ret > 0)
{
// is it from the right place?
if (sfunc.AddrCompare(&readaddr, &sendaddr) != 0)
{
#ifdef DEBUG
Con_Printf("wrong reply address\n");
Con_Printf("Expected: %s\n", StrAddr (&sendaddr));
Con_Printf("Received: %s\n", StrAddr (&readaddr));
SCR_UpdateScreen ();
#endif
ret = 0;
continue;
}
if (ret < sizeof(int))
{
ret = 0;
continue;
}
net_message.cursize = ret;
MSG_BeginReading ();
control = BigLong(*((int *)net_message.data));
MSG_ReadLong();
if (control == -1)
{
ret = 0;
continue;
}
if ((control & (~NETFLAG_LENGTH_MASK)) != NETFLAG_CTL)
{
ret = 0;
continue;
}
if ((control & NETFLAG_LENGTH_MASK) != ret)
{
ret = 0;
continue;
}
}
}
while (ret == 0 && (SetNetTime() - start_time) < 2.5);
if (ret)
break;
Con_Printf("still trying...\n"); SCR_UpdateScreen ();
start_time = SetNetTime();
}
if (ret == 0)
{
reason = "No Response";
Con_Printf("%s\n", reason);
Q_strcpy(m_return_reason, reason);
goto ErrorReturn;
}
if (ret == -1)
{
reason = "Network Error";
Con_Printf("%s\n", reason);
Q_strcpy(m_return_reason, reason);
goto ErrorReturn;
}
ret = MSG_ReadByte();
if (ret == CCREP_REJECT)
{
reason = MSG_ReadString();
Con_Printf(reason);
Q_strncpy(m_return_reason, reason, 31);
goto ErrorReturn;
}
if (ret == CCREP_ACCEPT)
{
Q_memcpy(&sock->addr, &sendaddr, sizeof(struct qsockaddr));
dfunc.SetSocketPort (&sock->addr, MSG_ReadLong());
}
else
{
reason = "Bad Response";
Con_Printf("%s\n", reason);
Q_strcpy(m_return_reason, reason);
goto ErrorReturn;
}
dfunc.GetNameFromAddr (&sendaddr, sock->address);
Con_Printf ("Connection accepted\n");
sock->lastMessageTime = SetNetTime();
// switch the connection to the specified address
if (dfunc.Connect (newsock, &sock->addr) == -1)
{
reason = "Connect to Game failed";
Con_Printf("%s\n", reason);
Q_strcpy(m_return_reason, reason);
goto ErrorReturn;
}
m_return_onerror = false;
return sock;
ErrorReturn:
NET_FreeQSocket(sock);
ErrorReturn2:
dfunc.CloseSocket(newsock);
if (m_return_onerror)
{
key_dest = key_menu;
m_state = m_return_state;
m_return_onerror = false;
}
return NULL;
}
void Network_Initialize(void)
{
int i;
int controlSocket;
qsocket_t *s;
i = COM_CheckParm ("-port");
if (!i)
i = COM_CheckParm ("-udpport");
if (!i)
i = COM_CheckParm ("-ipxport");
if (i)
{
if (i < com_argc-1)
DEFAULTnet_hostport = Q_atoi (com_argv[i+1]);
else
Sys_Error("You must specify a number after '-port'!");
}
net_hostport = DEFAULTnet_hostport;
if (COM_CheckParm("-listen") || cls.state == ca_dedicated)
listening = TRUE;
net_numsockets = svs.maxclientslimit;
if (cls.state != ca_dedicated)
net_numsockets++;
SetNetTime();
for (i = 0; i < net_numsockets; i++)
{
s = (qsocket_t *)Hunk_AllocName(sizeof(qsocket_t), "qsocket");
s->next = net_freeSockets;
net_freeSockets = s;
s->disconnected = TRUE;
}
// allocate space for network message buffer
SZ_Alloc (&net_message, NET_MAXMESSAGE);
Cvar_RegisterVariable (&net_messagetimeout, NULL);
Cvar_RegisterVariable (&hostname, NULL);
Cvar_RegisterVariable (&config_com_port, NULL);
Cvar_RegisterVariable (&config_com_irq, NULL);
Cvar_RegisterVariable (&config_com_baud, NULL);
Cvar_RegisterVariable (&config_com_modem, NULL);
Cvar_RegisterVariable (&config_modem_dialtype, NULL);
Cvar_RegisterVariable (&config_modem_clear, NULL);
Cvar_RegisterVariable (&config_modem_init, NULL);
Cvar_RegisterVariable (&config_modem_hangup, NULL);
Cmd_AddCommand ("slist", NET_Slist_f);
Cmd_AddCommand ("listen", NET_Listen_f);
Cmd_AddCommand ("maxplayers", MaxPlayers_f);
Cmd_AddCommand ("port", NET_Port_f);
// initialize all the drivers
for (net_driverlevel=0 ; net_driverlevel<net_numdrivers ; net_driverlevel++)
{
controlSocket = net_drivers[net_driverlevel].Init();
if (controlSocket == -1)
continue;
net_drivers[net_driverlevel].initialized = TRUE;
net_drivers[net_driverlevel].controlSock = controlSocket;
if (listening)
net_drivers[net_driverlevel].Listen (TRUE);
}
if(*my_tcpip_address)
Con_DPrintf("TCP/IP address %s\n", my_tcpip_address);
}
int NET_GetMessage (qsocket_t *sock)
{
int ret;
if (!sock)
return -1;
if (sock->disconnected)
{
Con_Printf("NET_GetMessage: disconnected socket\n");
return -1;
}
SetNetTime();
ret = sfunc.QGetMessage(sock);
// see if this connection has timed out
if (ret == 0 && sock->driver)
{
/*
RFC: Why doesn't this work!!! It's the same... or not??
Since when I compile it it evaluates the if body even if it's a smaller number...
if ((net_time - sock->lastMessageTime) > (double)net_messagetimeout.value)
{
Con_Printf("*** Connection timed out after %f s of inactivity (max is %f)\n",delta,net_messagetimeout.value);
//NET_Close(sock);
//return -1;
}
*/
float delta = (net_time - sock->lastMessageTime);
if (delta > net_messagetimeout.value)
{
Con_Printf("*** Connection timed out after %f s of inactivity (max is %f)\n",delta,net_messagetimeout.value);
NET_Close(sock);
return -1;
}
}
if (ret > 0)
{
if (sock->driver)
{
sock->lastMessageTime = net_time;
if (ret == 1)
messagesReceived++;
else if (ret == 2)
unreliableMessagesReceived++;
}
if (recording)
{
vcrGetMessage.time = host_time;
vcrGetMessage.op = VCR_OP_GETMESSAGE;
vcrGetMessage.session = (long)sock;
vcrGetMessage.ret = ret;
vcrGetMessage.len = net_message.cursize;
Sys_FileWrite (vcrFile, &vcrGetMessage, 24);
Sys_FileWrite (vcrFile, net_message.data, net_message.cursize);
}
}
else
{
if (recording)
{
vcrGetMessage.time = host_time;
vcrGetMessage.op = VCR_OP_GETMESSAGE;
vcrGetMessage.session = (long)sock;
vcrGetMessage.ret = ret;
Sys_FileWrite (vcrFile, &vcrGetMessage, 20);
}
}
return ret;
}
int NET_GetMessage (qsocket_t *sock)
{
int ret;
if (!sock)
return -1;
if (sock->disconnected)
{
Con_Printf("NET_GetMessage: disconnected socket\n");
return -1;
}
SetNetTime();
ret = sfunc.QGetMessage(sock);
// see if this connection has timed out
if (ret == 0 && sock->driver)
{
if (net_time - sock->lastMessageTime > net_messagetimeout.value)
{
NET_Close(sock);
return -1;
}
}
if (ret > 0)
{
if (sock->driver)
{
sock->lastMessageTime = net_time;
if (ret == 1)
messagesReceived++;
else if (ret == 2)
unreliableMessagesReceived++;
}
if (recording)
{
vcrGetMessage.time = host_time;
vcrGetMessage.op = VCR_OP_GETMESSAGE;
vcrGetMessage.session = (long)sock;
vcrGetMessage.ret = ret;
vcrGetMessage.len = net_message.cursize;
Sys_FileWrite (vcrFile, &vcrGetMessage, 24);
Sys_FileWrite (vcrFile, net_message.data, net_message.cursize);
}
}
else
{
if (recording)
{
vcrGetMessage.time = host_time;
vcrGetMessage.op = VCR_OP_GETMESSAGE;
vcrGetMessage.session = (long)sock;
vcrGetMessage.ret = ret;
Sys_FileWrite (vcrFile, &vcrGetMessage, 20);
}
}
return ret;
}
/*
* ====================
* NET_Init
* ====================
*/
void
NET_Init(void)
{
int i, num_inited;
int controlSocket;
qsocket_t *s;
i = COM_CheckParm("-port");
if (!i)
i = COM_CheckParm("-udpport");
if (i) {
if (i < com_argc - 1)
DEFAULTnet_hostport = Q_atoi(com_argv[i + 1]);
else
Sys_Error("%s: you must specify a number after -port", __func__);
}
net_hostport = DEFAULTnet_hostport;
if (COM_CheckParm("-listen") || cls.state == ca_dedicated)
listening = true;
net_numsockets = svs.maxclientslimit;
if (cls.state != ca_dedicated)
net_numsockets++;
SetNetTime();
for (i = 0; i < net_numsockets; i++) {
s = (qsocket_t *)Hunk_AllocName(sizeof(qsocket_t), "qsocket");
s->next = net_freeSockets;
net_freeSockets = s;
s->disconnected = true;
}
/* allocate space for network message buffer */
SZ_Alloc(&net_message, NET_MAXMESSAGE);
Cvar_RegisterVariable(&net_messagetimeout);
Cvar_RegisterVariable(&hostname);
Cmd_AddCommand("slist", NET_Slist_f);
Cmd_AddCommand("listen", NET_Listen_f);
Cmd_AddCommand("maxplayers", MaxPlayers_f);
Cmd_AddCommand("port", NET_Port_f);
/* initialize all the drivers */
num_inited = 0;
for (i = 0; i < net_numdrivers; i++) {
net_driver = &net_drivers[i];
controlSocket = net_driver->Init();
if (controlSocket == -1)
continue;
num_inited++;
net_driver->initialized = true;
net_driver->controlSock = controlSocket;
if (listening)
net_driver->Listen(true);
}
if (num_inited == 0 && cls.state == ca_dedicated)
Sys_Error("Network not available!");
if (*my_tcpip_address)
Con_DPrintf("TCP/IP address %s\n", my_tcpip_address);
}
void NET_Init (void)
{
int i;
int controlSocket;
qsocket_t *s;
if (COM_CheckParm("-playback"))
{
net_numdrivers = 1;
net_drivers[0].Init = VCR_Init;
}
if (COM_CheckParm("-record"))
recording = true;
i = COM_CheckParm ("-port");
if (!i)
i = COM_CheckParm ("-udpport");
if (!i)
i = COM_CheckParm ("-ipxport");
if (i)
{
if (i < com_argc-1)
DEFAULTnet_hostport = atoi (com_argv[i+1]);
else
Sys_Error ("NET_Init: you must specify a number after -port");
}
net_hostport = DEFAULTnet_hostport;
if (COM_CheckParm("-listen") || cls.state == ca_dedicated)
listening = true;
net_numsockets = svs.maxclientslimit;
if (cls.state != ca_dedicated)
net_numsockets++;
SetNetTime();
for (i = 0; i < net_numsockets; i++)
{
s = (qsocket_t *)Hunk_AllocName(sizeof(qsocket_t), "qsocket");
s->next = net_freeSockets;
net_freeSockets = s;
s->disconnected = true;
}
// allocate space for network message buffer
SZ_Alloc (&net_message, NET_MAXMESSAGE);
Cvar_RegisterVariable (&net_messagetimeout);
Cvar_RegisterVariable (&hostname);
Cvar_RegisterVariable (&config_com_port);
Cvar_RegisterVariable (&config_com_irq);
Cvar_RegisterVariable (&config_com_baud);
Cvar_RegisterVariable (&config_com_modem);
Cvar_RegisterVariable (&config_modem_dialtype);
Cvar_RegisterVariable (&config_modem_clear);
Cvar_RegisterVariable (&config_modem_init);
Cvar_RegisterVariable (&config_modem_hangup);
#ifdef IDGODS
Cvar_RegisterVariable (&idgods);
#endif
Cvar_RegisterVariable (&net_allowmultiple);
Cmd_AddCommand ("slist", NET_Slist_f);
Cmd_AddCommand ("listen", NET_Listen_f);
Cmd_AddCommand ("maxplayers", MaxPlayers_f);
Cmd_AddCommand ("port", NET_Port_f);
// initialize all the drivers
for (net_driverlevel=0 ; net_driverlevel<net_numdrivers ; net_driverlevel++)
{
controlSocket = net_drivers[net_driverlevel].Init();
if (controlSocket == -1)
continue;
net_drivers[net_driverlevel].initialized = true;
net_drivers[net_driverlevel].controlSock = controlSocket;
if (listening)
net_drivers[net_driverlevel].Listen (true);
}
if (*my_ipx_address)
Con_DPrintf("IPX address %s\n", my_ipx_address);
if (*my_tcpip_address)
Con_DPrintf("TCP/IP address %s\n", my_tcpip_address);
}
qsocket_t *
NET_Connect(const char *host)
{
qsocket_t *ret;
int i, n;
int numdrivers = net_numdrivers;
SetNetTime();
if (host && *host == 0)
host = NULL;
if (host) {
if (strcasecmp(host, "local") == 0) {
numdrivers = 1;
goto JustDoIt;
}
if (hostCacheCount) {
for (n = 0; n < hostCacheCount; n++)
if (strcasecmp(host, hostcache[n].name) == 0) {
host = hostcache[n].cname;
break;
}
if (n < hostCacheCount)
goto JustDoIt;
}
}
slistSilent = host ? true : false;
NET_Slist_f();
while (slistInProgress)
NET_Poll();
if (host == NULL) {
if (hostCacheCount != 1)
return NULL;
host = hostcache[0].cname;
Con_Printf("Connecting to...\n%s @ %s\n\n", hostcache[0].name, host);
}
if (hostCacheCount)
for (n = 0; n < hostCacheCount; n++)
if (strcasecmp(host, hostcache[n].name) == 0) {
host = hostcache[n].cname;
break;
}
JustDoIt:
for (i = 0; i < numdrivers; i++) {
net_driver = &net_drivers[i];
if (net_driver->initialized == false)
continue;
ret = net_driver->Connect(host);
if (ret)
return ret;
}
if (host) {
Con_Printf("\n");
PrintSlistHeader();
PrintSlist();
PrintSlistTrailer();
}
return NULL;
}
