WIP DHCP

NetBootServerCore/Components/Http/BootScriptProcessor.cs

@@ -12,7 +12,7 @@ namespace NetBootServerCore.Components.Http
             _bootScriptProvider = bootScriptProvider;
         }
 
-        public bool ProcessRequest(HttpContext request)
+        public async Task<bool> ProcessRequest(HttpContext request)
         {
             return false;
         }

NetBootServerCore/Components/Http/HttpServer.cs

@@ -23,7 +23,7 @@ namespace NetBootServerCore.Components.Http
             {
                 context.Response.Headers.Server = nameof(NetBootServerCore);
 
-                if (_processors.Any(processor => processor.ProcessRequest(context))) return;
+                foreach (var processor in _processors) if (await processor.ProcessRequest(context)) return;
 
                 context.Response.StatusCode = 404;
                 Logger.LogWarn($"404 {context.Request.GetEncodedPathAndQuery()}");

NetBootServerCore/Components/Http/IHttpRequestProcessor.cs

@@ -2,5 +2,5 @@
 
 public interface IHttpRequestProcessor
 {
-    bool ProcessRequest(HttpContext request);
+    Task<bool> ProcessRequest(HttpContext request);
 }

NetBootServerCore/Components/Http/StaticContent/StaticContentProcessor.cs

@@ -9,7 +9,7 @@ namespace NetBootServerCore.Components.Http.StaticContent
             //TODO: Load Content Package
         }
 
-        public bool ProcessRequest(HttpContext request)
+        public async Task<bool> ProcessRequest(HttpContext request)
         {
             return false;
         }

NetBootServerCore/Components/Http/WebApi/WebApiProcessor.cs

@@ -1,17 +1,23 @@
 using NetBootServerCore.Components.Logging;
 using NetBootServerCore.Components.NetBoot;
+using NetBootServerCore.Components.NetBoot.Dhcp;
 
 namespace NetBootServerCore.Components.Http.WebApi
 {
     public class WebApiProcessor : NbsComponentBase, IHttpRequestProcessor
     {
+        private readonly DhcpServer _dhcp;
+
         public WebApiProcessor(DhcpServer dhcp) : base(new Logger("HTTP.WebApi"))
         {
+            _dhcp = dhcp;
         }
 
-        public bool ProcessRequest(HttpContext request)
+        public async Task<bool> ProcessRequest(HttpContext request)
         {
+            
             //TODO: Show DHCP Pool entries
+            //TODO: Log Notify (WebSocket?)
             return false;
         }
     }

NetBootServerCore/Components/Logging/LogEntry.cs

@@ -2,8 +2,19 @@
 {
     public class LogEntry
     {
+        private static int _logSeed;
+        public int Id { get; } = Interlocked.Increment(ref _logSeed);
+
+        public LogEntry(LogLevel level, string message, string details)
+        {
+            Level = level;
+            Message = message;
+            Details = details;
+        }
+
         public DateTime Time { get; } = DateTime.Now;
-        public LogLevel Level { get; set; }
-        public string Message { get; set; }
+        public LogLevel Level { get; }
+        public string Message { get; }
+        public string Details { get; }
     }
 }

NetBootServerCore/Components/Logging/LogPool.cs

@@ -1,11 +1,11 @@
-using NetBootServerCore.LivingConsole;
-
-namespace NetBootServerCore.Components.Logging
+namespace NetBootServerCore.Components.Logging
 {
     public static class LogPool
     {
         //TODO: Data Logs
 
+        public static event Action LogChanged;
+
         public static int RequestsHandled = 0;
         public static int InBytes = 0;
         public static int OutBytes = 0;
@@ -17,7 +17,7 @@ namespace NetBootServerCore.Components.Logging
             lock (_logs)
             {
                 _logs.Add(entry);
-                LiveConsole.Refresh();
+                LogChanged?.Invoke();
             }
         }
 
@@ -26,7 +26,7 @@ namespace NetBootServerCore.Components.Logging
             lock (_logs)
             {
                 _logs.Clear();
-                LiveConsole.Refresh();
+                LogChanged?.Invoke();
             }
         }
 
@@ -47,5 +47,10 @@ namespace NetBootServerCore.Components.Logging
                 lock (_logs) return _logs.Count;
             }
         }
