DirectoryScanReceiver/DirectoryScanReceiver/Program.cs

using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;

namespace DirectoryScanReceiver;

struct Data
{
    public string Name;
    public int Length;
    public string Content;

    public override string ToString() => $"Name: {Name}\nLength: {Length}";
}

static class DataExtractor
{
    public static Data Data;

    public static void LoadAndParseData(string data)
    {
        Data = new Data();
        if (data.Length == 0) return;

        var s = data.Split('|').ToList();
        if(s.Count < 3) return;

        Data.Name = s[0];

        try { Data.Length = int.Parse(s[1]); }
        catch (Exception ex) { Console.WriteLine(ex.Message); }

        var sb = new StringBuilder();
        foreach (var sub in s[2..]) sb.Append(sub);
        var content = sb.ToString();

        var length = Math.Min(content.Length, Data.Length);
        Data.Content = content[..length];
    }
}

static class DataHandler
{
    public const string OutputDir = "./output";

    public static void Parse(string data)
    {
        if (data.Length == 0) return;

        DataExtractor.LoadAndParseData(data);
        var parsed = DataExtractor.Data;
        Console.WriteLine(parsed);

        if (parsed.Name.Length == 0 || parsed.Length == 0 || parsed.Content.Length == 0) return;

        var newPath = Path.Combine(OutputDir, parsed.Name);
        var fi = new FileInfo(newPath);
        var dir = Path.GetDirectoryName(newPath) ?? OutputDir;
        var di = new DirectoryInfo(dir);

        if (!di.Exists) di.Create();
        if (fi.Exists) return;

        Console.WriteLine($"Writing File: {newPath}");
        fi.Create().Write(Encoding.UTF8.GetBytes(parsed.Content));
    }
}

internal class Server
{
    private readonly TcpListener _listener;

    public Server(int port)
    {
        _listener = new TcpListener(IPAddress.Parse("127.0.0.1"), port);
        _listener.Start();
    }

    public static TcpState GetState(TcpClient tcpClient)
    {
        var foo = IPGlobalProperties.GetIPGlobalProperties()
            .GetActiveTcpConnections()
            .SingleOrDefault(x => x.LocalEndPoint.Equals(tcpClient.Client.LocalEndPoint));
        return foo is not null ? foo.State : TcpState.Unknown;
    }


    public void Receiver()
    {
        if(Directory.Exists(DataHandler.OutputDir)) Directory.Delete(DataHandler.OutputDir, true);

        while (true)
        {
            if(!_listener.Pending()) continue;

            var peer = _listener.AcceptTcpClient();
            var stream = peer.GetStream();

            Console.WriteLine($"Connected to Peer: {peer.Client.RemoteEndPoint}");
            while (GetState(peer) == TcpState.Established)
            {
                var buffer = "";

                try
                {
                    var start = DateTime.Now;
                    while (!buffer.EndsWith("\r\n\r\n"))
                    {
                        if (DateTime.Now.Subtract(start).TotalMilliseconds >= 10000)
                        {
                            Console.WriteLine("Receive Timeout!");
                            break;
                        }

                        var availableBytes = peer.Available;
                        while (availableBytes > 0)
                        {
                            var recvBytes = new byte[availableBytes];
                            var recvCount = stream.Read(recvBytes);
                            if(recvCount <= 0) continue;

                            // TODO: for is to heavy
                            for (var i = 0; i < recvCount; i++) buffer += (char)recvBytes[i];
                            availableBytes -= recvCount;
                        }
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.Message); }

                if(buffer.Length == 0) continue;

                foreach (var b in buffer.Split("\r\n\r\n"))
                {
                    Console.WriteLine($"Received {b.Length} bytes");
                    DataHandler.Parse(b);
                }
            }
            Console.WriteLine("Disconnected from Peer!");
        }
    }
}

public static class Program
{
    public static void Main()
    {
        var server = new Server(7156);
        Console.WriteLine("Started Server!");
        while (true)
        {
            Console.WriteLine("Waiting for data!");
            try
            {
                server.Receiver();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Receiver crashed!");
                Console.WriteLine(ex.Message);
            }
        }
    }
}