public int SendUnreliableMessage(qsocket_t sock, MessageWriter data)
{
if (sock.driverdata == null)
{
return(-1);
}
var sock2 = (qsocket_t)sock.driverdata;
if (sock2.receiveMessageLength + data.Length + sizeof(byte) + sizeof(short) > NetworkDef.NET_MAXMESSAGE)
{
return(0);
}
var offset = sock2.receiveMessageLength;
// message type
sock2.receiveMessage[offset++] = 2;
// length
sock2.receiveMessage[offset++] = ( byte )(data.Length & 0xff);
sock2.receiveMessage[offset++] = ( byte )(data.Length >> 8);
// align
offset++;
// message
Buffer.BlockCopy(data.Data, 0, sock2.receiveMessage, offset, data.Length);
sock2.receiveMessageLength = this.IntAlign(sock2.receiveMessageLength + data.Length + 4);
return(1);
}
static void NET_FreeQSocket(qsocket_t sock)
{
qsocket_t s;
// remove it from active list
if (sock == net_activeSockets)
{
net_activeSockets = net_activeSockets.next;
}
else
{
for (s = net_activeSockets; s != null; s = s.next)
{
if (s.next == sock)
{
s.next = sock.next;
break;
}
}
if (s == null)
{
sys_linux.Sys_Error("NET_FreeQSocket: not active\n");
}
}
// add it to free list
sock.next = net_freeSockets;
net_freeSockets = sock;
sock.disconnected = true;
}
public static int NET_SendUnreliableMessage(qsocket_t sock, MsgWriter data)
{
if (sock == null)
{
return(-1);
}
if (sock.disconnected)
{
Con_Printf("NET_SendMessage: disconnected socket\n");
return(-1);
}
SetNetTime();
int r = net_drivers[sock.driver].Datagram_SendUnreliableMessage(sock, data);
if (r == 1 && sock.driver != 0)
{
_UnreliableMessagesSent++;
}
if (recording)
{
vcrSendMessage.time = host_time;
vcrSendMessage.op = q_shared.VCR_OP_SENDMESSAGE;
vcrSendMessage.session = 1;// (long)sock; Uze todo: ???????
vcrSendMessage.ret = r;
byte[] buf = StructureToBytes(ref vcrSendMessage);
_VcrWriter.Write(buf);
}
return(r);
}
public int SendMessage(qsocket_t sock, MessageWriter data)
{
if (sock.driverdata == null)
{
return(-1);
}
var sock2 = (qsocket_t)sock.driverdata;
if (sock2.receiveMessageLength + data.Length + 4 > NetworkDef.NET_MAXMESSAGE)
{
Utilities.Error("Loop_SendMessage: overflow\n");
}
// message type
var offset = sock2.receiveMessageLength;
sock2.receiveMessage[offset++] = 1;
// length
sock2.receiveMessage[offset++] = ( byte )(data.Length & 0xff);
sock2.receiveMessage[offset++] = ( byte )(data.Length >> 8);
// align
offset++;
// message
Buffer.BlockCopy(data.Data, 0, sock2.receiveMessage, offset, data.Length);
sock2.receiveMessageLength = this.IntAlign(sock2.receiveMessageLength + data.Length + 4);
sock.canSend = false;
return(1);
}
public static bool NET_CanSendMessage(qsocket_t sock)
{
if (sock == null)
{
return(false);
}
if (sock.disconnected)
{
return(false);
}
SetNetTime();
bool r = net_drivers[sock.driver].Datagram_CanSendMessage(sock);
if (recording)
{
vcrSendMessage.time = host_time;
vcrSendMessage.op = q_shared.VCR_OP_CANSENDMESSAGE;
vcrSendMessage.session = 1; // (long)sock; Uze: todo: do something?
vcrSendMessage.ret = r ? 1 : 0;
byte[] buf = StructureToBytes(ref vcrSendMessage);
_VcrWriter.Write(buf, 0, buf.Length);
}
return(r);
}
public static void SV_CheckForNewClients()
{
//
// check for new connections
//
while (true)
{
qsocket_t ret = NET_CheckNewConnections();
if (ret == null)
{
break;
}
//
// init a new client structure
//
int i;
for (i = 0; i < svs.maxclients; i++)
{
if (!svs.clients[i].active)
{
break;
}
}
if (i == svs.maxclients)
{
Sys_Error("Host_CheckForNewClients: no free clients");
}
svs.clients[i].netconnection = ret;
SV_ConnectClient(i);
net_activeconnections++;
}
}
static 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 byte skipped here
common.SZ_Clear(net_message);
common.SZ_Write(net_message, sock.receiveMessage, 4, length);
length = IntAlign(length + 4);
sock.receiveMessageLength -= length;
if (sock.receiveMessageLength != 0)
{
Buffer.BlockCopy(sock.receiveMessage, length, sock.receiveMessage, 0, sock.receiveMessageLength);
}
if (sock.driverdata != null && ret == 1)
{
((qsocket_t)sock.driverdata).canSend = true;
}
return(ret);
}
public int GetMessage(qsocket_t sock)
{
if (sock.receiveMessageLength == 0)
{
return(0);
}
int ret = sock.receiveMessage[0];
var length = sock.receiveMessage[1] + (sock.receiveMessage[2] << 8);
// alignment byte skipped here
this.Host.Network.Message.Clear();
this.Host.Network.Message.FillFrom(sock.receiveMessage, 4, length);
length = this.IntAlign(length + 4);
sock.receiveMessageLength -= length;
if (sock.receiveMessageLength > 0)
{
Array.Copy(sock.receiveMessage, length, sock.receiveMessage, 0, sock.receiveMessageLength);
}
if (sock.driverdata != null && ret == 1)
{
((qsocket_t)sock.driverdata).canSend = true;
}
return(ret);
}
static bool Loop_CanSendMessage(qsocket_t sock)
{
if (sock.driverdata == null)
{
return(false);
}
return(sock.canSend);
}
static void Loop_Close(qsocket_t sock)
{
if (sock.driverdata != null)
((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;
}
public static void NET_FreeQSocket(qsocket_t sock)
{
// remove it from active list
if (!net_activeSockets.Remove(sock))
{
Sys_Error("NET_FreeQSocket: not active\n");
}
// add it to free list
net_freeSockets.Add(sock);
sock.disconnected = true;
}
public bool CanSendMessage(qsocket_t sock)
{
if (this.Host.Time != this._Next.time || this._Next.op != VcrOp.VCR_OP_CANSENDMESSAGE || this._Next.session != this.SocketToSession(sock))
{
Utilities.Error("VCR missmatch");
}
var ret = this.Host.VcrReader.ReadInt32();
this.ReadNext();
return(ret != 0);
}
/*
* =================
* 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
* =================
*/
public static int NET_GetMessage(qsocket_t sock)
{
int ret;
if (sock == null)
{
return(-1);
}
if (sock.disconnected)
{
console.Con_Printf("NET_GetMessage: disconnected socket\n");
return(-1);
}
SetNetTime();
ret = net_drivers[sock.driver].delegate_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 != 0)
{
sock.lastMessageTime = net_time;
if (ret == 1)
{
messagesReceived++;
}
else if (ret == 2)
{
unreliableMessagesReceived++;
}
}
}
else
{
}
return(ret);
}
public static qsocket_t NET_CheckNewConnections()
{
SetNetTime();
for (net_driverlevel = 0; net_driverlevel < net_drivers.Length; net_driverlevel++)
{
if (!net_drivers[net_driverlevel].IsInitialized)
{
continue;
}
if (net_driverlevel > 0 && !listening)
{
continue;
}
qsocket_t ret = net_drivers[net_driverlevel].Datagram_CheckNewConnections();
if (ret != null)
{
if (recording)
{
vcrConnect.time = host_time;
vcrConnect.op = q_shared.VCR_OP_CONNECT;
vcrConnect.session = 1; // (long)ret; // Uze: todo: make it work on 64bit systems
byte[] buf = StructureToBytes(ref vcrConnect);
_VcrWriter.Write(buf, 0, buf.Length);
buf = Encoding.ASCII.GetBytes(ret.address);
int count = Math.Min(buf.Length, q_shared.NET_NAMELEN);
int extra = q_shared.NET_NAMELEN - count;
_VcrWriter.Write(buf, 0, count);
for (int i = 0; i < extra; i++)
{
_VcrWriter.Write((byte)0);
}
}
return(ret);
}
}
if (recording)
{
vcrConnect.time = host_time;
vcrConnect.op = q_shared.VCR_OP_CONNECT;
vcrConnect.session = 0;
byte[] buf = StructureToBytes(ref vcrConnect);
_VcrWriter.Write(buf, 0, buf.Length);
}
return(null);
}
/*
==================
NET_CanSendMessage
Returns true or false if the given qsocket can currently accept a
message to be transmitted.
==================
*/
public static bool NET_CanSendMessage(qsocket_t sock)
{
bool r;
if (sock == null)
return false;
if (sock.disconnected)
return false;
SetNetTime();
r = net_drivers[sock.driver].delegate_CanSendMessage(sock);
return r;
}
static void Loop_Close(qsocket_t sock)
{
if (sock.driverdata != null)
{
((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;
}
}
public void Close(qsocket_t sock)
{
if (sock.driverdata != null)
{
((qsocket_t)sock.driverdata).driverdata = null;
}
sock.ClearBuffers();
sock.canSend = true;
if (sock == this._Client)
{
this._Client = null;
}
else
{
this._Server = null;
}
}
public qsocket_t Connect(string host)
{
if (host != "local")
{
return(null);
}
this._LocalConnectPending = true;
if (this._Client == null)
{
this._Client = this.Host.Network.NewSocket();
if (this._Client == null)
{
this.Host.Console.Print("Loop_Connect: no qsocket available\n");
return(null);
}
this._Client.address = "localhost";
}
this._Client.ClearBuffers();
this._Client.canSend = true;
if (this._Server == null)
{
this._Server = this.Host.Network.NewSocket();
if (this._Server == null)
{
this.Host.Console.Print("Loop_Connect: no qsocket available\n");
return(null);
}
this._Server.address = "LOCAL";
}
this._Server.ClearBuffers();
this._Server.canSend = true;
this._Client.driverdata = this._Server;
this._Server.driverdata = this._Client;
return(this._Client);
}
public static void NET_Close(qsocket_t sock)
{
if (sock == null)
{
return;
}
if (sock.disconnected)
{
return;
}
SetNetTime();
// call the driver_Close function
net_drivers[sock.driver].Datagram_Close(sock);
NET_FreeQSocket(sock);
}
/*
* ==================
* NET_CanSendMessage
*
* Returns true or false if the given qsocket can currently accept a
* message to be transmitted.
* ==================
*/
public static bool NET_CanSendMessage(qsocket_t sock)
{
bool r;
if (sock == null)
{
return(false);
}
if (sock.disconnected)
{
return(false);
}
SetNetTime();
r = net_drivers[sock.driver].delegate_CanSendMessage(sock);
return(r);
}
/*
* ===================
* NET_NewQSocket
*
* Called by drivers when a new communications endpoint is required
* The sequence and buffer fields will be filled in properly
* ===================
*/
static qsocket_t NET_NewQSocket()
{
qsocket_t sock;
if (net_freeSockets == null)
{
return(null);
}
if (net_activeconnections >= server.svs.maxclients)
{
return(null);
}
// get one from free list
sock = net_freeSockets;
net_freeSockets = sock.next;
// add it to active list
sock.next = net_activeSockets;
net_activeSockets = sock;
sock.disconnected = false;
sock.connecttime = net_time;
sock.address = "UNSET ADDRESS";
sock.driver = net_driverlevel;
sock.socket = 0;
sock.driverdata = null;
sock.canSend = true;
sock.sendNext = false;
sock.lastMessageTime = net_time;
sock.ackSequence = 0;
sock.sendSequence = 0;
sock.unreliableSendSequence = 0;
sock.sendMessageLength = 0;
sock.receiveSequence = 0;
sock.unreliableReceiveSequence = 0;
sock.receiveMessageLength = 0;
return(sock);
}
public static void SV_ConnectClient(int clientnum)
{
client_t client = svs.clients[clientnum];
Con_DPrintf("Client {0} connected\n", client.netconnection.address);
int edictnum = clientnum + 1;
edict_t ent = EDICT_NUM(edictnum);
// set up the client_t
qsocket_t netconnection = client.netconnection;
float[] spawn_parms = new float[q_shared.NUM_SPAWN_PARMS];
if (sv.loadgame)
{
Array.Copy(client.spawn_parms, spawn_parms, spawn_parms.Length);
}
client.Clear();
client.netconnection = netconnection;
client.name = "unconnected";
client.active = true;
client.spawned = false;
client.edict = ent;
client.message.AllowOverflow = true; // we can catch it
client.privileged = false;
if (sv.loadgame)
{
Array.Copy(spawn_parms, client.spawn_parms, spawn_parms.Length);
}
else
{
// call the progs to get default spawn parms for the new client
PR_ExecuteProgram(pr_global_struct.SetNewParms);
AssignGlobalSpawnparams(client);
}
SV_SendServerinfo(client);
}
public static qsocket_t NET_NewQSocket()
{
if (net_freeSockets.Count == 0)
{
return(null);
}
if (net_activeconnections >= svs.maxclients)
{
return(null);
}
// get one from free list
int i = net_freeSockets.Count - 1;
qsocket_t sock = net_freeSockets[i];
net_freeSockets.RemoveAt(i);
// add it to active list
net_activeSockets.Add(sock);
sock.disconnected = false;
sock.connecttime = net_time;
sock.address = "UNSET ADDRESS";
sock.driver = net_driverlevel;
sock.socket = null;
sock.driverdata = null;
sock.canSend = true;
sock.sendNext = false;
sock.lastMessageTime = net_time;
sock.ackSequence = 0;
sock.sendSequence = 0;
sock.unreliableSendSequence = 0;
sock.sendMessageLength = 0;
sock.receiveSequence = 0;
sock.unreliableReceiveSequence = 0;
sock.receiveMessageLength = 0;
return(sock);
}
static qsocket_t Loop_Connect(string host)
{
if (host.CompareTo("local") != 0)
{
return(null);
}
localconnectpending = true;
if (loop_client == null)
{
if ((loop_client = NET_NewQSocket()) == null)
{
console.Con_Printf("Loop_Connect: no qsocket available\n");
return(null);
}
loop_client.address = "localhost";
}
loop_client.receiveMessageLength = 0;
loop_client.sendMessageLength = 0;
loop_client.canSend = true;
if (loop_server == null)
{
if ((loop_server = NET_NewQSocket()) == null)
{
console.Con_Printf("Loop_Connect: no qsocket available\n");
return(null);
}
loop_server.address = "LOCAL";
}
loop_server.receiveMessageLength = 0;
loop_server.sendMessageLength = 0;
loop_server.canSend = true;
loop_client.driverdata = loop_server;
loop_server.driverdata = loop_client;
return(loop_client);
}
static qsocket_t Loop_Connect(string host)
{
if (host.CompareTo("local") != 0)
return null;
localconnectpending = true;
if (loop_client == null)
{
if ((loop_client = NET_NewQSocket ()) == null)
{
console.Con_Printf("Loop_Connect: no qsocket available\n");
return null;
}
loop_client.address = "localhost";
}
loop_client.receiveMessageLength = 0;
loop_client.sendMessageLength = 0;
loop_client.canSend = true;
if (loop_server == null)
{
if ((loop_server = NET_NewQSocket ()) == null)
{
console.Con_Printf("Loop_Connect: no qsocket available\n");
return null;
}
loop_server.address = "LOCAL";
}
loop_server.receiveMessageLength = 0;
loop_server.sendMessageLength = 0;
loop_server.canSend = true;
loop_client.driverdata = loop_server;
loop_server.driverdata = loop_client;
return loop_client;
}
static int Loop_SendMessage(qsocket_t sock, common.sizebuf_t data)
{
byte[] buffer;
int ofs;
int bufferLength;
if (sock.driverdata == null)
{
return(-1);
}
bufferLength = ((qsocket_t)sock.driverdata).receiveMessageLength;
if ((bufferLength + data.cursize + 4) > NET_MAXMESSAGE)
{
sys_linux.Sys_Error("Loop_SendMessage: overflow\n");
}
buffer = ((qsocket_t)sock.driverdata).receiveMessage;
ofs = bufferLength;
// message type
buffer[ofs++] = 1;
// length
buffer[ofs++] = (byte)(data.cursize & 0xff);
buffer[ofs++] = (byte)(data.cursize >> 8);
// align
ofs++;
// message
Buffer.BlockCopy(data.data, 0, buffer, ofs, data.cursize);
((qsocket_t)sock.driverdata).receiveMessageLength = IntAlign(bufferLength + data.cursize + 4);
sock.canSend = false;
return(1);
}
public int GetMessage(qsocket_t sock)
{
if (this.Host.Time != this._Next.time || this._Next.op != VcrOp.VCR_OP_GETMESSAGE || this._Next.session != this.SocketToSession(sock))
{
Utilities.Error("VCR missmatch");
}
var ret = this.Host.VcrReader.ReadInt32();
if (ret != 1)
{
this.ReadNext();
return(ret);
}
var length = this.Host.VcrReader.ReadInt32();
this.Host.Network.Message.FillFrom(this.Host.VcrReader.BaseStream, length);
this.ReadNext();
return(1);
}
static int Loop_SendUnreliableMessage(qsocket_t sock, common.sizebuf_t data)
{
byte[] buffer;
int ofs;
int bufferLength;
if (sock.driverdata == null)
{
return(-1);
}
bufferLength = ((qsocket_t)sock.driverdata).receiveMessageLength;
if ((bufferLength + data.cursize + sizeof(byte) + sizeof(short)) > NET_MAXMESSAGE)
{
return(0);
}
buffer = ((qsocket_t)sock.driverdata).receiveMessage;
ofs = bufferLength;
// message type
buffer[ofs++] = 2;
// length
buffer[ofs++] = (byte)(data.cursize & 0xff);
buffer[ofs++] = (byte)(data.cursize >> 8);
// align
ofs++;
// message
Buffer.BlockCopy(data.data, 0, buffer, ofs, data.cursize);
((qsocket_t)sock.driverdata).receiveMessageLength = IntAlign(bufferLength + data.cursize + 4);
return(1);
}
public static int NET_SendUnreliableMessage(qsocket_t sock, common.sizebuf_t data)
{
int r;
if (sock == null)
{
return(-1);
}
if (sock.disconnected)
{
console.Con_Printf("NET_SendMessage: disconnected socket\n");
return(-1);
}
SetNetTime();
r = net_drivers[sock.driver].delegate_SendUnreliableMessage(sock, data);
if (r == 1 && sock.driver != 0)
{
unreliableMessagesSent++;
}
return(r);
}
static 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 byte skipped here
common.SZ_Clear (net_message);
common.SZ_Write (net_message, sock.receiveMessage, 4, length);
length = IntAlign(length + 4);
sock.receiveMessageLength -= length;
if (sock.receiveMessageLength != 0)
Buffer.BlockCopy(sock.receiveMessage, length, sock.receiveMessage, 0, sock.receiveMessageLength);
if (sock.driverdata != null && ret == 1)
((qsocket_t)sock.driverdata).canSend = true;
return ret;
}
public static qsocket_t NET_Connect(string host)
{
int numdrivers = net_drivers.Length;// net_numdrivers;
SetNetTime();
if (String.IsNullOrEmpty(host))
{
host = null;
}
if (host != null)
{
if (SameText(host, "local"))
{
numdrivers = 1;
goto JustDoIt;
}
if (hostCacheCount > 0)
{
foreach (hostcache_t hc in hostcache)
{
if (SameText(hc.name, host))
{
host = hc.cname;
goto JustDoIt;
}
}
}
}
SlistSilent = (host != null);
NET_Slist_f();
while (slistInProgress)
{
NET_Poll();
}
if (host == null)
{
if (hostCacheCount != 1)
{
return(null);
}
host = hostcache[0].cname;
Con_Printf("Connecting to...\n{0} @ {1}\n\n", hostcache[0].name, host);
}
net_driverlevel = 0;
foreach (hostcache_t hc in hostcache)
{
if (SameText(host, hc.name))
{
host = hc.cname;
break;
}
net_driverlevel++;
}
JustDoIt:
net_driverlevel = 0;
foreach (INetDriver drv in net_drivers)
{
if (!drv.IsInitialized)
{
continue;
}
qsocket_t ret = drv.Datagram_Connect(host);
if (ret != null)
{
return(ret);
}
net_driverlevel++;
}
if (host != null)
{
Con_Printf("\n");
PrintSlistHeader();
PrintSlist();
PrintSlistTrailer();
}
return(null);
}
public bool CanSendUnreliableMessage(qsocket_t sock)
{
return(true);
}
public static int NET_SendUnreliableMessage(qsocket_t sock, common.sizebuf_t data)
{
int r;
if (sock == null)
return -1;
if (sock.disconnected)
{
console.Con_Printf("NET_SendMessage: disconnected socket\n");
return -1;
}
SetNetTime();
r = net_drivers[sock.driver].delegate_SendUnreliableMessage(sock, data);
if (r == 1 && sock.driver != 0)
unreliableMessagesSent++;
return r;
}
static bool Loop_CanSendUnreliableMessage(qsocket_t sock)
{
return true;
}
static bool Loop_CanSendMessage(qsocket_t sock)
{
if (sock.driverdata == null)
return false;
return sock.canSend;
}
static void NET_FreeQSocket(qsocket_t sock)
{
qsocket_t s;
// remove it from active list
if (sock == net_activeSockets)
net_activeSockets = net_activeSockets.next;
else
{
for (s = net_activeSockets; s != null; s = s.next)
if (s.next == sock)
{
s.next = sock.next;
break;
}
if (s == null)
sys_linux.Sys_Error ("NET_FreeQSocket: not active\n");
}
// add it to free list
sock.next = net_freeSockets;
net_freeSockets = sock;
sock.disconnected = true;
}
public static int NET_GetMessage(qsocket_t sock)
{
//int ret;
if (sock == null)
{
return(-1);
}
if (sock.disconnected)
{
Con_Printf("NET_GetMessage: disconnected socket\n");
return(-1);
}
SetNetTime();
int ret = net_drivers[sock.driver].GetMessage(sock);
// see if this connection has timed out
if (ret == 0 && sock.driver != 0)
{
if (net_time - sock.lastMessageTime > net_messagetimeout.value)
{
NET_Close(sock);
return(-1);
}
}
if (ret > 0)
{
if (sock.driver != 0)
{
sock.lastMessageTime = net_time;
if (ret == 1)
{
_MessagesReceived++;
}
else if (ret == 2)
{
_UnreliableMessagesReceived++;
}
}
if (recording)
{
vcrGetMessage.time = host_time;
vcrGetMessage.op = q_shared.VCR_OP_GETMESSAGE;
vcrGetMessage.session = 1;// (long)sock; Uze todo: write somethisng meaningful
vcrGetMessage.ret = ret;
byte[] buf = StructureToBytes(ref vcrGetMessage);
_VcrWriter.Write(buf, 0, buf.Length);
_VcrWriter.Write(Message.Length);
_VcrWriter.Write(Message.Data, 0, Message.Length);
}
}
else
{
if (recording)
{
vcrGetMessage.time = host_time;
vcrGetMessage.op = q_shared.VCR_OP_GETMESSAGE;
vcrGetMessage.session = 1; // (long)sock; Uze todo: fix this
vcrGetMessage.ret = ret;
byte[] buf = StructureToBytes(ref vcrGetMessage);
_VcrWriter.Write(buf, 0, buf.Length);
}
}
return(ret);
}
//=============================================================================
/*
====================
NET_Init
====================
*/
public static void NET_Init()
{
int i;
int controlSocket;
qsocket_t s;
if (common.COM_CheckParm("-listen") != 0 || client.cls.state == client.cactive_t.ca_dedicated)
listening = true;
net_numsockets = server.svs.maxclientslimit;
if (client.cls.state != client.cactive_t.ca_dedicated)
net_numsockets++;
SetNetTime();
for (i = 0; i < net_numsockets; i++)
{
s = new qsocket_t();
s.next = net_freeSockets;
net_freeSockets = s;
s.disconnected = true;
}
// allocate space for network message buffer
common.SZ_Alloc (net_message, NET_MAXMESSAGE);
cvar_t.Cvar_RegisterVariable (net_messagetimeout);
cvar_t.Cvar_RegisterVariable (hostname);
cvar_t.Cvar_RegisterVariable (config_com_port);
cvar_t.Cvar_RegisterVariable (config_com_irq);
cvar_t.Cvar_RegisterVariable (config_com_baud);
cvar_t.Cvar_RegisterVariable (config_com_modem);
cvar_t.Cvar_RegisterVariable (config_modem_dialtype);
cvar_t.Cvar_RegisterVariable (config_modem_clear);
cvar_t.Cvar_RegisterVariable (config_modem_init);
cvar_t.Cvar_RegisterVariable (config_modem_hangup);
cmd.Cmd_AddCommand ("slist", NET_Slist_f);
cmd.Cmd_AddCommand ("listen", NET_Listen_f);
cmd.Cmd_AddCommand ("maxplayers", MaxPlayers_f);
cmd.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].delegate_Init();
if (controlSocket == -1)
continue;
net_drivers[net_driverlevel].initialized = true;
net_drivers[net_driverlevel].controlSock = controlSocket;
if (listening)
net_drivers[net_driverlevel].delegate_Listen (true);
}
}
/*
===================
NET_Close
===================
*/
public static void NET_Close(qsocket_t sock)
{
if (sock == null)
return;
if (sock.disconnected)
return;
SetNetTime();
// call the driver_Close function
net_drivers[sock.driver].delegate_Close(sock);
NET_FreeQSocket(sock);
}
/*
=================
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
=================
*/
public static int NET_GetMessage(qsocket_t sock)
{
int ret;
if (sock == null)
return -1;
if (sock.disconnected)
{
console.Con_Printf("NET_GetMessage: disconnected socket\n");
return -1;
}
SetNetTime();
ret = net_drivers[sock.driver].delegate_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 != 0)
{
sock.lastMessageTime = net_time;
if (ret == 1)
messagesReceived++;
else if (ret == 2)
unreliableMessagesReceived++;
}
}
else
{
}
return ret;
}
static bool Loop_CanSendUnreliableMessage(qsocket_t sock)
{
return(true);
}
static int Loop_SendMessage(qsocket_t sock, common.sizebuf_t data)
{
Uint8Array buffer;
int ofs;
int bufferLength;
if (sock.driverdata == null)
return -1;
bufferLength = ((qsocket_t)sock.driverdata).receiveMessageLength;
if ((bufferLength + data.cursize + 4) > NET_MAXMESSAGE)
sys_linux.Sys_Error("Loop_SendMessage: overflow\n");
buffer = ((qsocket_t)sock.driverdata).receiveMessage;
ofs = bufferLength;
// message type
buffer[ofs++] = 1;
// length
buffer[ofs++] = (byte)(data.cursize & 0xff);
buffer[ofs++] = (byte)(data.cursize >> 8);
// align
ofs++;
// message
Buffer.BlockCopy(data.data, 0, buffer, ofs, data.cursize);
((qsocket_t)sock.driverdata).receiveMessageLength = IntAlign(bufferLength + data.cursize + 4);
sock.canSend = false;
return 1;
}
static int Loop_SendUnreliableMessage(qsocket_t sock, common.sizebuf_t data)
{
Uint8Array buffer;
int ofs;
int bufferLength;
if (sock.driverdata == null)
return -1;
bufferLength = ((qsocket_t)sock.driverdata).receiveMessageLength;
if ((bufferLength + data.cursize + sizeof(byte) + sizeof(short)) > NET_MAXMESSAGE)
return 0;
buffer = ((qsocket_t)sock.driverdata).receiveMessage;
ofs = bufferLength;
// message type
buffer[ofs++] = 2;
// length
buffer[ofs++] = (byte)(data.cursize & 0xff);
buffer[ofs++] = (byte)(data.cursize >> 8);
// align
ofs++;
// message
Buffer.BlockCopy(data.data, 0, buffer, ofs, data.cursize);
((qsocket_t)sock.driverdata).receiveMessageLength = IntAlign(bufferLength + data.cursize + 4);
return 1;
}
/*
===================
NET_NewQSocket
Called by drivers when a new communications endpoint is required
The sequence and buffer fields will be filled in properly
===================
*/
static qsocket_t NET_NewQSocket()
{
qsocket_t sock;
if (net_freeSockets == null)
return null;
if (net_activeconnections >= server.svs.maxclients)
return null;
// get one from free list
sock = net_freeSockets;
net_freeSockets = sock.next;
// add it to active list
sock.next = net_activeSockets;
net_activeSockets = sock;
sock.disconnected = false;
sock.connecttime = net_time;
sock.address = "UNSET ADDRESS";
sock.driver = net_driverlevel;
sock.socket = 0;
sock.driverdata = null;
sock.canSend = true;
sock.sendNext = false;
sock.lastMessageTime = net_time;
sock.ackSequence = 0;
sock.sendSequence = 0;
sock.unreliableSendSequence = 0;
sock.sendMessageLength = 0;
sock.receiveSequence = 0;
sock.unreliableReceiveSequence = 0;
sock.receiveMessageLength = 0;
return sock;
}
