public int SendUnreliableMessage(qsocket_t sock, MsgWriter data) { if (sock.driverdata == null) { return(-1); } qsocket_t sock2 = (qsocket_t)sock.driverdata; if ((sock2.receiveMessageLength + data.Length + sizeof(byte) + sizeof(short)) > Net.NET_MAXMESSAGE) { return(0); } int 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 = IntAlign(sock2.receiveMessageLength + data.Length + 4); return(1); }
public qsocket_t CheckNewConnections() { if (Host.Time != _Next.time || _Next.op != VcrOp.VCR_OP_CONNECT) { Sys.Error("VCR missmatch"); } if (_Next.session == 0) { ReadNext(); return(null); } qsocket_t sock = Net.NewSocket(); sock.driverdata = _Next.session; byte[] buf = new byte[Net.NET_NAMELEN]; Host.VcrReader.Read(buf, 0, buf.Length); sock.address = Encoding.ASCII.GetString(buf); ReadNext(); return(sock); }
/// <summary> /// NET_SendUnreliableMessage /// 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 /// </summary> public static int SendUnreliableMessage(qsocket_t sock, MsgWriter data) { if (sock == null) { return(-1); } if (sock.disconnected) { Con.Print("NET_SendMessage: disconnected socket\n"); return(-1); } SetNetTime(); int r = _Drivers[sock.driver].SendUnreliableMessage(sock, data); if (r == 1 && sock.driver != 0) { _UnreliableMessagesSent++; } if (_IsRecording) { _VcrSendMessage.time = Host.Time; _VcrSendMessage.op = VcrOp.VCR_OP_SENDMESSAGE; _VcrSendMessage.session = 1;// (long)sock; Uze todo: ??????? _VcrSendMessage.ret = r; byte[] buf = Sys.StructureToBytes(ref _VcrSendMessage); Host.VcrWriter.Write(buf); } return(r); }
/// <summary> /// NET_CanSendMessage /// Returns true or false if the given qsocket can currently accept a /// message to be transmitted. /// </summary> public static bool CanSendMessage(qsocket_t sock) { if (sock == null) { return(false); } if (sock.disconnected) { return(false); } SetNetTime(); bool r = _Drivers[sock.driver].CanSendMessage(sock); if (_IsRecording) { _VcrSendMessage.time = Host.Time; _VcrSendMessage.op = VcrOp.VCR_OP_CANSENDMESSAGE; _VcrSendMessage.session = 1; // (long)sock; Uze: todo: do something? _VcrSendMessage.ret = r ? 1 : 0; byte[] buf = Sys.StructureToBytes(ref _VcrSendMessage); Host.VcrWriter.Write(buf, 0, buf.Length); } return(r); }
/// <summary> /// SV_CheckForNewClients /// </summary> public static void 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; ConnectClient(i); Net.ActiveConnections++; } }
public int GetMessage(qsocket_t sock) { if (sock.receiveMessageLength == 0) { return(0); } int ret = sock.receiveMessage[0]; int length = sock.receiveMessage[1] + (sock.receiveMessage[2] << 8); // alignment byte skipped here Net.Message.Clear(); Net.Message.FillFrom(sock.receiveMessage, 4, length); length = 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); }
public int SendMessage(qsocket_t sock, MsgWriter data) { if (sock.driverdata == null) { return(-1); } qsocket_t sock2 = (qsocket_t)sock.driverdata; if ((sock2.receiveMessageLength + data.Length + 4) > Net.NET_MAXMESSAGE) { Sys.Error("Loop_SendMessage: overflow\n"); } // message type int 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 = IntAlign(sock2.receiveMessageLength + data.Length + 4); sock.canSend = false; return(1); }
public bool CanSendMessage(qsocket_t sock) { if (sock.driverdata == null) { return(false); } return(sock.canSend); }
/// <summary> /// NET_FreeQSocket /// </summary> public static void FreeSocket(qsocket_t sock) { // remove it from active list if (!_ActiveSockets.Remove(sock)) { Sys.Error("NET_FreeQSocket: not active\n"); } // add it to free list _FreeSockets.Add(sock); sock.disconnected = true; }
public int SendMessage(qsocket_t sock, MsgWriter data) { if (Host.Time != _Next.time || _Next.op != VcrOp.VCR_OP_SENDMESSAGE || _Next.session != SocketToSession(sock)) { Sys.Error("VCR missmatch"); } int ret = Host.VcrReader.ReadInt32(); ReadNext(); return(ret); }
public bool CanSendMessage(qsocket_t sock) { if (Host.Time != _Next.time || _Next.op != VcrOp.VCR_OP_CANSENDMESSAGE || _Next.session != SocketToSession(sock)) { Sys.Error("VCR missmatch"); } int ret = Host.VcrReader.ReadInt32(); ReadNext(); return(ret != 0); }
/// <summary> /// NET_CheckNewConnections /// </summary> /// <returns></returns> public static qsocket_t CheckNewConnections() { SetNetTime(); for (_DriverLevel = 0; _DriverLevel < _Drivers.Length; _DriverLevel++) { if (!_Drivers[_DriverLevel].IsInitialized) { continue; } if (_DriverLevel > 0 && !_IsListening) { continue; } qsocket_t ret = Net.Driver.CheckNewConnections(); if (ret != null) { if (_IsRecording) { _VcrConnect.time = Host.Time; _VcrConnect.op = VcrOp.VCR_OP_CONNECT; _VcrConnect.session = 1; // (long)ret; // Uze: todo: make it work on 64bit systems byte[] buf = Sys.StructureToBytes(ref _VcrConnect); Host.VcrWriter.Write(buf, 0, buf.Length); buf = Encoding.ASCII.GetBytes(ret.address); int count = Math.Min(buf.Length, NET_NAMELEN); int extra = NET_NAMELEN - count; Host.VcrWriter.Write(buf, 0, count); for (int i = 0; i < extra; i++) { Host.VcrWriter.Write((byte)0); } } return(ret); } } if (_IsRecording) { _VcrConnect.time = Host.Time; _VcrConnect.op = VcrOp.VCR_OP_CONNECT; _VcrConnect.session = 0; byte[] buf = Sys.StructureToBytes(ref _VcrConnect); Host.VcrWriter.Write(buf, 0, buf.Length); } return(null); }
/// <summary> /// Datagram_CheckNewConnections /// </summary> public qsocket_t CheckNewConnections() { qsocket_t ret = null; for (Net.LanDriverLevel = 0; Net.LanDriverLevel < Net.LanDrivers.Length; Net.LanDriverLevel++) { if (Net.LanDriver.IsInitialized) { ret = InternalCheckNewConnections(); if (ret != null) { break; } } } return(ret); }
/// <summary> /// Datagram_Connect /// </summary> public qsocket_t Connect(string host) { qsocket_t ret = null; for (Net.LanDriverLevel = 0; Net.LanDriverLevel < Net.LanDrivers.Length; Net.LanDriverLevel++) { if (Net.LanDrivers[Net.LanDriverLevel].IsInitialized) { ret = InternalConnect(host); if (ret != null) { break; } } } return(ret); }
public void Close(qsocket_t sock) { if (sock.driverdata != null) { ((qsocket_t)sock.driverdata).driverdata = null; } sock.ClearBuffers(); sock.canSend = true; if (sock == _Client) { _Client = null; } else { _Server = null; } }
/// <summary> /// NET_Close /// </summary> public static void Close(qsocket_t sock) { if (sock == null) { return; } if (sock.disconnected) { return; } SetNetTime(); // call the driver_Close function _Drivers[sock.driver].Close(sock); FreeSocket(sock); }
public void Clear() { this.active = false; this.spawned = false; this.dropasap = false; this.privileged = false; this.sendsignon = false; this.last_message = 0; this.netconnection = null; this.cmd.Clear(); this.wishdir = Vector3.Zero; this.message.Clear(); this.edict = null; this.name = null; this.colors = 0; Array.Clear(this.ping_times, 0, this.ping_times.Length); this.num_pings = 0; Array.Clear(this.spawn_parms, 0, this.spawn_parms.Length); this.old_frags = 0; }
/// <summary> /// SV_ConnectClient /// Initializes a client_t for a new net connection. This will only be called /// once for a player each game, not once for each level change. /// </summary> static void ConnectClient(int clientnum) { client_t client = svs.clients[clientnum]; Con.DPrint("Client {0} connected\n", client.netconnection.address); int edictnum = clientnum + 1; edict_t ent = EdictNum(edictnum); // set up the client_t qsocket_t netconnection = client.netconnection; float[] spawn_parms = new float[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 Progs.Execute(Progs.GlobalStruct.SetNewParms); AssignGlobalSpawnparams(client); } SendServerInfo(client); }
/// <summary> /// NET_NewQSocket /// Called by drivers when a new communications endpoint is required /// The sequence and buffer fields will be filled in properly /// </summary> public static qsocket_t NewSocket() { if (_FreeSockets.Count == 0) { return(null); } if (Net.ActiveConnections >= Server.svs.maxclients) { return(null); } // get one from free list int i = _FreeSockets.Count - 1; qsocket_t sock = _FreeSockets[i]; _FreeSockets.RemoveAt(i); // add it to active list _ActiveSockets.Add(sock); sock.disconnected = false; sock.connecttime = _Time; sock.address = "UNSET ADDRESS"; sock.driver = _DriverLevel; sock.socket = null; sock.driverdata = null; sock.canSend = true; sock.sendNext = false; sock.lastMessageTime = _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 qsocket_t Connect(string host) { if (host != "local") { return(null); } _LocalConnectPending = true; if (_Client == null) { _Client = Net.NewSocket(); if (_Client == null) { Con.Print("Loop_Connect: no qsocket available\n"); return(null); } _Client.address = "localhost"; } _Client.ClearBuffers(); _Client.canSend = true; if (_Server == null) { _Server = Net.NewSocket(); if (_Server == null) { Con.Print("Loop_Connect: no qsocket available\n"); return(null); } _Server.address = "LOCAL"; } _Server.ClearBuffers(); _Server.canSend = true; _Client.driverdata = _Server; _Server.driverdata = _Client; return(_Client); }
public int GetMessage(qsocket_t sock) { if (Host.Time != _Next.time || _Next.op != VcrOp.VCR_OP_GETMESSAGE || _Next.session != SocketToSession(sock)) { Sys.Error("VCR missmatch"); } int ret = Host.VcrReader.ReadInt32(); if (ret != 1) { ReadNext(); return(ret); } int length = Host.VcrReader.ReadInt32(); Net.Message.FillFrom(Host.VcrReader.BaseStream, length); ReadNext(); return(1); }
public long SocketToSession(qsocket_t sock) { return((long)sock.driverdata); }
public void Close(qsocket_t sock) { // nothing to do }
public bool CanSendUnreliableMessage(qsocket_t sock) { return(true); }
public int SendUnreliableMessage(qsocket_t sock, MsgWriter data) { throw new NotImplementedException(); }
/// <summary> /// NET_Connect /// called by client to connect to a host. Returns -1 if not able to connect /// </summary> public static qsocket_t Connect(string host) { int numdrivers = _Drivers.Length;// net_numdrivers; SetNetTime(); if (String.IsNullOrEmpty(host)) { host = null; } if (host != null) { if (Common.SameText(host, "local")) { numdrivers = 1; goto JustDoIt; } if (HostCacheCount > 0) { foreach (hostcache_t hc in _HostCache) { if (Common.SameText(hc.name, host)) { host = hc.cname; goto JustDoIt; } } } } SlistSilent = (host != null); Slist_f(); while (_SlistInProgress) { Poll(); } if (host == null) { if (HostCacheCount != 1) { return(null); } host = _HostCache[0].cname; Con.Print("Connecting to...\n{0} @ {1}\n\n", _HostCache[0].name, host); } _DriverLevel = 0; foreach (hostcache_t hc in _HostCache) { if (Common.SameText(host, hc.name)) { host = hc.cname; break; } _DriverLevel++; } JustDoIt: _DriverLevel = 0; foreach (INetDriver drv in _Drivers) { if (!drv.IsInitialized) { continue; } qsocket_t ret = drv.Connect(host); if (ret != null) { return(ret); } _DriverLevel++; } if (host != null) { Con.Print("\n"); PrintSlistHeader(); PrintSlist(); PrintSlistTrailer(); } return(null); }
/// <summary> /// NET_GetMessage /// 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 /// </summary> public static int GetMessage(qsocket_t sock) { //int ret; if (sock == null) { return(-1); } if (sock.disconnected) { Con.Print("NET_GetMessage: disconnected socket\n"); return(-1); } SetNetTime(); int ret = _Drivers[sock.driver].GetMessage(sock); // see if this connection has timed out if (ret == 0 && sock.driver != 0) { if (_Time - sock.lastMessageTime > _MessageTimeout.Value) { Close(sock); return(-1); } } if (ret > 0) { if (sock.driver != 0) { sock.lastMessageTime = _Time; if (ret == 1) { _MessagesReceived++; } else if (ret == 2) { _UnreliableMessagesReceived++; } } if (_IsRecording) { _VcrGetMessage.time = Host.Time; _VcrGetMessage.op = VcrOp.VCR_OP_GETMESSAGE; _VcrGetMessage.session = 1;// (long)sock; Uze todo: write somethisng meaningful _VcrGetMessage.ret = ret; byte[] buf = Sys.StructureToBytes(ref _VcrGetMessage); Host.VcrWriter.Write(buf, 0, buf.Length); Host.VcrWriter.Write(Net.Message.Length); Host.VcrWriter.Write(Net.Message.Data, 0, Net.Message.Length); } } else { if (_IsRecording) { _VcrGetMessage.time = Host.Time; _VcrGetMessage.op = VcrOp.VCR_OP_GETMESSAGE; _VcrGetMessage.session = 1; // (long)sock; Uze todo: fix this _VcrGetMessage.ret = ret; byte[] buf = Sys.StructureToBytes(ref _VcrGetMessage); Host.VcrWriter.Write(buf, 0, buf.Length); } } return(ret); }
/// <summary> /// _Datagram_Connect /// </summary> qsocket_t InternalConnect(string host) { // see if we can resolve the host name EndPoint sendaddr = Net.LanDriver.GetAddrFromName(host); if (sendaddr == null) { return(null); } Socket newsock = Net.LanDriver.OpenSocket(0); if (newsock == null) { return(null); } qsocket_t sock = Net.NewSocket(); if (sock == null) { goto ErrorReturn2; } sock.socket = newsock; sock.landriver = Net.LanDriverLevel; // connect to the host if (Net.LanDriver.Connect(newsock, sendaddr) == -1) { goto ErrorReturn; } // send the connection request Con.Print("trying...\n"); Scr.UpdateScreen(); double start_time = Net.Time; int ret = 0; for (int reps = 0; reps < 3; reps++) { Net.Message.Clear(); // save space for the header, filled in later Net.Message.WriteLong(0); Net.Message.WriteByte(CCReq.CCREQ_CONNECT); Net.Message.WriteString("QUAKE"); Net.Message.WriteByte(Net.NET_PROTOCOL_VERSION); Common.WriteInt(Net.Message.Data, 0, Common.BigLong(NetFlags.NETFLAG_CTL | (Net.Message.Length & NetFlags.NETFLAG_LENGTH_MASK))); //*((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK)); Net.LanDriver.Write(newsock, Net.Message.Data, Net.Message.Length, sendaddr); Net.Message.Clear(); EndPoint readaddr = new IPEndPoint(IPAddress.Any, 0); do { ret = Net.Message.FillFrom(newsock, ref readaddr); // if we got something, validate it if (ret > 0) { // is it from the right place? if (sock.LanDriver.AddrCompare(readaddr, sendaddr) != 0) { #if DEBUG Con.Print("wrong reply address\n"); Con.Print("Expected: {0}\n", StrAddr(sendaddr)); Con.Print("Received: {0}\n", StrAddr(readaddr)); Scr.UpdateScreen(); #endif ret = 0; continue; } if (ret < sizeof(int)) { ret = 0; continue; } Net.Reader.Reset(); int control = Common.BigLong(Net.Reader.ReadLong());// BigLong(*((int *)net_message.data)); //MSG_ReadLong(); if (control == -1) { ret = 0; continue; } if ((control & (~NetFlags.NETFLAG_LENGTH_MASK)) != NetFlags.NETFLAG_CTL) { ret = 0; continue; } if ((control & NetFlags.NETFLAG_LENGTH_MASK) != ret) { ret = 0; continue; } } }while ((ret == 0) && (Net.SetNetTime() - start_time) < 2.5); if (ret > 0) { break; } Con.Print("still trying...\n"); Scr.UpdateScreen(); start_time = Net.SetNetTime(); } string reason = String.Empty; if (ret == 0) { reason = "No Response"; Con.Print("{0}\n", reason); Menu.ReturnReason = reason; goto ErrorReturn; } if (ret == -1) { reason = "Network Error"; Con.Print("{0}\n", reason); Menu.ReturnReason = reason; goto ErrorReturn; } ret = Net.Reader.ReadByte(); if (ret == CCRep.CCREP_REJECT) { reason = Net.Reader.ReadString(); Con.Print(reason); Menu.ReturnReason = reason; goto ErrorReturn; } if (ret == CCRep.CCREP_ACCEPT) { IPEndPoint ep = (IPEndPoint)sendaddr; sock.addr = new IPEndPoint(ep.Address, ep.Port); Net.LanDriver.SetSocketPort(sock.addr, Net.Reader.ReadLong()); } else { reason = "Bad Response"; Con.Print("{0}\n", reason); Menu.ReturnReason = reason; goto ErrorReturn; } sock.address = Net.LanDriver.GetNameFromAddr(sendaddr); Con.Print("Connection accepted\n"); sock.lastMessageTime = Net.SetNetTime(); // switch the connection to the specified address if (Net.LanDriver.Connect(newsock, sock.addr) == -1) { reason = "Connect to Game failed"; Con.Print("{0}\n", reason); Menu.ReturnReason = reason; goto ErrorReturn; } Menu.ReturnOnError = false; return(sock); ErrorReturn: Net.FreeSocket(sock); ErrorReturn2: Net.LanDriver.CloseSocket(newsock); if (Menu.ReturnOnError && Menu.ReturnMenu != null) { Menu.ReturnMenu.Show(); Menu.ReturnOnError = false; } return(null); }