+
+        public static LogEntry GetEntryById(int id)
+        {
+            lock (_logs) return _logs.FirstOrDefault(p => p.Id == id);
+        }
     }
 }

NetBootServerCore/Components/Logging/Logger.cs

@@ -6,16 +6,16 @@
 
         public Logger(string tag) => Tag = tag;
 
-        public void LogDebug(string message) => LogPool.Append(new LogEntry { Level = LogLevel.Debug, Message = $"[{Tag}] {message}" });
+        public void LogDebug(string message, string details = null) => LogPool.Append(new LogEntry(LogLevel.Debug, message, details));
 
-        public void LogVerbose(string message) => LogPool.Append(new LogEntry { Level = LogLevel.Verbose, Message = $"[{Tag}] {message}" });
+        public void LogVerbose(string message, string details = null) => LogPool.Append(new LogEntry(LogLevel.Verbose, message, details));
 
-        public void LogInfo(string message) => LogPool.Append(new LogEntry { Level = LogLevel.Info, Message = $"[{Tag}] {message}" });
+        public void LogInfo(string message, string details = null) => LogPool.Append(new LogEntry(LogLevel.Info, message, details));
 
-        public void LogWarn(string message) => LogPool.Append(new LogEntry { Level = LogLevel.Warn, Message = $"[{Tag}] {message}" });
+        public void LogWarn(string message, string details = null) => LogPool.Append(new LogEntry(LogLevel.Warn, message, details));
 
-        public void LogError(string message) => LogPool.Append(new LogEntry { Level = LogLevel.Error, Message = $"[{Tag}] {message}" });
+        public void LogError(string message, string details = null) => LogPool.Append(new LogEntry(LogLevel.Error, message, details));
 
-        public void LogFatal(string message) => LogPool.Append(new LogEntry { Level = LogLevel.Fatal, Message = $"[{Tag}] {message}" });
+        public void LogFatal(string message, string details = null) => LogPool.Append(new LogEntry(LogLevel.Fatal, message, details));
     }
 }

NetBootServerCore/Components/NetBoot/BootScriptProvider.cs

