function update

MySolution/STcpHelper/Packet/PacketType.cs

@@ -9,6 +9,7 @@ namespace STcpHelper.Packet
     public enum PacketType
     {
         TEXT = 0,
-
+        REQ_CLIENT_LIST,
+        RES_CLIENT_LIST,
     }
 }

MySolution/STcpHelper/Packet/SBufferHelper.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace STcpHelper.Packet
 {
-    static class SBufferHelper
+    internal class SBufferHelper
     {
         public static byte[] GetBuffer(int size, params byte[][] args)
         {

MySolution/STcpHelper/Packet/SEncoding.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace STcpHelper.Packet
+{
+    internal class SEncoding
+    {
+        public static string GetString(byte[] bytes, int index, int length)
+        {
+            return Encoding.UTF8.GetString(bytes, index, length);
+        }
+
+        public static byte[] GetBytes(string s)
+        {
+            return Encoding.UTF8.GetBytes(s);
+        }
+    }
+}

MySolution/STcpHelper/Packet/STcpClientListReqPacket.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace STcpHelper.Packet
+{
+    public class STcpClientListReqPacket : ISTcpPacket
+    {
+        public STcpClientListReqPacket()
+        {
+            
+        }
+
+        public byte[] Serialize()
+        {
+            // 4bytes header
+            STcpPacketHeader header = new STcpPacketHeader(PacketType.REQ_CLIENT_LIST, 0);
+
+            // [header]
+            return SBufferHelper.GetBuffer(4, header.Serialize());
+        }
+    }
+}

MySolution/STcpHelper/Packet/STcpClientListResPacket.cs

@@ -0,0 +1,51 @@
+using STcpHelper.Packet;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace STcpHelper.Packet
+{
+    public class STcpClientListResPacket : ISTcpPacket
+    {
+        public List<string> Clients { get; private set; }
+
+        public STcpClientListResPacket(List<TcpClient> clinets)
+        {
+            this.Clients = new List<string>();
+            foreach (var client in clinets)
+            {
+                this.Clients.Add(client.Client.RemoteEndPoint.ToString());
+            }
+        }
+
+        public STcpClientListResPacket(byte[] dataBuffer)
+        {
+            int cursor = 0;
+            short length = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(dataBuffer, cursor));
+            cursor += sizeof(short);
+
+            string jsonString = SEncoding.GetString(dataBuffer, cursor, length);
+            List<string> clients = JsonSerializer.Deserialize<List<string>>(jsonString);
+
+            this.Clients = clients;
+        }
+
+        public byte[] Serialize()
+        {
+            string jsonString = JsonSerializer.Serialize(this.Clients);
+            byte[] data = SEncoding.GetBytes(jsonString);
+            byte[] dataLength = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)data.Length));
+
+            // 4bytes header
+            STcpPacketHeader header = new STcpPacketHeader(PacketType.RES_CLIENT_LIST, dataLength.Length + data.Length);
+
+            // [header][2bytes size][n bytes string]
+            return SBufferHelper.GetBuffer(4 + dataLength.Length + data.Length, header.Serialize(), dataLength, data);
+        }
+    }
+}

MySolution/STcpHelper/Packet/STcpTextPacket.cs

@@ -19,22 +19,22 @@ namespace STcpHelper.Packet
         public STcpTextPacket(byte[] dataBuffer)
         {
             int cursor = 0;
-            short textSize = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(dataBuffer, cursor));
+            short length = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(dataBuffer, cursor));
             cursor += sizeof(short);
 
-            this.Text = Encoding.UTF8.GetString(dataBuffer, cursor, textSize);
+            this.Text = SEncoding.GetString(dataBuffer, cursor, length);
         }
 
         public byte[] Serialize()
         {
-            byte[] text = Encoding.UTF8.GetBytes(Text);
+            byte[] data = SEncoding.GetBytes(Text);
-            byte[] textSize = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)text.Length));
+            byte[] dataLength = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)data.Length));
 
