NtrClient.cs

// With <3 from Phecda

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace NtrSharp
{
    public class NtrClient
    {
        //
        public String ServerHost;
        public int ServerPort;  // Should be 8000
        public Boolean HeartbeatSendable;

        public int Progress { get; private set; }
        public Boolean IsConnected { get { return Tcp?.Connected ?? false; } }

        private UInt32 CurrentSequence;
        private UInt32 LastReadMemorySequence;
        private Object SyncLock = new object();

        private TcpClient Tcp;
        private Thread PacketRecvThread;
        private Thread HeartbeatThread;
        private NetworkStream NetStream;

        public byte[] ReadMemory;

        public NtrClient(String ServerHost)
        {
            SetServer(ServerHost, 8000);
        }

        public void SetServer(String ServerHost, int ServerPort)
        {
            this.ServerHost = ServerHost;
            this.ServerPort = ServerPort;
        }

        public void ConnectToServer()
        {
            try
            {
                if (Tcp != null) Disconnect();
                Tcp = new TcpClient();
                Tcp.NoDelay = true;
                Tcp.Connect(ServerHost, ServerPort);

                CurrentSequence = 0;
                NetStream = Tcp.GetStream();
                HeartbeatSendable = true;

                PacketRecvThread = new Thread(new ThreadStart(PacketRecvThreadStart));
                PacketRecvThread.Start();

                HeartbeatThread = new Thread(new ThreadStart(HeartbeatThreadStart));
                HeartbeatThread.Start();

                Console.WriteLine("Server Connected");
            }
            catch (Exception)
            {
                Console.WriteLine("Failed to connect");
                //throw;
            }

        }

        public void Disconnect(Boolean WaitPacketThread = true)
        {
            try
            {
                Tcp?.Close();
                if (WaitPacketThread)
                {
                    PacketRecvThread?.Join();
                }
            }
            finally
            {
                Tcp = null;
            }
        }

        private void PacketRecvThreadStart()
        {
            byte[] Buffer = new byte[84];
            UInt32[] Args = new UInt32[16];

            int Ret;

            NetworkStream Stream = NetStream;

            while (IsConnected)
            {
                try
                {
                    Ret = ReadNetworkStream(Stream, Buffer, Buffer.Length);
                    if (Ret == 0) break; // Unable to read network stream

                    int t = 0;
                    UInt32 Magic = BitConverter.ToUInt32(Buffer, t);
                    t += 4;
                    UInt32 Sequence = BitConverter.ToUInt32(Buffer, t);
                    t += 4;
                    UInt32 Type = BitConverter.ToUInt32(Buffer, t);
                    t += 4;
                    UInt32 Command = BitConverter.ToUInt32(Buffer, t);

                    // Get Args
                    for (int i = 0; i < Args.Length; i++)
                    {
                        t += 4;
                        Args[i] = BitConverter.ToUInt32(Buffer, t);
                    }
                    t += 4;
                    UInt32 DataLength = BitConverter.ToUInt32(Buffer, t);

                    if (Command != 0) Console.WriteLine("Packet: CMD = {0}, DataLen = {1}", Command, DataLength);

                    if (Magic != 0x12345678)
                    {
                        Console.WriteLine("Broken Protocol: Magic = {0:X}, Seq = {1}", Magic, Sequence);
                        break;
                    }

                    if (Command == 0)
                    {
                        if (DataLength != 0)
                        {
                            byte[] DataBuffer = new byte[DataLength];
                            ReadNetworkStream(Stream, DataBuffer, DataBuffer.Length);
                            Console.WriteLine(Encoding.UTF8.GetString(DataBuffer));
                        }

                        lock (SyncLock)
                        {
                            HeartbeatSendable = true;
                        }
                    }
                    else if (DataLength != 0)
                    {
                        byte[] DataBuffer = new byte[DataLength];
                        ReadNetworkStream(Stream, DataBuffer, DataBuffer.Length);
                        HandlePacket(Command, Sequence, DataBuffer);
                    }

                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    break;
                }
            }

            Console.WriteLine("Server Disconnected.");
            Disconnect(false);
        }

        private void HeartbeatThreadStart()
        {
            while (IsConnected)
            {
                SendHeartbeatPacket();
                //Console.WriteLine("Trying to send HeartbeatPacket");
                Thread.Sleep(1000);
            }
        }

        private int ReadNetworkStream(NetworkStream Stream, byte[] Buffer, int Length)
        {
            int Index = 0;
            Boolean UseProgress = (Length > 0x100000);

            do
            {
                if (UseProgress) Progress = (int)(((double)(Index) / Length) * 100);

                int Len = Stream.Read(Buffer, Index, Length - Index);
                if (Len == 0) return 0;

                Index += Len;
            } while (Index < Length);

            return Length;
        }

        private void HandlePacket(UInt32 Command, UInt32 Sequence, byte[] DataBuffer)
        {
            if (Command == 9)
            {
                HandleReadMemory(Sequence, DataBuffer);
            }
        }

        /* MODIFIED */
        private void HandleReadMemory(UInt32 Sequence, byte[] DataBuffer)
        {
            if (Sequence != LastReadMemorySequence)
            {
                Console.WriteLine("{0} != {1} ignored", Sequence, LastReadMemorySequence);
                return;
            }

            LastReadMemorySequence = 0;
            ReadMemory = DataBuffer;
        }

        // Send Packets

        public void SendPacket(UInt32 Type, UInt32 Command, UInt32[] Args, UInt32 DataLen)
        {
            int t = 0;
            CurrentSequence += 1000;
            byte[] Buffer = new byte[84];
            BitConverter.GetBytes(0x12345678).CopyTo(Buffer, t);
            t += 4;
            BitConverter.GetBytes(CurrentSequence).CopyTo(Buffer, t);
            t += 4;
            BitConverter.GetBytes(Type).CopyTo(Buffer, t);
            t += 4;
            BitConverter.GetBytes(Command).CopyTo(Buffer, t);
            for (int i = 0; i < 16; i++)
            {
                t += 4;
                if (Args?.Length > i) BitConverter.GetBytes(Args[i]).CopyTo(Buffer, t);
                else BitConverter.GetBytes(0).CopyTo(Buffer, t); // remove this? Test it later TODO
            }
            t += 4;
            BitConverter.GetBytes(DataLen).CopyTo(Buffer, t);
            NetStream.Write(Buffer, 0, Buffer.Length);
        }

        public void SendEmptyPacket(UInt32 Command, params UInt32[] Args)
        {
            SendPacket(0, Command, Args, 0);
        }

        // Sending Packets

        public void SendHeartbeatPacket()
        {
            if (Tcp != null)
            {
                lock (SyncLock)
                {
                    if (HeartbeatSendable)
                    {
                        HeartbeatSendable = false;
                        SendPacket(0, 0, null, 0);
                    }
                }
            }
        }

        public void SendHelloPacket()
        {
            SendPacket(0, 3, null, 0);
        }

        public void SendReloadPacket()
        {
            SendPacket(0, 4, null, 0);
        }

        public void SendProcessPacket()
        {
            SendEmptyPacket(5);
        }

        public void SendReadMemPacket(UInt32 Address, UInt32 Size, UInt32 Pid)
        {
            SendEmptyPacket(9, Pid, Address, Size);
            LastReadMemorySequence = CurrentSequence;
        }


    }
}