public ConnectionEventInfo(ConnectionBase sourceConn, HostProtocolSupport protocolSupport)
{
this.Source = sourceConn;
this.Event = ConnectionEvents.ProtocolSupport;
this.State = HTTPConnectionStates.Initial;
this.ProtocolSupport = protocolSupport;
}
public ConnectionEventInfo(ConnectionBase sourceConn, ConnectionEvents @event)
{
this.Source = sourceConn;
this.Event = @event;
this.State = HTTPConnectionStates.Initial;
this.ProtocolSupport = HostProtocolSupport.Unknown;
}
//
// This is the callback delegate that will be invoked when a connection
// changes state from connected to disconnected (and vice versa)
//
static void NotifyConnectionState(Object src, ConnectionEvents cev)
{
Console.WriteLine("Connection Status: " + cev.GetState.ToString() +
" (Souce:" + cev.GetSource +
" Destination:" + cev.GetDestination +
" Relay1:" + cev.GetRelay1 +
" Relay2:" + cev.GetRelay2 +
" ID:" + cev.GetConnectionID +
")");
}
public ConnectionEventInfo(ConnectionBase sourceConn, HTTPConnectionStates newState)
{
this.Source = sourceConn;
this.Event = ConnectionEvents.StateChange;
this.State = newState;
this.ProtocolSupport = HostProtocolSupport.Unknown;
}
public ConnectionEventInfo(ConnectionBase sourceConn, HTTPRequest request)
{
this.Source = sourceConn;
this.Event = ConnectionEvents.StateChange;
this.State = HTTPConnectionStates.ClosedResendRequest;
this.ProtocolSupport = HostProtocolSupport.Unknown;
this.Request = request;
}
private void HandleClientConnectionApproval(Client client, NetIncomingMessage msg)
{
var type = msg.ReadInt32();
var length = msg.ReadInt32();
var connReq = Util.DeserializeBinary <ConnectionRequest>(msg.ReadBytes(length));
if (connReq == null)
{
DenyConnect(client, "Connection is null, this is most likely a bug in the client.", true, msg);
return;
}
var pluginResponse = ConnectionEvents.ConnectionRequest(client, connReq);
if (!pluginResponse.ContinueServerProc)
{
return;
}
connReq = pluginResponse.Data;
client.DisplayName = connReq.DisplayName;
client.Name = connReq.Name;
client.GameVersion = connReq.GameVersion;
client.RemoteScriptVersion = (ScriptVersion)connReq.ScriptVersion;
// If nicknames are disabled on the server, set the nickname to the player's social club name.
if (!AllowNicknames)
{
SendNotificationToPlayer(client,
$"Nicknames are disabled on this server. Your nickname has been set to {connReq.Name}");
client.DisplayName = client.Name;
}
logger.LogInformation(
$"New connection request: {client.DisplayName}@{msg.SenderEndPoint.Address.ToString()} | Game version: {client.GameVersion.ToString()} | Script version: {client.RemoteScriptVersion.ToString()}");
var latestScriptVersion = Enum.GetValues(typeof(ScriptVersion)).Cast <ScriptVersion>().Last();
if (!AllowOutdatedClients &&
(ScriptVersion)connReq.ScriptVersion != latestScriptVersion)
{
var latestReadableScriptVersion = latestScriptVersion.ToString();
latestReadableScriptVersion = Regex.Replace(latestReadableScriptVersion, "VERSION_", "",
RegexOptions.IgnoreCase);
latestReadableScriptVersion = Regex.Replace(latestReadableScriptVersion, "_", ".",
RegexOptions.IgnoreCase);
logger.LogInformation($"Client {client.DisplayName} tried to connect with an outdated script version {client.RemoteScriptVersion.ToString()} but the server requires {latestScriptVersion.ToString()}");
DenyConnect(client, $"Please update to version ${latestReadableScriptVersion} from http://bit.ly/gtacoop", true, msg);
return;
}
else if (client.RemoteScriptVersion != latestScriptVersion)
{
SendNotificationToPlayer(client, "You are currently on an outdated client. Please go to http://bit.ly/gtacoop and update.");
}
else if (client.RemoteScriptVersion == ScriptVersion.VERSION_UNKNOWN)
{
logger.LogInformation($"Client {client.DisplayName} tried to connect with an unknown script version (client too old?)");
DenyConnect(client, $"Unknown version. Please re-download GTACoop from http://bit.ly/gtacoop", true, msg);
return;
}
var numClients = 0;
lock (Clients) numClients = Clients.Count;
if (numClients >= MaxPlayers)
{
logger.LogInformation($"Player tried to join while server is full: {client.DisplayName}");
DenyConnect(client, "No available player slots.", true, msg);
}
if (PasswordProtected && connReq.Password != Password)
{
logger.LogInformation($"Client {client.DisplayName} tried to connect with the wrong password.");
DenyConnect(client, "Wrong password.", true, msg);
}
lock (Clients)
if (Clients.Any(c => c.DisplayName == client.DisplayName))
{
DenyConnect(client, "A player already exists with the current display name.");
}
else
{
Clients.Add(client);
}
var channelHail = Server.CreateMessage();
channelHail.Write(GetChannelForClient(client));
client.NetConnection.Approve(channelHail);
}
private void Awake()
{
Instance = this;
}
private static ServerHandshakePacket BeginConnection(ConnectionEvents events, string ip, int port)
{
events.OnStatusUpdate?.Invoke("Connecting To Master Server...");
TcpClient c = null;
try
{
c = new TcpClient(ip, port);
events.OnStatusUpdate?.Invoke("Connected to Server...");
}
catch (Exception connEX)
{
events.OnError?.Invoke(MatchMakingErrorCode.SocketException, connEX);
events.OnStatusUpdate?.Invoke("Connection Failed... Exception: \n" + connEX.Message);
return(new ServerHandshakePacket()
{
ErrorCode = MatchMakingErrorCode.SocketException, ErrorException = connEX
});
}
object obj = null;
try
{
events.OnStatusUpdate?.Invoke("Waiting for Handshake...");
if (!SerializerSingleton.Serializer.TryReadPacket(c.GetStream(), out obj))
{
throw new Exception();
}
}
catch (Exception e)
{
events.OnStatusUpdate?.Invoke("Handshake Failed... Exception: \n" + e.Message);
events.OnError?.Invoke(MatchMakingErrorCode.PacketDeserializationException, e);
return(new ServerHandshakePacket()
{
ErrorCode = MatchMakingErrorCode.PacketDeserializationException, ErrorException = e
});
}
if (obj == null)
{
events.OnStatusUpdate?.Invoke("Handshake Failed... Deserialized object was null");
events.OnError?.Invoke(MatchMakingErrorCode.PacketDeserializationException, null);
return(new ServerHandshakePacket()
{
ErrorCode = MatchMakingErrorCode.PacketDeserializationException
});
}
if (obj is ClientHandshakePacket)
{
events.OnStatusUpdate?.Invoke("Handshake Received..");
ClientHandshakePacket packet = (ClientHandshakePacket)obj;
ServerHandshakePacket sp = new ServerHandshakePacket
{
Client = c,
HeartBeat = packet.HeartBeat,
CurrentInstances = packet.CurrentInstances,
MaxInstances = packet.MaxInstances,
WaitingQueue = packet.WaitingQueue
};
return(sp);
}
events.OnStatusUpdate?.Invoke("Handshake Failed... Wrong Packet Received");
events.OnError?.Invoke(MatchMakingErrorCode.WrongPacketReceived, null);
return(new ServerHandshakePacket()
{
ErrorCode = MatchMakingErrorCode.WrongPacketReceived
});
//throw new Exception("Expected Packet of Type ClientHandshakePacket. Got: " + obj.GetType());
}
public static ServerInstanceResultPacket Queue(ConnectionEvents events, string ip, int port, CancellationToken token)
{
ServerHandshakePacket conn = BeginConnection(events, ip, port);
return(FindMatch(events, conn, token));
}
public static Task <ServerInstanceResultPacket> QueueAsync(ConnectionEvents events, string ip, int port, CancellationToken token)
{
Logger.DefaultLogger(events.ToString());
return(new Task <ServerInstanceResultPacket>(() => Queue(events, ip, port, token)));
}
//public static ServerInstanceResultPacket FindMatch(ConnectionEvents events, ServerHandshakePacket packet)
//{
// return FindMatch(events, packet, new CancellationToken());
//}
private static ServerInstanceResultPacket FindMatch(ConnectionEvents events, ServerHandshakePacket packet, CancellationToken token)
{
if (packet.ErrorCode != MatchMakingErrorCode.None)
{
return(new ServerInstanceResultPacket()
{
ErrorCode = packet.ErrorCode, ErrorException = packet.ErrorException
});
}
//try
//{
TcpClient c = packet.Client;
int waitTime = packet.HeartBeat;
events.OnStatusUpdate?.Invoke("In Queue..");
Logger.DefaultLogger(packet.ToString());
while (c.Connected && c.Available == 0)
{
if (token.IsCancellationRequested)
{
Logger.DefaultLogger("Aborting Queue");
events.OnStatusUpdate?.Invoke("Aborting Queue...");
events.OnError?.Invoke(MatchMakingErrorCode.ClientQueueAborted, null);
return(new ServerInstanceResultPacket()
{
ErrorCode = MatchMakingErrorCode.ClientQueueAborted
});
}
try
{
if (!SerializerSingleton.Serializer.TryWritePacket(c.GetStream(), new ClientHeartBeatPacket()))
{
throw new Exception("Serializer Write Error");
}
}
catch (Exception e)
{
events.OnStatusUpdate?.Invoke("Packet Could not be Deserialized. Exception: " + e.Message);
break; //We could still have some data in the stream that could be our instance ready packet
//events.OnError?.Invoke(MatchMakingErrorCode.PacketSerializationException, e);
//return new ServerInstanceResultPacket() { ErrorCode = MatchMakingErrorCode.PacketSerializationException, ErrorException = e };
}
Thread.Sleep(waitTime);
Logger.DefaultLogger("Heartbeat...");
}
if (c.Available == 0)
{
events.OnStatusUpdate?.Invoke("Client or Server has Disconnected during Queue.");
events.OnError?.Invoke(MatchMakingErrorCode.ClientDisconnectDuringReady, null);
return(new ServerInstanceResultPacket()
{
ErrorCode = MatchMakingErrorCode.ClientDisconnectDuringReady
});
}
ClientInstanceReadyPacket irp;
events.OnStatusUpdate?.Invoke("Creating Match...");
try
{
if (!SerializerSingleton.Serializer.TryReadPacket(c.GetStream(), out irp))
{
throw new Exception();
}
events.OnStatusUpdate?.Invoke("Received Packet Data..");
}
catch (Exception e)
{
events.OnStatusUpdate?.Invoke("Packet Could not be Deserialized. Exception: " + e.Message);
events.OnError?.Invoke(MatchMakingErrorCode.PacketSerializationException, e);
return(new ServerInstanceResultPacket()
{
ErrorCode = MatchMakingErrorCode.PacketSerializationException, ErrorException = e
});
}
events.OnStatusUpdate?.Invoke("Match Starting on Port: " + irp.Port);
Logger.DefaultLogger($"Client: Current Instances: {packet.CurrentInstances}/{packet.MaxInstances}");
Logger.DefaultLogger($"Client: Clients in Queue: {packet.WaitingQueue}");
Logger.DefaultLogger($"Client: Instance Ready: {irp.Port}");
if (c.Connected)
{
c.Close();
}
ServerInstanceResultPacket ret = new ServerInstanceResultPacket {
Port = irp.Port, ErrorCode = MatchMakingErrorCode.None
};
events.OnSuccess?.Invoke(ret);
return(ret);
//}
//catch (Exception unhandled)
//{
// events.OnStatusUpdate?.Invoke("Packet Could not be Deserialized. Exception: " + unhandled.Message);
// events.OnError?.Invoke(MatchMakingErrorCode.PacketSerializationException, unhandled);
// return new ServerInstanceResultPacket() { Port = -1, ErrorCode = MatchMakingErrorCode.UnhandledError, ErrorException = unhandled };
//}
}
