minimal set needed for windows build
git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@21 fc73d0e0-1445-4013-8a0c-d673dee63da5
This commit is contained in:
Spoike
parent
fffb8897b9
commit
7ee6e8131b
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_dgrm.h
|
||||
|
||||
|
||||
int Datagram_Init (void);
|
||||
void Datagram_Listen (qboolean state);
|
||||
void Datagram_SearchForHosts (qboolean xmit);
|
||||
qsocket_t *Datagram_Connect (char *host);
|
||||
qsocket_t *Datagram_CheckNewConnections (void);
|
||||
int Datagram_GetMessage (qsocket_t *sock);
|
||||
int Datagram_SendMessage (qsocket_t *sock, sizebuf_t *data);
|
||||
int Datagram_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data);
|
||||
qboolean Datagram_CanSendMessage (qsocket_t *sock);
|
||||
qboolean Datagram_CanSendUnreliableMessage (qsocket_t *sock);
|
||||
void Datagram_Close (qsocket_t *sock);
|
||||
void Datagram_Shutdown (void);
|
||||
|
||||
qsocket_t *Datagram_BeginConnect (char *host);
|
||||
qsocket_t *Datagram_ContinueConnect (char *host);
|
||||
|
|
@ -0,0 +1,267 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_loop.c
|
||||
|
||||
#include "../client/quakedef.h"
|
||||
#if !(defined(CLIENTONLY) || defined(SERVERONLY))
|
||||
#ifdef NQPROT
|
||||
#include "net_loop.h"
|
||||
|
||||
qboolean localconnectpending = false;
|
||||
qsocket_t *loop_client = NULL;
|
||||
qsocket_t *loop_server = NULL;
|
||||
|
||||
int Loop_Init (void)
|
||||
{
|
||||
if (isDedicated)
|
||||
return -1;
|
||||
// if (cls.state == ca_dedicated)
|
||||
// return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void Loop_Shutdown (void)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void Loop_Listen (qboolean state)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void Loop_SearchForHosts (qboolean xmit)
|
||||
{
|
||||
if (!sv.active)
|
||||
return;
|
||||
|
||||
hostCacheCount = 1;
|
||||
if (Q_strcmp(hostname.string, "UNNAMED") == 0)
|
||||
Q_strcpy(hostcache[0].name, "local");
|
||||
else
|
||||
Q_strcpy(hostcache[0].name, hostname.string);
|
||||
Q_strcpy(hostcache[0].map, sv.name);
|
||||
hostcache[0].users = net_activeconnections;
|
||||
hostcache[0].maxusers = 32;
|
||||
hostcache[0].driver = net_driverlevel;
|
||||
Q_strcpy(hostcache[0].cname, "local");
|
||||
}
|
||||
|
||||
|
||||
qsocket_t *Loop_Connect (char *host)
|
||||
{
|
||||
if (Q_strcmp(host,"local") != 0)
|
||||
return NULL;
|
||||
|
||||
if (localconnectpending && loop_client && loop_server)
|
||||
return loop_client;
|
||||
|
||||
if (!loop_client)
|
||||
{
|
||||
if ((loop_client = NET_NewQSocket ()) == NULL)
|
||||
{
|
||||
Con_Printf("Loop_Connect: no qsocket available\n");
|
||||
return NULL;
|
||||
}
|
||||
Q_strcpy (loop_client->address, "localhost");
|
||||
}
|
||||
else
|
||||
loop_client->disconnected = false;
|
||||
loop_client->receiveMessageLength = 0;
|
||||
loop_client->sendMessageLength = 0;
|
||||
loop_client->canSend = true;
|
||||
|
||||
if (!loop_server)
|
||||
{
|
||||
if ((loop_server = NET_NewQSocket ()) == NULL)
|
||||
{
|
||||
Con_Printf("Loop_Connect: no qsocket available\n");
|
||||
return NULL;
|
||||
}
|
||||
Q_strcpy (loop_server->address, "LOCAL");
|
||||
}
|
||||
else
|
||||
loop_server->disconnected = false;
|
||||
loop_server->receiveMessageLength = 0;
|
||||
loop_server->sendMessageLength = 0;
|
||||
loop_server->canSend = true;
|
||||
|
||||
loop_client->driverdata = (void *)loop_server;
|
||||
loop_server->driverdata = (void *)loop_client;
|
||||
|
||||
loop_server->qwprotocol = loop_client->qwprotocol = true;
|
||||
|
||||
localconnectpending = true;
|
||||
|
||||
return loop_client;
|
||||
}
|
||||
|
||||
|
||||
qsocket_t *Loop_CheckNewConnections (void)
|
||||
{
|
||||
if (!localconnectpending || !loop_server || !loop_client)
|
||||
return NULL;
|
||||
|
||||
localconnectpending = false;
|
||||
loop_server->sendMessageLength = 0;
|
||||
loop_server->receiveMessageLength = 0;
|
||||
loop_server->canSend = true;
|
||||
loop_client->sendMessageLength = 0;
|
||||
loop_client->receiveMessageLength = 0;
|
||||
loop_client->canSend = true;
|
||||
return loop_server;
|
||||
}
|
||||
|
||||
|
||||
static int IntAlign(int value)
|
||||
{
|
||||
return (value + (sizeof(int) - 1)) & (~(sizeof(int) - 1));
|
||||
}
|
||||
|
||||
|
||||
int Loop_GetMessage (qsocket_t *sock)
|
||||
{
|
||||
int ret;
|
||||
int length;
|
||||
|
||||
if (sock->receiveMessageLength == 0)
|
||||
return 0;
|
||||
|
||||
ret = sock->receiveMessage[0];
|
||||
length = sock->receiveMessage[1] + (sock->receiveMessage[2] << 8);
|
||||
// alignment qbyte skipped here
|
||||
SZ_Clear (&net_message);
|
||||
SZ_Write (&net_message, &sock->receiveMessage[4], length);
|
||||
|
||||
length = IntAlign(length + 4);
|
||||
sock->receiveMessageLength -= length;
|
||||
|
||||
if (sock->receiveMessageLength)
|
||||
Q_memcpy(sock->receiveMessage, &sock->receiveMessage[length], sock->receiveMessageLength);
|
||||
|
||||
if (sock->driverdata && ret == 1)
|
||||
((qsocket_t *)sock->driverdata)->canSend = true;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int Loop_SendMessage (qsocket_t *sock, sizebuf_t *data)
|
||||
{
|
||||
qbyte *buffer;
|
||||
int *bufferLength;
|
||||
|
||||
if (!sock->driverdata)
|
||||
return -1;
|
||||
|
||||
bufferLength = &((qsocket_t *)sock->driverdata)->receiveMessageLength;
|
||||
|
||||
if ((*bufferLength + data->cursize + 4) > NET_MAXMESSAGE)
|
||||
Sys_Error("Loop_SendMessage: overflow\n");
|
||||
|
||||
buffer = ((qsocket_t *)sock->driverdata)->receiveMessage + *bufferLength;
|
||||
|
||||
// message type
|
||||
*buffer++ = 1;
|
||||
|
||||
// length
|
||||
*buffer++ = data->cursize & 0xff;
|
||||
*buffer++ = data->cursize >> 8;
|
||||
|
||||
// align
|
||||
buffer++;
|
||||
|
||||
// message
|
||||
Q_memcpy(buffer, data->data, data->cursize);
|
||||
*bufferLength = IntAlign(*bufferLength + data->cursize + 4);
|
||||
|
||||
sock->canSend = false;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int Loop_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data)
|
||||
{
|
||||
qbyte *buffer;
|
||||
int *bufferLength;
|
||||
|
||||
if (!sock->driverdata)
|
||||
return -1;
|
||||
|
||||
bufferLength = &((qsocket_t *)sock->driverdata)->receiveMessageLength;
|
||||
|
||||
if ((*bufferLength + data->cursize + sizeof(qbyte) + sizeof(short)) > NET_MAXMESSAGE)
|
||||
return 0;
|
||||
|
||||
buffer = ((qsocket_t *)sock->driverdata)->receiveMessage + *bufferLength;
|
||||
|
||||
// message type
|
||||
*buffer++ = 2;
|
||||
|
||||
// length
|
||||
*buffer++ = data->cursize & 0xff;
|
||||
*buffer++ = data->cursize >> 8;
|
||||
|
||||
// align
|
||||
buffer++;
|
||||
|
||||
// message
|
||||
Q_memcpy(buffer, data->data, data->cursize);
|
||||
*bufferLength = IntAlign(*bufferLength + data->cursize + 4);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
qboolean Loop_CanSendMessage (qsocket_t *sock)
|
||||
{
|
||||
if (!sock->driverdata)
|
||||
return false;
|
||||
return sock->canSend;
|
||||
}
|
||||
|
||||
|
||||
qboolean Loop_CanSendUnreliableMessage (qsocket_t *sock)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void Loop_Close (qsocket_t *sock)
|
||||
{
|
||||
localconnectpending = false;
|
||||
|
||||
if (sock->driverdata)
|
||||
((qsocket_t *)sock->driverdata)->driverdata = NULL;
|
||||
sock->receiveMessageLength = 0;
|
||||
sock->sendMessageLength = 0;
|
||||
sock->canSend = true;
|
||||
if (sock == loop_client)
|
||||
loop_client = NULL;
|
||||
else
|
||||
loop_server = NULL;
|
||||
|
||||
if (loop_server)
|
||||
loop_server->disconnected=2;
|
||||
else if (loop_client)
|
||||
loop_client->disconnected=2;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_loop.h
|
||||
|
||||
#if !defined(SERVERONLY) && !defined(CLIENTONLY)
|
||||
|
||||
int Loop_Init (void);
|
||||
void Loop_Listen (qboolean state);
|
||||
void Loop_SearchForHosts (qboolean xmit);
|
||||
qsocket_t *Loop_Connect (char *host);
|
||||
qsocket_t *Loop_CheckNewConnections (void);
|
||||
int Loop_GetMessage (qsocket_t *sock);
|
||||
int Loop_SendMessage (qsocket_t *sock, sizebuf_t *data);
|
||||
int Loop_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data);
|
||||
qboolean Loop_CanSendMessage (qsocket_t *sock);
|
||||
qboolean Loop_CanSendUnreliableMessage (qsocket_t *sock);
|
||||
void Loop_Close (qsocket_t *sock);
|
||||
void Loop_Shutdown (void);
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,33 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_ser.h
|
||||
|
||||
int Serial_Init (void);
|
||||
void Serial_Listen (qboolean state);
|
||||
void Serial_SearchForHosts (qboolean xmit);
|
||||
qsocket_t *Serial_Connect (char *host);
|
||||
qsocket_t *Serial_CheckNewConnections (void);
|
||||
int Serial_GetMessage (qsocket_t *sock);
|
||||
int Serial_SendMessage (qsocket_t *sock, sizebuf_t *data);
|
||||
int Serial_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data);
|
||||
qboolean Serial_CanSendMessage (qsocket_t *sock);
|
||||
qboolean Serial_CanSendUnreliableMessage (qsocket_t *sock);
|
||||
void Serial_Close (qsocket_t *sock);
|
||||
void Serial_Shutdown (void);
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_vcr.c
|
||||
|
||||
#include "../client/quakedef.h"
|
||||
#ifdef NQPROT
|
||||
#include "net_vcr.h"
|
||||
|
||||
extern int vcrFile;
|
||||
|
||||
// This is the playback portion of the VCR. It reads the file produced
|
||||
// by the recorder and plays it back to the host. The recording contains
|
||||
// everything necessary (events, timestamps, and data) to duplicate the game
|
||||
// from the viewpoint of everything above the network layer.
|
||||
|
||||
static struct
|
||||
{
|
||||
double time;
|
||||
int op;
|
||||
long session;
|
||||
} next;
|
||||
|
||||
int VCR_Init (void)
|
||||
{
|
||||
net_drivers[0].Init = VCR_Init;
|
||||
|
||||
net_drivers[0].SearchForHosts = VCR_SearchForHosts;
|
||||
net_drivers[0].Connect = VCR_Connect;
|
||||
net_drivers[0].CheckNewConnections = VCR_CheckNewConnections;
|
||||
net_drivers[0].QGetMessage = VCR_GetMessage;
|
||||
net_drivers[0].QSendMessage = VCR_SendMessage;
|
||||
net_drivers[0].CanSendMessage = VCR_CanSendMessage;
|
||||
net_drivers[0].Close = VCR_Close;
|
||||
net_drivers[0].Shutdown = VCR_Shutdown;
|
||||
|
||||
Sys_FileRead(vcrFile, &next, sizeof(next));
|
||||
return 0;
|
||||
}
|
||||
|
||||
void VCR_ReadNext (void)
|
||||
{
|
||||
if (Sys_FileRead(vcrFile, &next, sizeof(next)) == 0)
|
||||
{
|
||||
next.op = 255;
|
||||
Sys_Error ("=== END OF PLAYBACK===\n");
|
||||
}
|
||||
if (next.op < 1 || next.op > VCR_MAX_MESSAGE)
|
||||
Sys_Error ("VCR_ReadNext: bad op");
|
||||
}
|
||||
|
||||
|
||||
void VCR_Listen (qboolean state)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void VCR_Shutdown (void)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
int VCR_GetMessage (qsocket_t *sock)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (realtime != next.time || next.op != VCR_OP_GETMESSAGE || next.session != *(long *)(&sock->driverdata))
|
||||
Sys_Error ("VCR missmatch");
|
||||
|
||||
Sys_FileRead(vcrFile, &ret, sizeof(int));
|
||||
if (ret != 1)
|
||||
{
|
||||
VCR_ReadNext ();
|
||||
return ret;
|
||||
}
|
||||
|
||||
Sys_FileRead(vcrFile, &net_message.cursize, sizeof(int));
|
||||
Sys_FileRead(vcrFile, net_message.data, net_message.cursize);
|
||||
|
||||
VCR_ReadNext ();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int VCR_SendMessage (qsocket_t *sock, sizebuf_t *data)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (realtime != next.time || next.op != VCR_OP_SENDMESSAGE || next.session != *(long *)(&sock->driverdata))
|
||||
Sys_Error ("VCR missmatch");
|
||||
|
||||
Sys_FileRead(vcrFile, &ret, sizeof(int));
|
||||
|
||||
VCR_ReadNext ();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
qboolean VCR_CanSendMessage (qsocket_t *sock)
|
||||
{
|
||||
qboolean ret;
|
||||
|
||||
if (realtime != next.time || next.op != VCR_OP_CANSENDMESSAGE || next.session != *(long *)(&sock->driverdata))
|
||||
Sys_Error ("VCR missmatch");
|
||||
|
||||
Sys_FileRead(vcrFile, &ret, sizeof(int));
|
||||
|
||||
VCR_ReadNext ();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
void VCR_Close (qsocket_t *sock)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void VCR_SearchForHosts (qboolean xmit)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
qsocket_t *VCR_Connect (char *host)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
qsocket_t *VCR_CheckNewConnections (void)
|
||||
{
|
||||
qsocket_t *sock;
|
||||
|
||||
if (realtime != next.time || next.op != VCR_OP_CONNECT)
|
||||
Sys_Error ("VCR missmatch");
|
||||
|
||||
if (!next.session)
|
||||
{
|
||||
VCR_ReadNext ();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
sock = NET_NewQSocket ();
|
||||
*(long *)(&sock->driverdata) = next.session;
|
||||
|
||||
Sys_FileRead (vcrFile, sock->address, NET_NAMELEN);
|
||||
VCR_ReadNext ();
|
||||
|
||||
return sock;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_vcr.h
|
||||
|
||||
#define VCR_OP_CONNECT 1
|
||||
#define VCR_OP_GETMESSAGE 2
|
||||
#define VCR_OP_SENDMESSAGE 3
|
||||
#define VCR_OP_CANSENDMESSAGE 4
|
||||
#define VCR_MAX_MESSAGE 4
|
||||
|
||||
int VCR_Init (void);
|
||||
void VCR_Listen (qboolean state);
|
||||
void VCR_SearchForHosts (qboolean xmit);
|
||||
qsocket_t *VCR_Connect (char *host);
|
||||
qsocket_t *VCR_CheckNewConnections (void);
|
||||
int VCR_GetMessage (qsocket_t *sock);
|
||||
int VCR_SendMessage (qsocket_t *sock, sizebuf_t *data);
|
||||
qboolean VCR_CanSendMessage (qsocket_t *sock);
|
||||
void VCR_Close (qsocket_t *sock);
|
||||
void VCR_Shutdown (void);
|
||||
|
|
@ -0,0 +1,765 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
#include "../client/quakedef.h"
|
||||
#ifdef NQPROT
|
||||
#include "../client/winquake.h"
|
||||
|
||||
#include "net_loop.h"
|
||||
#include "net_dgrm.h"
|
||||
#include "net_ser.h"
|
||||
|
||||
#define Sys_FloatTime Sys_DoubleTime
|
||||
|
||||
net_driver_t net_drivers[MAX_NET_DRIVERS] =
|
||||
{
|
||||
#if !defined(SERVERONLY) && !defined(CLIENTONLY)
|
||||
{
|
||||
"Loopback",
|
||||
false,
|
||||
Loop_Init,
|
||||
Loop_Listen,
|
||||
Loop_SearchForHosts,
|
||||
Loop_Connect,
|
||||
Loop_CheckNewConnections,
|
||||
Loop_GetMessage,
|
||||
Loop_SendMessage,
|
||||
Loop_SendUnreliableMessage,
|
||||
Loop_CanSendMessage,
|
||||
Loop_CanSendUnreliableMessage,
|
||||
Loop_Close,
|
||||
Loop_Shutdown
|
||||
}
|
||||
,
|
||||
#endif
|
||||
{
|
||||
"Datagram",
|
||||
false,
|
||||
Datagram_Init,
|
||||
Datagram_Listen,
|
||||
Datagram_SearchForHosts,
|
||||
Datagram_Connect,
|
||||
Datagram_CheckNewConnections,
|
||||
Datagram_GetMessage,
|
||||
Datagram_SendMessage,
|
||||
Datagram_SendUnreliableMessage,
|
||||
Datagram_CanSendMessage,
|
||||
Datagram_CanSendUnreliableMessage,
|
||||
Datagram_Close,
|
||||
Datagram_Shutdown,
|
||||
|
||||
Datagram_BeginConnect,
|
||||
Datagram_ContinueConnect
|
||||
}
|
||||
};
|
||||
|
||||
#if !defined(SERVERONLY) && !defined(CLIENTONLY)
|
||||
int net_numdrivers = 2;
|
||||
#else
|
||||
int net_numdrivers = 1;
|
||||
#endif
|
||||
|
||||
|
||||
#include "net_wins.h"
|
||||
#include "net_wipx.h"
|
||||
|
||||
net_landriver_t net_landrivers[MAX_NET_DRIVERS] =
|
||||
{
|
||||
{
|
||||
"Winsock TCPIP",
|
||||
false,
|
||||
0,
|
||||
WINS_Init,
|
||||
WINS_Shutdown,
|
||||
WINS_Listen,
|
||||
WINS_OpenSocket,
|
||||
WINS_CloseSocket,
|
||||
WINS_Connect,
|
||||
WINS_CheckNewConnections,
|
||||
WINS_Read,
|
||||
WINS_Write,
|
||||
WINS_Broadcast,
|
||||
WINS_AddrToString,
|
||||
WINS_StringToAddr,
|
||||
WINS_GetSocketAddr,
|
||||
WINS_GetNameFromAddr,
|
||||
WINS_GetAddrFromName,
|
||||
WINS_AddrCompare,
|
||||
WINS_GetSocketPort,
|
||||
WINS_SetSocketPort
|
||||
}
|
||||
#ifdef _WIN32
|
||||
,
|
||||
{
|
||||
"Winsock IPX",
|
||||
false,
|
||||
0,
|
||||
WIPX_Init,
|
||||
WIPX_Shutdown,
|
||||
WIPX_Listen,
|
||||
WIPX_OpenSocket,
|
||||
WIPX_CloseSocket,
|
||||
WIPX_Connect,
|
||||
WIPX_CheckNewConnections,
|
||||
WIPX_Read,
|
||||
WIPX_Write,
|
||||
WIPX_Broadcast,
|
||||
WIPX_AddrToString,
|
||||
WIPX_StringToAddr,
|
||||
WIPX_GetSocketAddr,
|
||||
WIPX_GetNameFromAddr,
|
||||
WIPX_GetAddrFromName,
|
||||
WIPX_AddrCompare,
|
||||
WIPX_GetSocketPort,
|
||||
WIPX_SetSocketPort
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifdef _WIN32
|
||||
int net_numlandrivers = 2;
|
||||
#else
|
||||
int net_numlandrivers = 1;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef CLIENTONLY
|
||||
extern cvar_t hostname;
|
||||
#endif
|
||||
|
||||
#define MAXHOSTNAMELEN 256
|
||||
|
||||
static int net_acceptsocket = -1; // socket for fielding new connections
|
||||
static int net_controlsocket;
|
||||
static int net_broadcastsocket = 0;
|
||||
static struct sockaddr_qstorage broadcastaddr;
|
||||
|
||||
static unsigned long myAddr;
|
||||
|
||||
#ifdef _WIN32
|
||||
qboolean winsock_lib_initialized;
|
||||
|
||||
int (PASCAL *pWSAStartup)(WORD wVersionRequired, LPWSADATA lpWSAData);
|
||||
int (PASCAL *pWSACleanup)(void);
|
||||
int (PASCAL *pWSAGetLastError)(void);
|
||||
SOCKET (PASCAL *psocket)(int af, int type, int protocol);
|
||||
int (PASCAL *pioctlsocket)(SOCKET s, long cmd, u_long *argp);
|
||||
int (PASCAL *psetsockopt)(SOCKET s, int level, int optname,
|
||||
const char * optval, int optlen);
|
||||
int (PASCAL *precvfrom)(SOCKET s, char * buf, int len, int flags,
|
||||
struct sockaddr *from, int * fromlen);
|
||||
int (PASCAL *psendto)(SOCKET s, const char * buf, int len, int flags,
|
||||
const struct sockaddr *to, int tolen);
|
||||
int (PASCAL *pclosesocket)(SOCKET s);
|
||||
int (PASCAL *pgethostname)(char * name, int namelen);
|
||||
struct hostent * (PASCAL *pgethostbyname)(const char * name);
|
||||
struct hostent * (PASCAL *pgethostbyaddr)(const char * addr,
|
||||
int len, int type);
|
||||
int (PASCAL *pgetsockname)(SOCKET s, struct sockaddr *name,
|
||||
int * namelen);
|
||||
|
||||
int winsock_initialized = 0;
|
||||
WSADATA winsockdata;
|
||||
#define qerrno pWSAGetLastError()
|
||||
|
||||
#define EWOULDBLOCK WSAEWOULDBLOCK
|
||||
#define ECONNREFUSED WSAECONNREFUSED
|
||||
#else
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netdb.h>
|
||||
#include <sys/param.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
#define SOCKET_ERROR -1
|
||||
|
||||
#define qerrno errno
|
||||
|
||||
#define psocket socket
|
||||
#define pgethostbyaddrpsocket gethostbyaddrpsocket
|
||||
#define pgethostbyaddrpioctlsocket gethostbyaddrpioctlsocket
|
||||
#define psetsockopt setsockopt
|
||||
#define precvfrom recvfrom
|
||||
#define psendto sendto
|
||||
#define pclosesocket close
|
||||
#define pgethostname gethostname
|
||||
#define pgethostbyname gethostbyname
|
||||
#define pgethostbyaddr gethostbyaddr
|
||||
#define pgetsockname getsockname
|
||||
#define pioctlsocket ioctl
|
||||
|
||||
#endif
|
||||
|
||||
#include "net_wins.h"
|
||||
|
||||
//=============================================================================
|
||||
|
||||
static double blocktime;
|
||||
#ifdef _WIN32
|
||||
BOOL PASCAL BlockingHook(void)
|
||||
{
|
||||
MSG msg;
|
||||
BOOL ret;
|
||||
|
||||
if ((Sys_FloatTime() - blocktime) > 2.0)
|
||||
{
|
||||
WSACancelBlockingCall();
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* get the next message, if any */
|
||||
ret = (BOOL) PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
|
||||
|
||||
/* if we got one, process it */
|
||||
if (ret) {
|
||||
TranslateMessage(&msg);
|
||||
DispatchMessage(&msg);
|
||||
}
|
||||
|
||||
/* TRUE if we got a message */
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
void WINS_GetLocalAddress()
|
||||
{
|
||||
struct hostent *local = NULL;
|
||||
char buff[MAXHOSTNAMELEN];
|
||||
unsigned long addr;
|
||||
|
||||
if (myAddr != INADDR_ANY)
|
||||
return;
|
||||
|
||||
if (pgethostname(buff, MAXHOSTNAMELEN) == SOCKET_ERROR)
|
||||
return;
|
||||
|
||||
blocktime = Sys_FloatTime();
|
||||
#ifdef _WIN32
|
||||
WSASetBlockingHook(BlockingHook);
|
||||
#endif
|
||||
local = pgethostbyname(buff);
|
||||
#ifdef _WIN32
|
||||
WSAUnhookBlockingHook();
|
||||
#endif
|
||||
if (local == NULL)
|
||||
return;
|
||||
|
||||
myAddr = *(int *)local->h_addr_list[0];
|
||||
|
||||
addr = ntohl(myAddr);
|
||||
sprintf(my_tcpip_address, "%d.%d.%d.%d", (qbyte)((addr >> 24) & 0xff), (qbyte)((addr >> 16) & 0xff), (qbyte)((addr >> 8) & 0xff), (qbyte)(addr & 0xff));
|
||||
}
|
||||
|
||||
|
||||
int WINS_Init (void)
|
||||
{
|
||||
int i;
|
||||
char buff[MAXHOSTNAMELEN];
|
||||
char *p;
|
||||
|
||||
#ifdef _WIN32
|
||||
int r;
|
||||
WORD wVersionRequested;
|
||||
HINSTANCE hInst;
|
||||
|
||||
// initialize the Winsock function vectors (we do this instead of statically linking
|
||||
// so we can run on Win 3.1, where there isn't necessarily Winsock)
|
||||
hInst = LoadLibrary("wsock32.dll");
|
||||
|
||||
if (hInst == NULL)
|
||||
{
|
||||
Con_Printf ("Failed to load winsock.dll\n");
|
||||
winsock_lib_initialized = false;
|
||||
return -1;
|
||||
}
|
||||
|
||||
winsock_lib_initialized = true;
|
||||
|
||||
pWSAStartup = (void *)GetProcAddress(hInst, "WSAStartup");
|
||||
pWSACleanup = (void *)GetProcAddress(hInst, "WSACleanup");
|
||||
pWSAGetLastError = (void *)GetProcAddress(hInst, "WSAGetLastError");
|
||||
psocket = (void *)GetProcAddress(hInst, "socket");
|
||||
pioctlsocket = (void *)GetProcAddress(hInst, "ioctlsocket");
|
||||
psetsockopt = (void *)GetProcAddress(hInst, "setsockopt");
|
||||
precvfrom = (void *)GetProcAddress(hInst, "recvfrom");
|
||||
psendto = (void *)GetProcAddress(hInst, "sendto");
|
||||
pclosesocket = (void *)GetProcAddress(hInst, "closesocket");
|
||||
pgethostname = (void *)GetProcAddress(hInst, "gethostname");
|
||||
pgethostbyname = (void *)GetProcAddress(hInst, "gethostbyname");
|
||||
pgethostbyaddr = (void *)GetProcAddress(hInst, "gethostbyaddr");
|
||||
pgetsockname = (void *)GetProcAddress(hInst, "getsockname");
|
||||
|
||||
if (!pWSAStartup || !pWSACleanup || !pWSAGetLastError ||
|
||||
!psocket || !pioctlsocket || !psetsockopt ||
|
||||
!precvfrom || !psendto || !pclosesocket ||
|
||||
!pgethostname || !pgethostbyname || !pgethostbyaddr ||
|
||||
!pgetsockname)
|
||||
{
|
||||
Con_Printf ("Couldn't GetProcAddress from winsock.dll\n");
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (COM_CheckParm ("-noudp"))
|
||||
return -1;
|
||||
|
||||
#ifdef _WIN32
|
||||
if (winsock_initialized == 0)
|
||||
{
|
||||
wVersionRequested = MAKEWORD(1, 1);
|
||||
|
||||
r = pWSAStartup (MAKEWORD(1, 1), &winsockdata);
|
||||
|
||||
if (r)
|
||||
{
|
||||
Con_Printf ("Winsock initialization failed.\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
winsock_initialized++;
|
||||
#endif
|
||||
|
||||
// determine my name
|
||||
if (pgethostname(buff, MAXHOSTNAMELEN) == SOCKET_ERROR)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
Con_DPrintf ("Winsock TCP/IP Initialization failed.\n");
|
||||
if (--winsock_initialized == 0)
|
||||
pWSACleanup ();
|
||||
#else
|
||||
Con_DPrintf ("TCP/IP failed to get hostname.\n");
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
#ifndef CLIENTONLY
|
||||
// if the quake hostname isn't set, set it to the machine name
|
||||
if (Q_strcmp(hostname.string, "UNNAMED") == 0)
|
||||
{
|
||||
// see if it's a text IP address (well, close enough)
|
||||
for (p = buff; *p; p++)
|
||||
if ((*p < '0' || *p > '9') && *p != '.')
|
||||
break;
|
||||
|
||||
// if it is a real name, strip off the domain; we only want the host
|
||||
if (*p)
|
||||
{
|
||||
for (i = 0; i < 15; i++)
|
||||
if (buff[i] == '.')
|
||||
break;
|
||||
buff[i] = 0;
|
||||
}
|
||||
Cvar_Set (&hostname, buff);
|
||||
}
|
||||
#endif
|
||||
i = COM_CheckParm ("-nqip");
|
||||
if (i)
|
||||
{
|
||||
if (i < com_argc-1)
|
||||
{
|
||||
myAddr = inet_addr(com_argv[i+1]);
|
||||
if (myAddr == INADDR_NONE)
|
||||
Sys_Error ("%s is not a valid IP address", com_argv[i+1]);
|
||||
strcpy(my_tcpip_address, com_argv[i+1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
Sys_Error ("NET_Init: you must specify an IP address after -ip");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
myAddr = INADDR_ANY;
|
||||
strcpy(my_tcpip_address, "INADDR_ANY");
|
||||
}
|
||||
|
||||
if ((net_controlsocket = WINS_OpenSocket (0)) == -1)
|
||||
{
|
||||
Con_Printf("WINS_Init: Unable to open control socket\n");
|
||||
#ifdef _WIN32
|
||||
if (--winsock_initialized == 0)
|
||||
pWSACleanup ();
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
|
||||
((struct sockaddr_in *)&broadcastaddr)->sin_family = AF_INET;
|
||||
((struct sockaddr_in *)&broadcastaddr)->sin_addr.s_addr = INADDR_BROADCAST;
|
||||
((struct sockaddr_in *)&broadcastaddr)->sin_port = htons((unsigned short)net_hostport);
|
||||
|
||||
Con_Printf("Winsock TCP/IP Initialized\n");
|
||||
tcpipAvailable = true;
|
||||
|
||||
return net_controlsocket;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void WINS_Shutdown (void)
|
||||
{
|
||||
WINS_Listen (false);
|
||||
WINS_CloseSocket (net_controlsocket);
|
||||
#ifdef _WIN32
|
||||
if (--winsock_initialized == 0)
|
||||
pWSACleanup ();
|
||||
#endif
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void WINS_Listen (qboolean state)
|
||||
{
|
||||
// enable listening
|
||||
if (state)
|
||||
{
|
||||
if (net_acceptsocket != -1)
|
||||
return;
|
||||
WINS_GetLocalAddress();
|
||||
if ((net_acceptsocket = WINS_OpenSocket (net_hostport)) == -1)
|
||||
Con_Printf ("WINS_Listen: Unable to open accept socket\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// disable listening
|
||||
if (net_acceptsocket == -1)
|
||||
return;
|
||||
WINS_CloseSocket (net_acceptsocket);
|
||||
net_acceptsocket = -1;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_OpenSocket (int port)
|
||||
{
|
||||
int newsocket;
|
||||
struct sockaddr_in address;
|
||||
u_long _true = 1;
|
||||
|
||||
if ((newsocket = psocket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
|
||||
return -1;
|
||||
|
||||
if (pioctlsocket (newsocket, FIONBIO, &_true) == -1)
|
||||
goto ErrorReturn;
|
||||
|
||||
address.sin_family = AF_INET;
|
||||
address.sin_addr.s_addr = myAddr;
|
||||
address.sin_port = htons((unsigned short)port);
|
||||
if( bind (newsocket, (void *)&address, sizeof(address)) == 0)
|
||||
return newsocket;
|
||||
|
||||
Con_Printf ("Unable to bind to %s\n", WINS_AddrToString((struct sockaddr_qstorage *)&address));
|
||||
ErrorReturn:
|
||||
pclosesocket (newsocket);
|
||||
return -1;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_CloseSocket (int socket)
|
||||
{
|
||||
if (socket == net_broadcastsocket)
|
||||
net_broadcastsocket = 0;
|
||||
return pclosesocket (socket);
|
||||
}
|
||||
|
||||
|
||||
//=============================================================================
|
||||
/*
|
||||
============
|
||||
PartialIPAddress
|
||||
|
||||
this lets you type only as much of the net address as required, using
|
||||
the local network components to fill in the rest
|
||||
============
|
||||
*/
|
||||
static int PartialIPAddress (char *in, struct sockaddr_qstorage *hostaddr)
|
||||
{
|
||||
char buff[256];
|
||||
char *b;
|
||||
int addr;
|
||||
int num;
|
||||
int mask;
|
||||
int run;
|
||||
int port;
|
||||
|
||||
buff[0] = '.';
|
||||
b = buff;
|
||||
strcpy(buff+1, in);
|
||||
if (buff[1] == '.')
|
||||
b++;
|
||||
|
||||
addr = 0;
|
||||
mask=-1;
|
||||
while (*b == '.')
|
||||
{
|
||||
b++;
|
||||
num = 0;
|
||||
run = 0;
|
||||
while (!( *b < '0' || *b > '9'))
|
||||
{
|
||||
num = num*10 + *b++ - '0';
|
||||
if (++run > 3)
|
||||
return -1;
|
||||
}
|
||||
if ((*b < '0' || *b > '9') && *b != '.' && *b != ':' && *b != 0)
|
||||
return -1;
|
||||
if (num < 0 || num > 255)
|
||||
return -1;
|
||||
mask<<=8;
|
||||
addr = (addr<<8) + num;
|
||||
}
|
||||
|
||||
if (*b++ == ':')
|
||||
port = Q_atoi(b);
|
||||
else
|
||||
port = net_hostport;
|
||||
|
||||
hostaddr->sa_family = AF_INET;
|
||||
((struct sockaddr_in *)hostaddr)->sin_port = htons((short)port);
|
||||
((struct sockaddr_in *)hostaddr)->sin_addr.s_addr = (myAddr & htonl(mask)) | htonl(addr);
|
||||
|
||||
return 0;
|
||||
}
|
||||
//=============================================================================
|
||||
|
||||
int WINS_Connect (int socket, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_CheckNewConnections (void)
|
||||
{
|
||||
char buf[4096];
|
||||
|
||||
if (net_acceptsocket == -1)
|
||||
return -1;
|
||||
|
||||
if (precvfrom (net_acceptsocket, buf, sizeof(buf), MSG_PEEK, NULL, NULL) > 0)
|
||||
{
|
||||
return net_acceptsocket;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_Read (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int addrlen = sizeof (struct sockaddr_qstorage);
|
||||
int ret;
|
||||
|
||||
ret = precvfrom (socket, buf, len, 0, (struct sockaddr *)addr, &addrlen);
|
||||
if (ret == -1)
|
||||
{
|
||||
if (qerrno == EWOULDBLOCK || qerrno == ECONNREFUSED)
|
||||
return 0;
|
||||
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_MakeSocketBroadcastCapable (int socket)
|
||||
{
|
||||
int i = 1;
|
||||
|
||||
// make this socket broadcast capable
|
||||
if (psetsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) < 0)
|
||||
return -1;
|
||||
net_broadcastsocket = socket;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_Broadcast (int socket, qbyte *buf, int len)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (socket != net_broadcastsocket)
|
||||
{
|
||||
if (net_broadcastsocket != 0)
|
||||
Sys_Error("Attempted to use multiple broadcasts sockets\n");
|
||||
WINS_GetLocalAddress();
|
||||
ret = WINS_MakeSocketBroadcastCapable (socket);
|
||||
if (ret == -1)
|
||||
{
|
||||
Con_Printf("Unable to make socket broadcast capable\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return WINS_Write (socket, buf, len, &broadcastaddr);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_Write (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = psendto (socket, buf, len, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_qstorage));
|
||||
if (ret == -1)
|
||||
if (qerrno == EWOULDBLOCK)
|
||||
return 0;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
char *WINS_AddrToString (struct sockaddr_qstorage *addr)
|
||||
{
|
||||
static char buffer[22];
|
||||
int haddr;
|
||||
|
||||
haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
|
||||
sprintf(buffer, "%d.%d.%d.%d:%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff, ntohs(((struct sockaddr_in *)addr)->sin_port));
|
||||
return buffer;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_StringToAddr (char *string, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int ha1, ha2, ha3, ha4, hp;
|
||||
int ipaddr;
|
||||
|
||||
sscanf(string, "%d.%d.%d.%d:%d", &ha1, &ha2, &ha3, &ha4, &hp);
|
||||
ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
|
||||
|
||||
addr->sa_family = AF_INET;
|
||||
((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
|
||||
((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)hp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_GetSocketAddr (int socket, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int addrlen = sizeof(struct sockaddr_qstorage);
|
||||
unsigned int a;
|
||||
|
||||
Q_memset(addr, 0, sizeof(struct sockaddr_qstorage));
|
||||
pgetsockname(socket, (struct sockaddr *)addr, &addrlen);
|
||||
a = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
|
||||
if (a == 0 || a == inet_addr("127.0.0.1"))
|
||||
((struct sockaddr_in *)addr)->sin_addr.s_addr = myAddr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_GetNameFromAddr (struct sockaddr_qstorage *addr, char *name)
|
||||
{
|
||||
struct hostent *hostentry;
|
||||
|
||||
hostentry = pgethostbyaddr ((char *)&((struct sockaddr_in *)addr)->sin_addr, sizeof(struct in_addr), AF_INET);
|
||||
if (hostentry)
|
||||
{
|
||||
Q_strncpyz (name, (char *)hostentry->h_name, NET_NAMELEN);
|
||||
return 0;
|
||||
}
|
||||
|
||||
Q_strcpy (name, WINS_AddrToString (addr));
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_GetAddrFromName(char *name, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
struct hostent *hostentry;
|
||||
|
||||
if (name[0] >= '0' && name[0] <= '9')
|
||||
return PartialIPAddress (name, addr);
|
||||
|
||||
hostentry = pgethostbyname (name);
|
||||
if (!hostentry)
|
||||
return -1;
|
||||
|
||||
addr->sa_family = AF_INET;
|
||||
((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)net_hostport);
|
||||
((struct sockaddr_in *)addr)->sin_addr.s_addr = *(int *)hostentry->h_addr_list[0];
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_AddrCompare (struct sockaddr_qstorage *addr1, struct sockaddr_qstorage *addr2)
|
||||
{
|
||||
if (addr1->sa_family != addr2->sa_family)
|
||||
return -1;
|
||||
|
||||
if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
|
||||
return -1;
|
||||
|
||||
if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WINS_GetSocketPort (struct sockaddr_qstorage *addr)
|
||||
{
|
||||
return ntohs(((struct sockaddr_in *)addr)->sin_port);
|
||||
}
|
||||
|
||||
|
||||
int WINS_SetSocketPort (struct sockaddr_qstorage *addr, int port)
|
||||
{
|
||||
((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)port);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
#endif
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_wins.h
|
||||
|
||||
int WINS_Init (void);
|
||||
void WINS_Shutdown (void);
|
||||
void WINS_Listen (qboolean state);
|
||||
int WINS_OpenSocket (int port);
|
||||
int WINS_CloseSocket (int socket);
|
||||
int WINS_Connect (int socket, struct sockaddr_qstorage *addr);
|
||||
int WINS_CheckNewConnections (void);
|
||||
int WINS_Read (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr);
|
||||
int WINS_Write (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr);
|
||||
int WINS_Broadcast (int socket, qbyte *buf, int len);
|
||||
char *WINS_AddrToString (struct sockaddr_qstorage *addr);
|
||||
int WINS_StringToAddr (char *string, struct sockaddr_qstorage *addr);
|
||||
int WINS_GetSocketAddr (int socket, struct sockaddr_qstorage *addr);
|
||||
int WINS_GetNameFromAddr (struct sockaddr_qstorage *addr, char *name);
|
||||
int WINS_GetAddrFromName (char *name, struct sockaddr_qstorage *addr);
|
||||
int WINS_AddrCompare (struct sockaddr_qstorage *addr1, struct sockaddr_qstorage *addr2);
|
||||
int WINS_GetSocketPort (struct sockaddr_qstorage *addr);
|
||||
int WINS_SetSocketPort (struct sockaddr_qstorage *addr, int port);
|
||||
|
|
@ -0,0 +1,441 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_wipx.c
|
||||
|
||||
#include "quakedef.h"
|
||||
#ifdef NQPROT
|
||||
#include "../client/winquake.h"
|
||||
#include <wsipx.h>
|
||||
#include "net_wipx.h"
|
||||
|
||||
#ifndef CLIENTONLY
|
||||
extern cvar_t hostname;
|
||||
#endif
|
||||
|
||||
#define MAXHOSTNAMELEN 256
|
||||
|
||||
static int net_acceptsocket = -1; // socket for fielding new connections
|
||||
static int net_controlsocket;
|
||||
static struct sockaddr_qstorage broadcastaddr;
|
||||
|
||||
extern qboolean winsock_initialized;
|
||||
extern WSADATA winsockdata;
|
||||
|
||||
#define IPXSOCKETS 18
|
||||
static int ipxsocket[IPXSOCKETS];
|
||||
static int sequence[IPXSOCKETS];
|
||||
|
||||
#ifdef _WIN32
|
||||
#define qerrno pWSAGetLastError()
|
||||
#else
|
||||
#define qerrno errno
|
||||
#endif
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_Init (void)
|
||||
{
|
||||
int i;
|
||||
char buff[MAXHOSTNAMELEN];
|
||||
struct sockaddr_qstorage addr;
|
||||
char *p;
|
||||
int r;
|
||||
WORD wVersionRequested;
|
||||
|
||||
if (COM_CheckParm ("-noipx"))
|
||||
return -1;
|
||||
|
||||
// make sure LoadLibrary has happened successfully
|
||||
if (!winsock_lib_initialized)
|
||||
return -1;
|
||||
|
||||
if (winsock_initialized == 0)
|
||||
{
|
||||
wVersionRequested = MAKEWORD(1, 1);
|
||||
|
||||
r = pWSAStartup (MAKEWORD(1, 1), &winsockdata);
|
||||
|
||||
if (r)
|
||||
{
|
||||
Con_Printf ("Winsock initialization failed.\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
winsock_initialized++;
|
||||
|
||||
for (i = 0; i < IPXSOCKETS; i++)
|
||||
ipxsocket[i] = 0;
|
||||
|
||||
#ifndef CLIENTONLY
|
||||
// determine my name & address
|
||||
if (pgethostname(buff, MAXHOSTNAMELEN) == 0)
|
||||
{
|
||||
// if the quake hostname isn't set, set it to the machine name
|
||||
if (Q_strcmp(hostname.string, "UNNAMED") == 0)
|
||||
{
|
||||
// see if it's a text IP address (well, close enough)
|
||||
for (p = buff; *p; p++)
|
||||
if ((*p < '0' || *p > '9') && *p != '.')
|
||||
break;
|
||||
|
||||
// if it is a real name, strip off the domain; we only want the host
|
||||
if (*p)
|
||||
{
|
||||
for (i = 0; i < 15; i++)
|
||||
if (buff[i] == '.')
|
||||
break;
|
||||
buff[i] = 0;
|
||||
}
|
||||
Cvar_Set (&hostname, buff);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if ((net_controlsocket = WIPX_OpenSocket (0)) == -1)
|
||||
{
|
||||
Con_Printf("WIPX_Init: Unable to open control socket\n");
|
||||
if (--winsock_initialized == 0)
|
||||
pWSACleanup ();
|
||||
return -1;
|
||||
}
|
||||
|
||||
((struct sockaddr_ipx *)&broadcastaddr)->sa_family = AF_IPX;
|
||||
memset(((struct sockaddr_ipx *)&broadcastaddr)->sa_netnum, 0, 4);
|
||||
memset(((struct sockaddr_ipx *)&broadcastaddr)->sa_nodenum, 0xff, 6);
|
||||
((struct sockaddr_ipx *)&broadcastaddr)->sa_socket = htons((unsigned short)net_hostport);
|
||||
|
||||
WIPX_GetSocketAddr (net_controlsocket, &addr);
|
||||
Q_strcpy(my_ipx_address, WIPX_AddrToString (&addr));
|
||||
p = Q_strrchr (my_ipx_address, ':');
|
||||
if (p)
|
||||
*p = 0;
|
||||
|
||||
Con_Printf("Winsock IPX Initialized\n");
|
||||
ipxAvailable = true;
|
||||
|
||||
return net_controlsocket;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void WIPX_Shutdown (void)
|
||||
{
|
||||
WIPX_Listen (false);
|
||||
WIPX_CloseSocket (net_controlsocket);
|
||||
if (--winsock_initialized == 0)
|
||||
pWSACleanup ();
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void WIPX_Listen (qboolean state)
|
||||
{
|
||||
// enable listening
|
||||
if (state)
|
||||
{
|
||||
if (net_acceptsocket != -1)
|
||||
return;
|
||||
if ((net_acceptsocket = WIPX_OpenSocket (net_hostport)) == -1)
|
||||
Con_Printf ("WIPX_Listen: Unable to open accept socket\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// disable listening
|
||||
if (net_acceptsocket == -1)
|
||||
return;
|
||||
WIPX_CloseSocket (net_acceptsocket);
|
||||
net_acceptsocket = -1;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_OpenSocket (int port)
|
||||
{
|
||||
int handle;
|
||||
int newsocket;
|
||||
struct sockaddr_ipx address;
|
||||
u_long _true = 1;
|
||||
|
||||
for (handle = 0; handle < IPXSOCKETS; handle++)
|
||||
if (ipxsocket[handle] == 0)
|
||||
break;
|
||||
if (handle == IPXSOCKETS)
|
||||
return -1;
|
||||
|
||||
if ((newsocket = psocket (AF_IPX, SOCK_DGRAM, NSPROTO_IPX)) == INVALID_SOCKET)
|
||||
return -1;
|
||||
|
||||
if (pioctlsocket (newsocket, FIONBIO, &_true) == -1)
|
||||
goto ErrorReturn;
|
||||
|
||||
if (psetsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&_true, sizeof(_true)) < 0)
|
||||
goto ErrorReturn;
|
||||
|
||||
address.sa_family = AF_IPX;
|
||||
memset(address.sa_netnum, 0, 4);
|
||||
memset(address.sa_nodenum, 0, 6);;
|
||||
address.sa_socket = htons((unsigned short)port);
|
||||
if( bind (newsocket, (void *)&address, sizeof(address)) == 0)
|
||||
{
|
||||
ipxsocket[handle] = newsocket;
|
||||
sequence[handle] = 0;
|
||||
return handle;
|
||||
}
|
||||
|
||||
Con_Printf ("Winsock IPX bind failed\n");
|
||||
ErrorReturn:
|
||||
pclosesocket (newsocket);
|
||||
return -1;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_CloseSocket (int handle)
|
||||
{
|
||||
int socket = ipxsocket[handle];
|
||||
int ret;
|
||||
|
||||
ret = pclosesocket (socket);
|
||||
ipxsocket[handle] = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_Connect (int handle, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_CheckNewConnections (void)
|
||||
{
|
||||
unsigned long available;
|
||||
|
||||
if (net_acceptsocket == -1)
|
||||
return -1;
|
||||
|
||||
if (pioctlsocket (ipxsocket[net_acceptsocket], FIONREAD, &available) == -1)
|
||||
Sys_Error ("WIPX: ioctlsocket (FIONREAD) failed\n");
|
||||
if (available)
|
||||
return net_acceptsocket;
|
||||
return -1;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
static qbyte packetBuffer[NET_DATAGRAMSIZE + 4];
|
||||
|
||||
int WIPX_Read (int handle, qbyte *buf, int len, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int addrlen = sizeof (struct sockaddr_qstorage);
|
||||
int socket = ipxsocket[handle];
|
||||
int ret;
|
||||
|
||||
ret = precvfrom (socket, packetBuffer, len+4, 0, (struct sockaddr *)addr, &addrlen);
|
||||
if (ret == -1)
|
||||
{
|
||||
if (qerrno == WSAEWOULDBLOCK || qerrno == WSAECONNREFUSED)
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
if (ret < 4)
|
||||
return 0;
|
||||
|
||||
// remove sequence number, it's only needed for DOS IPX
|
||||
ret -= 4;
|
||||
memcpy(buf, packetBuffer+4, ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_Broadcast (int handle, qbyte *buf, int len)
|
||||
{
|
||||
return WIPX_Write (handle, buf, len, &broadcastaddr);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_Write (int handle, qbyte *buf, int len, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int socket = ipxsocket[handle];
|
||||
int ret;
|
||||
|
||||
// build packet with sequence number
|
||||
*(int *)(&packetBuffer[0]) = sequence[handle];
|
||||
sequence[handle]++;
|
||||
memcpy(&packetBuffer[4], buf, len);
|
||||
len += 4;
|
||||
|
||||
ret = psendto (socket, packetBuffer, len, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_qstorage));
|
||||
if (ret == -1)
|
||||
if (pWSAGetLastError() == WSAEWOULDBLOCK)
|
||||
return 0;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
char *WIPX_AddrToString (struct sockaddr_qstorage *addr)
|
||||
{
|
||||
static char buf[28];
|
||||
|
||||
sprintf(buf, "%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x:%u",
|
||||
((struct sockaddr_ipx *)addr)->sa_netnum[0] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_netnum[1] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_netnum[2] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_netnum[3] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_nodenum[0] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_nodenum[1] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_nodenum[2] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_nodenum[3] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_nodenum[4] & 0xff,
|
||||
((struct sockaddr_ipx *)addr)->sa_nodenum[5] & 0xff,
|
||||
ntohs(((struct sockaddr_ipx *)addr)->sa_socket)
|
||||
);
|
||||
return buf;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_StringToAddr (char *string, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int val;
|
||||
char buf[3];
|
||||
|
||||
buf[2] = 0;
|
||||
Q_memset(addr, 0, sizeof(struct sockaddr_qstorage));
|
||||
addr->sa_family = AF_IPX;
|
||||
|
||||
#define DO(src,dest) \
|
||||
buf[0] = string[src]; \
|
||||
buf[1] = string[src + 1]; \
|
||||
if (sscanf (buf, "%x", &val) != 1) \
|
||||
return -1; \
|
||||
((struct sockaddr_ipx *)addr)->dest = val
|
||||
|
||||
DO(0, sa_netnum[0]);
|
||||
DO(2, sa_netnum[1]);
|
||||
DO(4, sa_netnum[2]);
|
||||
DO(6, sa_netnum[3]);
|
||||
DO(9, sa_nodenum[0]);
|
||||
DO(11, sa_nodenum[1]);
|
||||
DO(13, sa_nodenum[2]);
|
||||
DO(15, sa_nodenum[3]);
|
||||
DO(17, sa_nodenum[4]);
|
||||
DO(19, sa_nodenum[5]);
|
||||
#undef DO
|
||||
|
||||
sscanf (&string[22], "%u", &val);
|
||||
((struct sockaddr_ipx *)addr)->sa_socket = htons((unsigned short)val);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_GetSocketAddr (int handle, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int socket = ipxsocket[handle];
|
||||
int addrlen = sizeof(struct sockaddr_qstorage);
|
||||
|
||||
Q_memset(addr, 0, sizeof(struct sockaddr_qstorage));
|
||||
if(pgetsockname(socket, (struct sockaddr *)addr, &addrlen) != 0)
|
||||
{
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_GetNameFromAddr (struct sockaddr_qstorage *addr, char *name)
|
||||
{
|
||||
Q_strcpy(name, WIPX_AddrToString(addr));
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_GetAddrFromName(char *name, struct sockaddr_qstorage *addr)
|
||||
{
|
||||
int n;
|
||||
char buf[32];
|
||||
|
||||
n = Q_strlen(name);
|
||||
|
||||
if (n == 12)
|
||||
{
|
||||
sprintf(buf, "00000000:%s:%u", name, net_hostport);
|
||||
return WIPX_StringToAddr (buf, addr);
|
||||
}
|
||||
if (n == 21)
|
||||
{
|
||||
sprintf(buf, "%s:%u", name, net_hostport);
|
||||
return WIPX_StringToAddr (buf, addr);
|
||||
}
|
||||
if (n > 21 && n <= 27)
|
||||
return WIPX_StringToAddr (name, addr);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_AddrCompare (struct sockaddr_qstorage *addr1, struct sockaddr_qstorage *addr2)
|
||||
{
|
||||
if (addr1->sa_family != addr2->sa_family)
|
||||
return -1;
|
||||
|
||||
if (*((struct sockaddr_ipx *)addr1)->sa_netnum && *((struct sockaddr_ipx *)addr2)->sa_netnum)
|
||||
if (memcmp(((struct sockaddr_ipx *)addr1)->sa_netnum, ((struct sockaddr_ipx *)addr2)->sa_netnum, 4) != 0)
|
||||
return -1;
|
||||
if (memcmp(((struct sockaddr_ipx *)addr1)->sa_nodenum, ((struct sockaddr_ipx *)addr2)->sa_nodenum, 6) != 0)
|
||||
return -1;
|
||||
|
||||
if (((struct sockaddr_ipx *)addr1)->sa_socket != ((struct sockaddr_ipx *)addr2)->sa_socket)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
int WIPX_GetSocketPort (struct sockaddr_qstorage *addr)
|
||||
{
|
||||
return ntohs(((struct sockaddr_ipx *)addr)->sa_socket);
|
||||
}
|
||||
|
||||
|
||||
int WIPX_SetSocketPort (struct sockaddr_qstorage *addr, int port)
|
||||
{
|
||||
((struct sockaddr_ipx *)addr)->sa_socket = htons((unsigned short)port);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net_wipx.h
|
||||
|
||||
int WIPX_Init (void);
|
||||
void WIPX_Shutdown (void);
|
||||
void WIPX_Listen (qboolean state);
|
||||
int WIPX_OpenSocket (int port);
|
||||
int WIPX_CloseSocket (int socket);
|
||||
int WIPX_Connect (int socket, struct sockaddr_qstorage *addr);
|
||||
int WIPX_CheckNewConnections (void);
|
||||
int WIPX_Read (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr);
|
||||
int WIPX_Write (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr);
|
||||
int WIPX_Broadcast (int socket, qbyte *buf, int len);
|
||||
char *WIPX_AddrToString (struct sockaddr_qstorage *addr);
|
||||
int WIPX_StringToAddr (char *string, struct sockaddr_qstorage *addr);
|
||||
int WIPX_GetSocketAddr (int socket, struct sockaddr_qstorage *addr);
|
||||
int WIPX_GetNameFromAddr (struct sockaddr_qstorage *addr, char *name);
|
||||
int WIPX_GetAddrFromName (char *name, struct sockaddr_qstorage *addr);
|
||||
int WIPX_AddrCompare (struct sockaddr_qstorage *addr1, struct sockaddr_qstorage *addr2);
|
||||
int WIPX_GetSocketPort (struct sockaddr_qstorage *addr);
|
||||
int WIPX_SetSocketPort (struct sockaddr_qstorage *addr, int port);
|
||||
|
|
@ -0,0 +1,343 @@
|
|||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
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.
|
||||
|
||||
*/
|
||||
// net.h -- quake's interface to the networking layer
|
||||
|
||||
#define NET_NAMELEN 64
|
||||
|
||||
#define NET_MAXMESSAGE 8192
|
||||
#define NET_HEADERSIZE (2 * sizeof(unsigned int))
|
||||
#define NET_DATAGRAMSIZE (MAX_DATAGRAM + NET_HEADERSIZE)
|
||||
|
||||
// NetHeader flags
|
||||
#define NETFLAG_LENGTH_MASK 0x0000ffff
|
||||
#define NETFLAG_DATA 0x00010000
|
||||
#define NETFLAG_ACK 0x00020000
|
||||
#define NETFLAG_NAK 0x00040000
|
||||
#define NETFLAG_EOM 0x00080000
|
||||
#define NETFLAG_UNRELIABLE 0x00100000
|
||||
#define NETFLAG_CTL 0x80000000
|
||||
|
||||
|
||||
#define NET_PROTOCOL_VERSION 3
|
||||
|
||||
// This is the network info/connection protocol. It is used to find Quake
|
||||
// servers, get info about them, and connect to them. Once connected, the
|
||||
// Quake game protocol (documented elsewhere) is used.
|
||||
//
|
||||
//
|
||||
// General notes:
|
||||
// game_name is currently always "QUAKE", but is there so this same protocol
|
||||
// can be used for future games as well; can you say Quake2?
|
||||
//
|
||||
// CCREQ_CONNECT
|
||||
// string game_name "QUAKE"
|
||||
// qbyte net_protocol_version NET_PROTOCOL_VERSION
|
||||
//
|
||||
// CCREQ_SERVER_INFO
|
||||
// string game_name "QUAKE"
|
||||
// qbyte net_protocol_version NET_PROTOCOL_VERSION
|
||||
//
|
||||
// CCREQ_PLAYER_INFO
|
||||
// qbyte player_number
|
||||
//
|
||||
// CCREQ_RULE_INFO
|
||||
// string rule
|
||||
//
|
||||
//
|
||||
//
|
||||
// CCREP_ACCEPT
|
||||
// long port
|
||||
//
|
||||
// CCREP_REJECT
|
||||
// string reason
|
||||
//
|
||||
// CCREP_SERVER_INFO
|
||||
// string server_address
|
||||
// string host_name
|
||||
// string level_name
|
||||
// qbyte current_players
|
||||
// qbyte max_players
|
||||
// qbyte protocol_version NET_PROTOCOL_VERSION
|
||||
//
|
||||
// CCREP_PLAYER_INFO
|
||||
// qbyte player_number
|
||||
// string name
|
||||
// long colors
|
||||
// long frags
|
||||
// long connect_time
|
||||
// string address
|
||||
//
|
||||
// CCREP_RULE_INFO
|
||||
// string rule
|
||||
// string value
|
||||
|
||||
// note:
|
||||
// There are two address forms used above. The short form is just a
|
||||
// port number. The address that goes along with the port is defined as
|
||||
// "whatever address you receive this reponse from". This lets us use
|
||||
// the host OS to solve the problem of multiple host addresses (possibly
|
||||
// with no routing between them); the host will use the right address
|
||||
// when we reply to the inbound connection request. The long from is
|
||||
// a full address and port in a string. It is used for returning the
|
||||
// address of a server that is not running locally.
|
||||
|
||||
#define CCREQ_CONNECT 0x01
|
||||
#define CCREQ_SERVER_INFO 0x02
|
||||
#define CCREQ_PLAYER_INFO 0x03
|
||||
#define CCREQ_RULE_INFO 0x04
|
||||
|
||||
#define CCREP_ACCEPT 0x81
|
||||
#define CCREP_REJECT 0x82
|
||||
#define CCREP_SERVER_INFO 0x83
|
||||
#define CCREP_PLAYER_INFO 0x84
|
||||
#define CCREP_RULE_INFO 0x85
|
||||
|
||||
typedef struct qsocket_s
|
||||
{
|
||||
struct qsocket_s *next;
|
||||
double connecttime;
|
||||
double lastMessageTime;
|
||||
double lastSendTime;
|
||||
|
||||
qboolean disconnected;
|
||||
qboolean canSend;
|
||||
qboolean sendNext;
|
||||
|
||||
int driver;
|
||||
int landriver;
|
||||
int socket;
|
||||
void *driverdata;
|
||||
|
||||
unsigned int ackSequence;
|
||||
unsigned int sendSequence;
|
||||
unsigned int unreliableSendSequence;
|
||||
int sendMessageLength;
|
||||
qbyte sendMessage [NET_MAXMESSAGE];
|
||||
|
||||
unsigned int receiveSequence;
|
||||
unsigned int unreliableReceiveSequence;
|
||||
int receiveMessageLength;
|
||||
qbyte receiveMessage [NET_MAXMESSAGE];
|
||||
|
||||
struct sockaddr_qstorage addr;
|
||||
char address[NET_NAMELEN];
|
||||
|
||||
int qwprotocol;
|
||||
|
||||
} qsocket_t;
|
||||
|
||||
extern qsocket_t *net_activeSockets;
|
||||
extern qsocket_t *net_freeSockets;
|
||||
extern int net_numsockets;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *name;
|
||||
qboolean initialized;
|
||||
int controlSock;
|
||||
int (*Init) (void);
|
||||
void (*Shutdown) (void);
|
||||
void (*Listen) (qboolean state);
|
||||
int (*OpenSocket) (int port);
|
||||
int (*CloseSocket) (int socket);
|
||||
int (*Connect) (int socket, struct sockaddr_qstorage *addr);
|
||||
int (*CheckNewConnections) (void);
|
||||
int (*Read) (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr);
|
||||
int (*Write) (int socket, qbyte *buf, int len, struct sockaddr_qstorage *addr);
|
||||
int (*Broadcast) (int socket, qbyte *buf, int len);
|
||||
char * (*AddrToString) (struct sockaddr_qstorage *addr);
|
||||
int (*StringToAddr) (char *string, struct sockaddr_qstorage *addr);
|
||||
int (*GetSocketAddr) (int socket, struct sockaddr_qstorage *addr);
|
||||
int (*GetNameFromAddr) (struct sockaddr_qstorage *addr, char *name);
|
||||
int (*GetAddrFromName) (char *name, struct sockaddr_qstorage *addr);
|
||||
int (*AddrCompare) (struct sockaddr_qstorage *addr1, struct sockaddr_qstorage *addr2);
|
||||
int (*GetSocketPort) (struct sockaddr_qstorage *addr);
|
||||
int (*SetSocketPort) (struct sockaddr_qstorage *addr, int port);
|
||||
} net_landriver_t;
|
||||
|
||||
#define MAX_NET_DRIVERS 8
|
||||
extern int net_numlandrivers;
|
||||
extern net_landriver_t net_landrivers[MAX_NET_DRIVERS];
|
||||
|
||||
typedef struct
|
||||
{
|
||||
//basic setup
|
||||
char *name;
|
||||
qboolean initialized;
|
||||
int (*Init) (void);
|
||||
void (*Listen) (qboolean state);
|
||||
void (*SearchForHosts) (qboolean xmit);
|
||||
qsocket_t *(*Connect) (char *host);
|
||||
qsocket_t *(*CheckNewConnections) (void);
|
||||
int (*QGetMessage) (qsocket_t *sock);
|
||||
int (*QSendMessage) (qsocket_t *sock, sizebuf_t *data);
|
||||
int (*SendUnreliableMessage) (qsocket_t *sock, sizebuf_t *data);
|
||||
qboolean (*CanSendMessage) (qsocket_t *sock);
|
||||
qboolean (*CanSendUnreliableMessage) (qsocket_t *sock);
|
||||
void (*Close) (qsocket_t *sock);
|
||||
void (*Shutdown) (void);
|
||||
|
||||
//extra setup
|
||||
qsocket_t *(*BeginConnect) (char *host);
|
||||
qsocket_t *(*ContinueConnect) (char *host);
|
||||
qsocket_t *(*FailConnect) (char *host);
|
||||
|
||||
//extra info
|
||||
int controlSock;
|
||||
} net_driver_t;
|
||||
|
||||
extern int net_numdrivers;
|
||||
extern net_driver_t net_drivers[MAX_NET_DRIVERS];
|
||||
|
||||
extern int DEFAULTnet_hostport;
|
||||
extern int net_hostport;
|
||||
|
||||
extern int net_driverlevel;
|
||||
extern cvar_t hostname;
|
||||
extern char playername[];
|
||||
extern int playercolor;
|
||||
|
||||
extern int messagesSent;
|
||||
extern int messagesReceived;
|
||||
extern int unreliableMessagesSent;
|
||||
extern int unreliableMessagesReceived;
|
||||
|
||||
qsocket_t *NET_NewQSocket (void);
|
||||
void NET_FreeQSocket(qsocket_t *);
|
||||
double SetNetTime(void);
|
||||
|
||||
|
||||
#define HOSTCACHESIZE 8
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char name[16];
|
||||
char map[16];
|
||||
char cname[32];
|
||||
int users;
|
||||
int maxusers;
|
||||
int driver;
|
||||
int ldriver;
|
||||
struct sockaddr_qstorage addr;
|
||||
|
||||
qboolean isqwprotocol;
|
||||
} hostcache_t;
|
||||
|
||||
extern int hostCacheCount;
|
||||
extern hostcache_t hostcache[HOSTCACHESIZE];
|
||||
|
||||
#if !defined(_WIN32 ) && !defined (__linux__) && !defined (__sun__)
|
||||
#ifndef htonl
|
||||
extern unsigned long htonl (unsigned long hostlong);
|
||||
#endif
|
||||
#ifndef htons
|
||||
extern unsigned short htons (unsigned short hostshort);
|
||||
#endif
|
||||
#ifndef ntohl
|
||||
extern unsigned long ntohl (unsigned long netlong);
|
||||
#endif
|
||||
#ifndef ntohs
|
||||
extern unsigned short ntohs (unsigned short netshort);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef IDGODS
|
||||
qboolean IsID(struct qsockaddr *addr);
|
||||
#endif
|
||||
|
||||
//============================================================================
|
||||
//
|
||||
// public network functions
|
||||
//
|
||||
//============================================================================
|
||||
|
||||
extern double net_time;
|
||||
extern sizebuf_t net_message;
|
||||
extern int net_activeconnections;
|
||||
|
||||
void NQ_NET_Init (void);
|
||||
void NQ_NET_Shutdown (void);
|
||||
|
||||
struct qsocket_s *NET_CheckNewConnections (void);
|
||||
// returns a new connection number if there is one pending, else -1
|
||||
|
||||
void NQ_Connect(char *to);
|
||||
struct qsocket_s *NET_Connect (char *host, qboolean continuation);
|
||||
// called by client to connect to a host. Returns -1 if not able to
|
||||
|
||||
qboolean NET_CanSendMessage (qsocket_t *sock);
|
||||
// Returns true or false if the given qsocket can currently accept a
|
||||
// message to be transmitted.
|
||||
|
||||
int NET_GetMessage (struct qsocket_s *sock);
|
||||
// returns data in net_message sizebuf
|
||||
// returns 0 if no data is waiting
|
||||
// returns 1 if a message was received
|
||||
// returns 2 if an unreliable message was received
|
||||
// returns -1 if the connection died
|
||||
|
||||
int NET_SendMessage (struct qsocket_s *sock, sizebuf_t *data);
|
||||
int NET_SendUnreliableMessage (struct qsocket_s *sock, sizebuf_t *data);
|
||||
// returns 0 if the message connot 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_SendToAll(sizebuf_t *data, int blocktime);
|
||||
// This is a reliable *blocking* send to all attached clients.
|
||||
|
||||
|
||||
void NET_Close (struct qsocket_s *sock);
|
||||
// if a dead connection is returned by a get or send function, this function
|
||||
// should be called when it is convenient
|
||||
|
||||
// Server calls when a client is kicked off for a game related misbehavior
|
||||
// like an illegal protocal conversation. Client calls when disconnecting
|
||||
// from a server.
|
||||
// A netcon_t number will not be reused until this function is called for it
|
||||
|
||||
void NET_Poll(void);
|
||||
|
||||
|
||||
typedef struct _PollProcedure
|
||||
{
|
||||
struct _PollProcedure *next;
|
||||
double nextTime;
|
||||
void (*procedure)(void *arg);
|
||||
void *arg;
|
||||
} PollProcedure;
|
||||
|
||||
void SchedulePollProcedure(PollProcedure *pp, double timeOffset);
|
||||
|
||||
extern qboolean serialAvailable;
|
||||
extern qboolean ipxAvailable;
|
||||
extern qboolean tcpipAvailable;
|
||||
extern char my_ipx_address[NET_NAMELEN];
|
||||
extern char my_tcpip_address[NET_NAMELEN];
|
||||
extern void (*GetComPortConfig) (int portNumber, int *port, int *irq, int *baud, qboolean *useModem);
|
||||
extern void (*SetComPortConfig) (int portNumber, int port, int irq, int baud, qboolean useModem);
|
||||
extern void (*GetModemConfig) (int portNumber, char *dialType, char *clear, char *init, char *hangup);
|
||||
extern void (*SetModemConfig) (int portNumber, char *dialType, char *clear, char *init, char *hangup);
|
||||
|
||||
extern qboolean slistInProgress;
|
||||
extern qboolean slistSilent;
|
||||
extern qboolean slistLocal;
|
||||
|
||||
void NET_Slist_f (void);
|
||||
Loading…
Reference in New Issue