Client.TCP Class Reference

Handles TCP connection. More...

Public Member Functions
void	Connect ()
	Establishes a TCP connection to the server and begins receiving data.
void	Send (Packet Packet)
	Sends a packet to the server using TCP.
void	Disconnect ()
	Disconnects the TCP connection and clears the buffers.

Public Attributes
TcpClient	Socket

Private Member Functions
bool	Handler (byte[] data)
	Handles received raw byte data from the server.
void	ConnectCallback (IAsyncResult result)
	Callback triggered after attempting to connect to the server by TCP. Initializes TLS if enabled, sets up the stream, and begins reading data.
void	ReceiveCallback (IAsyncResult result)
	Callback for receiving data over the TCP. Reads data into the data buffer, manages it by Handler and continues reading.

Static Private Member Functions
static bool	ValidateServerCertificate (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
	Validates the server's SSL/TLS certificate. Returns true if the certificate is valid; else writes error and returns false.

Private Attributes
Stream	Stream
byte[]	receiveBuffer
Packet	receivedPacket

Detailed Description

Handles TCP connection.

Definition at line 291 of file Client.cs.

Member Function Documentation

Connect()

void Client.TCP.Connect

(

)

Establishes a TCP connection to the server and begins receiving data.

Definition at line 300 of file Client.cs.

        {
            if(Client.instance.GetUsername() == "")
            {
                System.Random rng = new System.Random();
                int rand = rng.Next(1000); 
                Client.instance.SetUsername("Guest" + rand.ToString());
            }
            Socket = new TcpClient 
            {
                ReceiveBufferSize = DefaultBufferSize,
                SendBufferSize = DefaultBufferSize
            };
            receiveBuffer = new byte[DefaultBufferSize]; 
            Socket.BeginConnect(Client.instance.defaultNetworkSettings.ipAddress, Client.instance.defaultNetworkSettings.port, ConnectCallback, Socket); // zacne asynchronne pripojenie k serveru, ak uspesne da callback
        }

ConnectCallback()

void Client.TCP.ConnectCallback ( IAsyncResult result )

private

Callback triggered after attempting to connect to the server by TCP. Initializes TLS if enabled, sets up the stream, and begins reading data.

Definition at line 401 of file Client.cs.

        {
            try
            {
                Socket.EndConnect(result); 
                if (!Socket.Connected)
                {
                    return;
                }
                if (Client.instance.defaultNetworkSettings.useTLS == true)
                {
                    SslStream ScStream = new SslStream(Socket.GetStream(), false, ValidateServerCertificate);
                    ScStream.AuthenticateAsClient(Client.instance.defaultNetworkSettings.ipAddress); 
 
                    receiveBuffer = new byte[Client.DefaultBufferSize];
                    receivedPacket = new Packet();
                    Stream = ScStream;
                } else
                {
                    Stream = Socket.GetStream();
                    receiveBuffer = new byte[Client.DefaultBufferSize];
                    receivedPacket = new Packet();
                }
                Stream.BeginRead(receiveBuffer, 0, Client.DefaultBufferSize, ReceiveCallback, null); 
                Client.instance.isConnected = true;
                ThreadsController.StartOnMainThread(() =>
                {
                    Client.instance.OnConnected?.Invoke();
                });
            }
            catch (Exception ex)
            {
                Debug.LogError($"Error during SSL/TLS handshake: {ex.Message}");
                ThreadsController.StartOnMainThread(() =>
                {
                    Client.instance.OnConnectionFailed?.Invoke($"Error during SSL/TLS handshake: {ex.Message}");
                });
                Disconnect();
            }
        }

Disconnect()

void Client.TCP.Disconnect

(

)

Disconnects the TCP connection and clears the buffers.

Definition at line 336 of file Client.cs.

        {
            Stream = null;
            receivedPacket = null;
            receiveBuffer = null;
            Socket = null;
        }

Handler()

bool Client.TCP.Handler ( byte[] data )

private

Handles received raw byte data from the server.

Definition at line 358 of file Client.cs.

        {
            int packetLength = 0;
            receivedPacket.AddBytesToBuffers(data);
            if (receivedPacket.UnreadLength() >= 4)
            {
                packetLength = receivedPacket.ReadInt();
                if (packetLength <= 0)
                {
                    return true;
                }
            }
            while (packetLength > 0 && packetLength <= receivedPacket.UnreadLength())
            {
                byte[] packetBytes = receivedPacket.ReadBytes(packetLength);
                ThreadsController.StartOnMainThread(() =>
                {
                Packet packet = new Packet(packetBytes); 
                int packetId = packet.ReadInt();
                PacketAction(packetId, packet); 
                });
                packetLength = 0;
                if (receivedPacket.UnreadLength() >= 4)
                {
                    packetLength = receivedPacket.ReadInt();
                    if (packetLength <= 0)
                    {
                        return true;
                    }
                }
            }
            if (packetLength <= 1)
            {
                return true;
            }
            return false;
        }

ReceiveCallback()

void Client.TCP.ReceiveCallback ( IAsyncResult result )

private

Callback for receiving data over the TCP. Reads data into the data buffer, manages it by Handler and continues reading.

Definition at line 445 of file Client.cs.

        {
            try
            {
                int dataLength = Stream.EndRead(result); 
                if (dataLength <= 0) 
                {
                    instance.Disconnect();
                    return;
                }
                byte[] data = new byte[dataLength];
                Array.Copy(receiveBuffer, data, dataLength); 
                receivedPacket.ClearPacket(Handler(data));
                Stream.BeginRead(receiveBuffer, 0, DefaultBufferSize, ReceiveCallback, null);
            }
            catch (Exception ex) {
                Debug.LogError($"Error connecting {ex}");
            }
        }

Send()

void Client.TCP.Send

(

Packet

Packet

)

Sends a packet to the server using TCP.

Definition at line 319 of file Client.cs.

        {
            try
            {
                if (Socket != null)
                {
                    Stream.BeginWrite(Packet.ConvertToArray(), 0, Packet.DataLength(), null, null);
                }
            }
            catch (Exception _ex)
            {
                Debug.LogError($"Error sending data to server via TCP: {_ex}");
            }
        }

ValidateServerCertificate()

bool Client.TCP.ValidateServerCertificate ( object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors )

staticprivate

Validates the server's SSL/TLS certificate. Returns true if the certificate is valid; else writes error and returns false.

Definition at line 346 of file Client.cs.

        {
            if (sslPolicyErrors == SslPolicyErrors.None)
            {
                return true; 
            }
            Debug.LogError($"SSL/TLS validation error: {sslPolicyErrors}");
            return false; 
        }

Member Data Documentation

receiveBuffer

byte [] Client.TCP.receiveBuffer

private

Definition at line 295 of file Client.cs.

receivedPacket

Packet Client.TCP.receivedPacket

private

Definition at line 296 of file Client.cs.

Socket

TcpClient Client.TCP.Socket

Definition at line 293 of file Client.cs.

Stream

Stream Client.TCP.Stream

private

Definition at line 294 of file Client.cs.