@@ -4,7 +4,7 @@ namespace NetBootServerCore.Components.NetBoot
 {
     public class BootScriptProvider : NbsComponentBase
     {
-        public BootScriptProvider() : base(new Logger("BSP"))
+        public BootScriptProvider(IConfigurationSection configurationSection) : base(new Logger("BSP"))
         {
         }
     }

NetBootServerCore/Components/NetBoot/Dhcp/AddressPool.cs

@@ -0,0 +1,7 @@
+namespace NetBootServerCore.Components.NetBoot.Dhcp;
+
+public class AddressPool
+{
+    public IReadOnlyCollection<AddressPoolSlot> Slots { get; }
+
+}

NetBootServerCore/Components/NetBoot/Dhcp/AddressPoolSlot.cs

@@ -0,0 +1,12 @@
+using System.Diagnostics;
+using System.Net;
+
+namespace NetBootServerCore.Components.NetBoot.Dhcp;
+
+[DebuggerDisplay("{" + nameof(Address) + "}")]
+public class AddressPoolSlot
+{
+    public IPAddress Address { get; }
+
+    public AddressPoolSlot(IPAddress address) => Address = address;
+}

NetBootServerCore/Components/NetBoot/Dhcp/DhcpServer.cs

@@ -0,0 +1,56 @@
+using Microsoft.AspNetCore.Components.Routing;
+using NetBootServerCore.Components.Logging;
+using SharpPcap.LibPcap;
+using System.Net;
+
+namespace NetBootServerCore.Components.NetBoot.Dhcp
+{
+    public class DhcpServer : NbsComponentBase
+    {
+        private const int Port = 67;
+
+        private readonly IPEndPoint _listenOn;
+
+        private readonly IPAddress _poolStart;
+        private readonly int _poolSize;
+
+        private readonly IPAddress _subNet;
+        private readonly IPAddress _gateway;
+        private readonly IPAddress _dns;
+
+        private readonly IPAddress _broadcastAddress;
+
+        private readonly IPAddress _tftp;
+        private readonly string _fileName;
+        private readonly string _fileNameForiPxe;
+
+        public DhcpServer(IConfigurationSection config) : base(new Logger("DHCP"))
+        {
+            _listenOn = new IPEndPoint(IPAddress.Parse(config["ListenOn"]), 67);
+
+            _poolStart = IPAddress.Parse(config["PoolStart"]);
+            _poolSize =int.Parse(config["PoolSize"]);
+
+            _subNet = IPAddress.Parse(config["SubNet"]);
+            _gateway = IPAddress.Parse(config["Gateway"]);
+            _dns = IPAddress.Parse(config["Dns"]);
+
+            _broadcastAddress= IPAddress.Parse(config["BroadcastAddress"]);
+
+            _tftp=IPAddress.Parse(config["Tftp"]);
+            _fileName = config["FileName"];
+            _fileNameForiPxe = config["FileName_iPXE"];
+        }
+
+        private static LibPcapLiveDevice _nic;
+
+        protected override void OnStart()
+        {
+            _nic = LibPcapLiveDeviceList.Instance.FirstOrDefault(p => p.Addresses.Any(q => Equals(q.Addr.ipAddress, _listenOn.Address)));
+        }
+
+        protected override void OnStop()
+        {
+        }
+    }
+}

NetBootServerCore/Components/NetBoot/Dhcp/Protocol/DhcpPdu.cs

@@ -0,0 +1,117 @@
+using Microsoft.Extensions.Options;
+using System.Net;
+using System.Text;
+using static NetBootServerCore.Components.NetBoot.Dhcp.Protocol.Enums;
+
+namespace NetBootServerCore.Components.NetBoot.Dhcp.Protocol
+{
+    public class DhcpPdu
+    {
+        public DhcpOpCode OpCode { get; set; }
+        public DhcpHardwareType HardwareType { get; set; }
+        public byte Hops { get; set; }
+        public int TransactionId { get; set; }
+
+        public short SecondsElapsed { get; set; }
+
+        public DhcpBootpFlag BootpFlags { get; set; }
+        public IPAddress ClientIpAddress { get; set; }
+
+        public IPAddress YourIpAddress { get; set; }
+
+        public IPAddress NextServerIpAddress { get; set; }
+
+        public IPAddress RelayAgentIpAddress { get; set; }
+
+        public byte[] ClientMacAddress { get; set; }
+
+        public string ServerHostName { get; set; }
+        public string BootFileName { get; set; }
+
+        public int MagicCookie { get; set; } = 0x63825363;
+        public Dictionary<DhcpOption, byte[]> Options { get; set; } = new Dictionary<DhcpOption, byte[]>();
+
+        public DhcpMessageType MessageType
+        {
+            get => Options.MapValue(DhcpOption.DhcpMessageType, value => (DhcpMessageType)value[0]);
+
+            set => Options[DhcpOption.DhcpMessageType] = new[] { (byte)value };
+        }
+
+        public IPAddress SubNetMask
+        {
+            get => Options.MapValue(DhcpOption.SubNetMask, value => new IPAddress(value));
+            set => Options[DhcpOption.SubNetMask] = value.GetAddressBytes();
+        }
+
+        public IPAddress Router
+        {
+            get => Options.MapValue(DhcpOption.Router, value => new IPAddress(value));
+            set => Options[DhcpOption.Router] = value.GetAddressBytes();
+        }
+
+        public IPAddress DnsServer
+        {
+            get => Options.MapValue(DhcpOption.DnsServer, value => new IPAddress(value));
+            set => Options[DhcpOption.DnsServer] = value.GetAddressBytes();
+        }
+
+        public string TftpServer
+        {
+            get => Options.MapValue(DhcpOption.TftpServer, value => Encoding.ASCII.GetString(value));
+            set => Options[DhcpOption.TftpServer] = Encoding.ASCII.GetBytes(value);
+        }
+
+        public IPAddress BroadcastAddress
+        {
+            get => Options.MapValue(DhcpOption.BroadcastAddress, value => new IPAddress(value));
+            set => Options[DhcpOption.BroadcastAddress] = value.GetAddressBytes();
+        }
+
+        public IPAddress ServerIdentifier
+        {
+            get => Options.MapValue(DhcpOption.ServerIdentifier, value => new IPAddress(value));
+            set => Options[DhcpOption.ServerIdentifier] = value.GetAddressBytes();
+        }
+
+        public IPAddress DhcpServerIdentifier
+        {
+            get => Options.MapValue(DhcpOption.DhcpServerIdentifier, value => new IPAddress(value));
+            set => Options[DhcpOption.DhcpServerIdentifier] = value.GetAddressBytes();
+        }
+
+        public string UserClass
+        {
+            get => Options.MapValue(DhcpOption.UserClass, value => Encoding.ASCII.GetString(value))?.Trim().Trim('\0');
+            set => Options[DhcpOption.UserClass] = Encoding.ASCII.GetBytes(value);
+        }
+
+        public string HostName => Options.MapValue(DhcpOption.HostName, v => Encoding.ASCII.GetString(v))?.Trim().Trim('\0');
+        public string Vendor => Options.MapValue(DhcpOption.Vendor, v => Encoding.ASCII.GetString(v))?.Trim().Trim('\0');
+
+        public TimeSpan LeaseTime
+        {
+            get => Options.MapValue(DhcpOption.LeaseTime, p => TimeSpan.FromSeconds(p.ToBeUint()));
+            set => Options[DhcpOption.LeaseTime] = ((uint)value.TotalSeconds).ToBytes();
+        }
+
+        public TimeSpan RenewalTime
+        {
+            get => Options.MapValue(DhcpOption.RenewalTime, p => TimeSpan.FromSeconds(p.ToBeUint()));
+            set => Options[DhcpOption.RenewalTime] = ((uint)value.TotalSeconds).ToBytes();
+        }
+
+        public TimeSpan RebindingTime
+        {
+            get => Options.MapValue(DhcpOption.RebindingTime, p => TimeSpan.FromSeconds(p.ToBeUint()));
+            set => Options[DhcpOption.RebindingTime] = ((uint)value.TotalSeconds).ToBytes();
+        }
+
+        public byte[] ClientIdentifier
+        {
+            get => Options.MapValue(DhcpOption.ClientIdentifier, p => p);
+            set => Options[DhcpOption.ClientIdentifier] = value;
+        }
+
+    }
+}

NetBootServerCore/Components/NetBoot/Dhcp/Protocol/Enums.cs

@@ -0,0 +1,60 @@
+namespace NetBootServerCore.Components.NetBoot.Dhcp.Protocol;
+
+public static class Enums
+{
+    public enum DhcpHardwareType
+    {
+        Unknown = 0,
+        Ethernet = 1,
+    }
+
+    public enum DhcpOpCode
+    {
+        Unknown = 0,
+        BootRequest = 1,
+        BootReply = 2,
+    }
+
+    public enum DhcpOption : byte
+    {
+        SubNetMask = 1, // 4b ip address
+        Router = 3, // 4b ip address
+        DnsServer = 6, // 4b ip address
+        HostName = 12, // var ascii
+        BroadcastAddress = 28, // 4b ip address
+        DhcpMessageType = 53,  // 1b enum
+        RequestedIpAddress = 50, // 4b ip address
+        LeaseTime = 51, // 4b seconds BE
+        ParameterRequestList = 55, // var byte array
+        ServerIdentifier = 54, // 4b ip address
+        RenewalTime = 58, // 4b seconds BE
+        RebindingTime = 59, // 4b seconds BE
+        DhcpServerIdentifier = 54, // 4b ip address
+        Vendor = 60, // var ascii
+        ClientIdentifier = 61, // var MAC
+        TftpServer = 66, // 4b ip address
+        UserClass = 77, // var ascii
+        ClientArchitecture = 93, // RFC 4578
+        End = 255,
+    }
+
+    public enum DhcpMessageType : byte
+    {
+        Unknown = 0,
+        Discover = 1,
+        Offer = 2,
+        Request = 3,
+        Decline = 4,
+        Ack = 5,
+        Nak = 6,
+        Release = 7,
+        Conform = 8
+    }
+
+    [Flags]
+    public enum DhcpBootpFlag : ushort
+    {
+        Broadcast = 1 << 15
+    }
+}
+

NetBootServerCore/Components/NetBoot/Dhcp/Protocol/ExtensionMethods.cs

@@ -0,0 +1,46 @@
+using System.Text;
+
+namespace NetBootServerCore.Components.NetBoot.Dhcp.Protocol;
+
+public static class ExtensionMethods
+{
+    public static TR MapValue<TK, TV, TR>(this Dictionary<TK, TV> dic, TK key, Func<TV, TR> found)
+    {
+        return dic.TryGetValue(key, out var value)
+            ? found(value)
+            : default;
+    }
+
+    public static TR MapValue<TK, TV, TR>(this Dictionary<TK, TV> dic, TK key, Func<TV, TR> found, Func<TR> notFound)
+    {
+        return dic.TryGetValue(key, out var value)
+            ? found(value)
+            : notFound();
+    }
+
+    public static void FilterChars(this StringBuilder sb, HashSet<char> chars, char replace = '_')
+    {
+        for (var i = 0; i < sb.Length; i++)
+        {
+            if (chars.Contains(sb[i])) sb[i] = replace;
+        }
+    }
+
+    public static uint ToBeUint(this byte[] buf)
+    {
+        return (uint)buf[0] << 24 |
+               (uint)buf[1] << 16 |
+               (uint)buf[2] << 8 |
+               (uint)buf[3];
+    }
+
+    public static byte[] ToBytes(this uint value)
+    {
+        var buf = new byte[4];
+        buf[0] = (byte)(value >> 24);
+        buf[1] = (byte)(value >> 16);
+        buf[2] = (byte)(value >> 8);
+        buf[3] = (byte)(value);
+        return buf;
+    }
+}

NetBootServerCore/Components/NetBoot/DhcpServer.cs

@@ -1,16 +0,0 @@
-using NetBootServerCore.Components.Logging;
-
-namespace NetBootServerCore.Components.NetBoot
-{
-    public class DhcpServer : NbsComponentBase
-    {
-        public DhcpServer() : base(new Logger("DHCP"))
-        {
-        }
-
-        protected override void OnStart()
-        {
-            base.OnStart();
-        }
-    }
-}

NetBootServerCore/Components/NetBoot/TftpServer.cs

@@ -4,7 +4,7 @@ namespace NetBootServerCore.Components.NetBoot
 {
     public class TftpServer : NbsComponentBase
     {
-        public TftpServer() : base(new Logger("TFTP"))
+        public TftpServer(IConfigurationSection configurationSection) : base(new Logger("TFTP"))
         {
 
 

NetBootServerCore/LivingConsole/LiveConsole.cs

@@ -13,11 +13,13 @@ namespace NetBootServerCore.LivingConsole
         public static void Start()
         {
             _isRunning = true;
+            LogPool.LogChanged += Refresh;
             _task = Task.Run(RunInternal);
         }
 
         public static void Stop()
         {
+            LogPool.LogChanged -= Refresh;
             Refresh();
             _isRunning = false;
             _task.Wait(10000);
@@ -46,9 +48,6 @@ namespace NetBootServerCore.LivingConsole
                 tableMain.AddRow(new Panel("Logs Brrr"));
             }
 
-            //init content
-            ct2RequestHandled.Header = new Text($"Reqs: {LogPool.RequestsHandled} In: {LogPool.InBytes} Out: {LogPool.OutBytes}");
-
             do
             {
                 Console.Clear();
@@ -63,6 +62,7 @@ namespace NetBootServerCore.LivingConsole
                         {
                             var now = DateTime.Now;
                             var up = now - NbsProgram.LaunchTime;
+                            ct2RequestHandled.Header = new Text($"Reqs: {LogPool.RequestsHandled} In: {LogPool.InBytes} Out: {LogPool.OutBytes}");
                             ct1UpTime.Header = new Text($"UP: {(int)up.TotalDays:00}D {up.Hours:00}H {up.Minutes:00}M {up.Seconds:00}S {up.Milliseconds:000}");
                             if (LogPool.Count != 0 && Console.WindowHeight > 4) tableMain.UpdateCell(0, 0, new Rows(LogPool.TakeLast(conH - 4).Select(p => LogMarkup.Create(p, conW))));
                             ctx.Refresh();

NetBootServerCore/NetBootServerCore.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="SharpPcap" Version="6.2.5" />
     <PackageReference Include="Spectre.Console" Version="0.46.1-preview.0.4" />
   </ItemGroup>
 

NetBootServerCore/Program.cs

@@ -3,6 +3,7 @@ using NetBootServerCore.Components.Http.StaticContent;
 using NetBootServerCore.Components.Http.WebApi;
 using NetBootServerCore.Components.Logging;
 using NetBootServerCore.Components.NetBoot;
+using NetBootServerCore.Components.NetBoot.Dhcp;
 using NetBootServerCore.LivingConsole;
 
 namespace NetBootServerCore;
@@ -30,74 +31,79 @@ public static class NbsProgram
         logger.LogWarn("Logger Init");
         logger.LogError("Logger Init");
         logger.LogFatal("Logger Init");
-
-        logger.LogInfo("Load config");
-        var config = WebApplication.CreateBuilder(args).Configuration;
-        var httpPrefix = config.GetSection("Web")["Prefix"];
-        Console.Title = $"{nameof(NetBootServerCore)} at {httpPrefix}";
-        Environment.SetEnvironmentVariable("ASPNETCORE_URLS", httpPrefix);
-
-        logger.LogInfo("Create components");
-        var dhcp = new DhcpServer();
-        var tftp = new TftpServer();
-        var bsp = new BootScriptProvider();
-
-        var scriptServer = new BootScriptProcessor(bsp);
-        var apiServer = new WebApiProcessor(dhcp);
-        var staticServer = new StaticContentProcessor();
-        var httpServer = new HttpServer(new IHttpRequestProcessor[] { scriptServer, apiServer, staticServer });
-
-        logger.LogInfo("Start components");
-        dhcp.Start();
-        tftp.Start();
-        scriptServer.Start();
-        apiServer.Start();
-        staticServer.Start();
-        httpServer.Start();
-
-        logger.LogInfo("Running");
-
-        //Waiting until Control-C
+        try
         {
-            CancellationTokenSource ctSource = new();
-            var ct = ctSource.Token;
-
-            void ExitHandler()
+            logger.LogInfo("Load config");
+            var config = WebApplication.CreateBuilder(args).Configuration;
+            var httpPrefix = config.GetSection("Web")["Prefix"];
+            Console.Title = $"{nameof(NetBootServerCore)} at {httpPrefix}";
+            Environment.SetEnvironmentVariable("ASPNETCORE_URLS", httpPrefix);
+
+            logger.LogInfo("Create components");
+            var dhcp = new DhcpServer(config.GetSection("DHCP"));
+            var tftp = new TftpServer(config.GetSection("TFTP"));
+            var bsp = new BootScriptProvider(config.GetSection("BootScript"));
+
+            var scriptServer = new BootScriptProcessor(bsp);
+            var apiServer = new WebApiProcessor(dhcp);
+            var staticServer = new StaticContentProcessor();
+            var httpServer = new HttpServer(new IHttpRequestProcessor[] { scriptServer, apiServer, staticServer });
+
+            logger.LogInfo("Start components");
+            dhcp.Start();
+            tftp.Start();
+            scriptServer.Start();
+            apiServer.Start();
+            staticServer.Start();
+            httpServer.Start();
+
+            logger.LogInfo("Running");
+
+            //Waiting until Control-C
             {
-                // You can add any arbitrary global clean up
-                logger.LogInfo("Exiting...");
-                ctSource.Cancel();
-            }
+                CancellationTokenSource ctSource = new();
+                var ct = ctSource.Token;
 
-            // Assign exit handler to be called when the process is terminated
-            // or the user hits CTRL+C
-            AppDomain.CurrentDomain.ProcessExit += (_, _) => ExitHandler();
-            Console.CancelKeyPress += (_, _) => ExitHandler();
-
-            // Then you can use the cancellation token to check for exit:
-            while (!ct.IsCancellationRequested)
-            {
-                try
+                void ExitHandler()
                 {
-                    Task.Delay(1000, ct).Wait(ct);
+                    // You can add any arbitrary global clean up
+                    logger.LogInfo("Exiting...");
+                    ctSource.Cancel();
                 }
-                catch (OperationCanceledException e)
+
+                // Assign exit handler to be called when the process is terminated
+                // or the user hits CTRL+C
+                AppDomain.CurrentDomain.ProcessExit += (_, _) => ExitHandler();
+                Console.CancelKeyPress += (_, _) => ExitHandler();
+
+                // Then you can use the cancellation token to check for exit:
+                while (!ct.IsCancellationRequested)
                 {
-                    break;
+                    try
+                    {
+                        Task.Delay(1000, ct).Wait(ct);
+                    }
+                    catch (OperationCanceledException e)
+                    {
+                        break;
+                    }
                 }
             }
-        }
-
-        //stop components
-        dhcp.Stop();
-        tftp.Stop();
-        apiServer.Stop();
-        scriptServer.Stop();
-        staticServer.Stop();
-        httpServer.Stop();
 
-        logger.LogInfo("Finished");
+            //stop components
+            dhcp.Stop();
+            tftp.Stop();
+            apiServer.Stop();
+            scriptServer.Stop();
+            staticServer.Stop();
+            httpServer.Stop();
 
+            logger.LogInfo("Finished");
+        }
+        catch (Exception ex)
+        {
+            logger.LogFatal(ex.Message, ex.ToString());
+        }
         LiveConsole.Stop();
     }
 }

NetBootServerCore/appsettings.json

@@ -7,14 +7,10 @@
   },
   "AllowedHosts": "*",
   "Web": {
-    "Prefix": "http://0.0.0.0:6880",
-    "BootScriptDir": "BootScripts"
-  },
-  "TFTP": {
-    "RootDir": "TftpRoot"
+    "Prefix": "http://0.0.0.0:6780"
   },
   "DHCP": {
-    "ListenOn": "0.0.0.0",
+    "ListenOn": "192.168.233.31",
     "PoolStart": "192.168.233.154",
     "PoolSize": 100,
     "SubNet": "255.255.255.0",
@@ -22,7 +18,14 @@
     "DNS": "192.168.233.53",
     "BroadcastAddress": "192.168.233.255",
     "Tftp": "192.168.233.133",
-    "BootFileName": "undionly.kpxe",
-    "BootFileName_iPXE": "http://192.168.233.133:6800/boot/ipxe"
+    "FileName": "undionly.kpxe",
+    "FileName_iPXE": "http://192.168.233.133:6800/boot/ipxe"
+  },
+  "TFTP": {
+    "ListenOn": "0.0.0.0",
+    "RootDir": "TftpRoot"
+  },
+  "BootScript": {
+    "ScriptDir": "BootScript"
   }
 }