-            // 4byte header
+            // 4bytes header
-            STcpPacketHeader header = new STcpPacketHeader(PacketType.TEXT, text.Length + textSize.Length);
+            STcpPacketHeader header = new STcpPacketHeader(PacketType.TEXT, dataLength.Length + data.Length);
 
-            // [2bytes text size][n bytes text]
+            // [header][2bytes text size][n bytes text]
-            return SBufferHelper.GetBuffer(4 + textSize.Length + text.Length, header.Serialize(), textSize, text);
+            return SBufferHelper.GetBuffer(4 + dataLength.Length + data.Length, header.Serialize(), dataLength, data);
         }
     }
 }

MySolution/STcpHelper/Packet/SXmlSerializerHelper.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Serialization;
+
+namespace STcpHelper.Packet
+{
+    static class SXmlSerializerHelper
+    {
+        public static string Serialize<T>(T obj)
+        {
+            XmlSerializer serializer = new XmlSerializer(typeof(T));
+            using (StringWriter sw = new StringWriter())
+            {
+                serializer.Serialize(sw, obj);
+                return sw.ToString();
+            }
+        }
+
+        public static T Deserialize<T>(string str)
+        {
+            XmlSerializer serializer = new XmlSerializer(typeof(T));
+            using (StringReader sr = new StringReader(str))
+            {
+                return (T)serializer.Deserialize(sr);
+            }
+        }
+    }
+}

MySolution/STcpHelper/STcpClient.cs

@@ -62,6 +62,14 @@ namespace STcpHelper
                             STcpTextPacket packet = new STcpTextPacket(dataBuffer);
                             WriteMessage(packet.Text);
                         }
+                        else if (header.Type == PacketType.RES_CLIENT_LIST)
+                        {
+                            STcpClientListResPacket packet = new STcpClientListResPacket(dataBuffer);
+                            foreach (var client in packet.Clients)
+                            {
+                                WriteMessage(client);
+                            }
+                        }
                     }
                 }, _cts.Token);
             }
@@ -90,6 +98,19 @@ namespace STcpHelper
             }
         }
 
+        public async void RequireClientList()
+        {
+            try
+            {
+                STcpClientListReqPacket packet = new STcpClientListReqPacket();
+                await _stream.WriteAsync(packet.Serialize());
+            }
+            catch (Exception ex)
+            {
+                WriteError(ex);
+            }
+        }
+
         public void Close()
         {
             try

MySolution/STcpHelper/STcpServer.cs

@@ -80,6 +80,14 @@ namespace STcpHelper
                                     BroadcastMessage(packet.Text, client);
 
                                 }
+                                else if (header.Type == PacketType.REQ_CLIENT_LIST)
+                                {
+                                    STcpClientListResPacket packet = new STcpClientListResPacket(_clients);
+                                    WriteMessage($"[{client.Client.RemoteEndPoint.ToString()}] Type: {header.Type.ToString()}");
+
+                                    // Send
+                                    SendPacket(packet, client);
+                                }
 
                                 if (!IsClientConnected(client))
                                     break;
@@ -109,6 +117,15 @@ namespace STcpHelper
             return packet.Serialize();
         }
 
+        private void SendPacket(ISTcpPacket packet, TcpClient requester)
+        {
+            byte[] responseByte = packet.Serialize();
+            if (!IsClientConnected(requester))
+                return;
+
+            requester.GetStream().WriteAsync(responseByte, 0, responseByte.Length);
+        }
+
         private void BroadcastMessage(string message, TcpClient sender)
         {
             byte[] resonseByte = MakeTextPacket(message);

MySolution/TAPClient/Program.cs

@@ -13,8 +13,17 @@ namespace TAPClient
 
             while (true)
             {
-                string message = Console.ReadLine();
+                string input = Console.ReadLine();
-                client.SendMessage(message);
+                switch (input.ToLower())
+                {
+                    case "rcl":
+                        client.RequireClientList();
+                        break;
+                    default:
+                        client.SendMessage(input);
+                        break;
+                }
+
             }
         }
     }