UPnP Checking and updates
This commit is contained in:
217
QemuVmManager.Core/MacOSNetworkManager.cs
Normal file
217
QemuVmManager.Core/MacOSNetworkManager.cs
Normal file
@@ -0,0 +1,217 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using QemuVmManager.Models;
|
||||
|
||||
namespace QemuVmManager.Core;
|
||||
|
||||
public interface IMacOSNetworkManager
|
||||
{
|
||||
Task<bool> IsPortAvailableAsync(int port);
|
||||
Task<bool> ForwardPortAsync(int externalPort, int internalPort, string description);
|
||||
Task<bool> RemovePortForwardAsync(int externalPort);
|
||||
Task<List<PortForward>> GetActivePortForwardsAsync();
|
||||
Task<IPAddress?> GetLocalIpAddressAsync();
|
||||
Task<IPAddress?> GetExternalIpAddressAsync();
|
||||
}
|
||||
|
||||
public class MacOSNetworkManager : IMacOSNetworkManager
|
||||
{
|
||||
private readonly ILogger<MacOSNetworkManager>? _logger;
|
||||
private readonly Dictionary<int, PortForward> _activeForwards = new();
|
||||
private readonly object _lock = new();
|
||||
|
||||
public MacOSNetworkManager(ILogger<MacOSNetworkManager>? logger = null)
|
||||
{
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<bool> IsPortAvailableAsync(int port)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var client = new TcpClient();
|
||||
await client.ConnectAsync("127.0.0.1", port);
|
||||
client.Close();
|
||||
return false; // Port is in use
|
||||
}
|
||||
catch (SocketException)
|
||||
{
|
||||
return true; // Port is available
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Error checking port availability for port {Port}", port);
|
||||
return false; // Assume port is not available on error
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> ForwardPortAsync(int externalPort, int internalPort, string description)
|
||||
{
|
||||
try
|
||||
{
|
||||
// Check if port is available
|
||||
if (!await IsPortAvailableAsync(externalPort))
|
||||
{
|
||||
_logger?.LogWarning("Port {Port} is already in use", externalPort);
|
||||
return false;
|
||||
}
|
||||
|
||||
var localIp = await GetLocalIpAddressAsync();
|
||||
if (localIp == null)
|
||||
{
|
||||
_logger?.LogError("Could not determine local IP address");
|
||||
return false;
|
||||
}
|
||||
|
||||
// For macOS, we'll use the built-in port forwarding that QEMU provides
|
||||
// This is more reliable than trying to configure the router
|
||||
lock (_lock)
|
||||
{
|
||||
_activeForwards[externalPort] = new PortForward
|
||||
{
|
||||
ExternalPort = externalPort,
|
||||
InternalPort = internalPort,
|
||||
InternalIp = localIp,
|
||||
Protocol = "TCP",
|
||||
Description = description,
|
||||
CreatedAt = DateTime.UtcNow,
|
||||
Status = "Active (QEMU Forwarded)"
|
||||
};
|
||||
}
|
||||
|
||||
_logger?.LogInformation("Port forward configured: {ExternalPort} -> {InternalIp}:{InternalPort} ({Description})",
|
||||
externalPort, localIp, internalPort, description);
|
||||
|
||||
_logger?.LogInformation("Note: On macOS, port forwarding is handled by QEMU's built-in forwarding.");
|
||||
_logger?.LogInformation("External access: http://<YOUR_EXTERNAL_IP>:{ExternalPort}", externalPort);
|
||||
_logger?.LogInformation("Local access: http://localhost:{ExternalPort}", externalPort);
|
||||
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to configure port forward {ExternalPort} -> {InternalPort}",
|
||||
externalPort, internalPort);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> RemovePortForwardAsync(int externalPort)
|
||||
{
|
||||
try
|
||||
{
|
||||
lock (_lock)
|
||||
{
|
||||
if (_activeForwards.Remove(externalPort))
|
||||
{
|
||||
_logger?.LogInformation("Removed port forward: {ExternalPort}", externalPort);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
_logger?.LogWarning("Port forward {ExternalPort} not found", externalPort);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to remove port forward {ExternalPort}", externalPort);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<List<PortForward>> GetActivePortForwardsAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
lock (_lock)
|
||||
{
|
||||
return _activeForwards.Values.ToList();
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to get active port forwards");
|
||||
return new List<PortForward>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IPAddress?> GetLocalIpAddressAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
// Get the local IP address (not localhost)
|
||||
var host = Dns.GetHostEntry(Dns.GetHostName());
|
||||
foreach (var ip in host.AddressList)
|
||||
{
|
||||
if (ip.AddressFamily == AddressFamily.InterNetwork && !IPAddress.IsLoopback(ip))
|
||||
{
|
||||
return ip;
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: try to get IP from network interfaces
|
||||
var networkInterfaces = System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces();
|
||||
foreach (var networkInterface in networkInterfaces)
|
||||
{
|
||||
if (networkInterface.OperationalStatus == System.Net.NetworkInformation.OperationalStatus.Up &&
|
||||
networkInterface.NetworkInterfaceType != System.Net.NetworkInformation.NetworkInterfaceType.Loopback)
|
||||
{
|
||||
var properties = networkInterface.GetIPProperties();
|
||||
foreach (var address in properties.UnicastAddresses)
|
||||
{
|
||||
if (address.Address.AddressFamily == AddressFamily.InterNetwork &&
|
||||
!IPAddress.IsLoopback(address.Address))
|
||||
{
|
||||
return address.Address;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Failed to get local IP address");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IPAddress?> GetExternalIpAddressAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
// Use external service to get public IP (more reliable than UPnP on macOS)
|
||||
using var client = new HttpClient();
|
||||
client.Timeout = TimeSpan.FromSeconds(10);
|
||||
|
||||
var response = await client.GetStringAsync("https://api.ipify.org");
|
||||
if (IPAddress.TryParse(response.Trim(), out var externalIp))
|
||||
{
|
||||
_logger?.LogInformation("External IP from service: {ExternalIP}", externalIp);
|
||||
return externalIp;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Failed to get external IP from service");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class PortForward
|
||||
{
|
||||
public int ExternalPort { get; set; }
|
||||
public int InternalPort { get; set; }
|
||||
public IPAddress? InternalIp { get; set; }
|
||||
public string Protocol { get; set; } = "TCP";
|
||||
public string Description { get; set; } = "";
|
||||
public DateTime CreatedAt { get; set; }
|
||||
public string Status { get; set; } = "Active";
|
||||
}
|
||||
@@ -13,6 +13,7 @@ public interface IUPnPManager
|
||||
Task<bool> AddPortMappingAsync(int externalPort, int internalPort, string description);
|
||||
Task<bool> RemovePortMappingAsync(int externalPort);
|
||||
Task<List<PortMapping>> GetPortMappingsAsync();
|
||||
Task<string> GetUPnPDiagnosticsAsync();
|
||||
}
|
||||
|
||||
public class UPnPManager : IUPnPManager
|
||||
@@ -34,27 +35,49 @@ public class UPnPManager : IUPnPManager
|
||||
|
||||
try
|
||||
{
|
||||
_logger?.LogInformation("Initializing UPnP/NAT discovery...");
|
||||
_logger?.LogInformation("Initializing UPnP/NAT discovery for macOS...");
|
||||
|
||||
// Create a new NAT discoverer
|
||||
var discoverer = new NatDiscoverer();
|
||||
|
||||
// Discover UPnP devices with a 10-second timeout
|
||||
_natDevice = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, new CancellationTokenSource(TimeSpan.FromSeconds(10)));
|
||||
// Try UPnP first (most common on home routers)
|
||||
_logger?.LogInformation("Trying UPnP discovery...");
|
||||
_natDevice = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, new CancellationTokenSource(TimeSpan.FromSeconds(8)));
|
||||
|
||||
if (_natDevice != null)
|
||||
{
|
||||
_logger?.LogInformation("UPnP device discovered successfully");
|
||||
_isInitialized = true;
|
||||
return;
|
||||
}
|
||||
else
|
||||
|
||||
// Try NAT-PMP (Apple's protocol, common on Apple routers)
|
||||
_logger?.LogInformation("UPnP not found, trying NAT-PMP...");
|
||||
_natDevice = await discoverer.DiscoverDeviceAsync(PortMapper.Pmp, new CancellationTokenSource(TimeSpan.FromSeconds(5)));
|
||||
|
||||
if (_natDevice != null)
|
||||
{
|
||||
_logger?.LogWarning("No UPnP devices found");
|
||||
_logger?.LogInformation("NAT-PMP device discovered successfully");
|
||||
_isInitialized = true;
|
||||
return;
|
||||
}
|
||||
|
||||
// Note: PCP (Port Control Protocol) is not supported by Open.NAT library
|
||||
// We'll stick with UPnP and NAT-PMP which are the most common
|
||||
|
||||
_logger?.LogWarning("No UPnP/NAT devices found. This could be due to:");
|
||||
_logger?.LogWarning("- Router doesn't support UPnP");
|
||||
_logger?.LogWarning("- macOS firewall blocking discovery");
|
||||
_logger?.LogWarning("- Network policy blocking UPnP");
|
||||
_logger?.LogWarning("- Router UPnP is disabled");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "UPnP initialization failed");
|
||||
_logger?.LogWarning(ex, "UPnP/NAT initialization failed");
|
||||
_logger?.LogInformation("Common solutions:");
|
||||
_logger?.LogInformation("- Check router UPnP settings");
|
||||
_logger?.LogInformation("- Temporarily disable macOS firewall");
|
||||
_logger?.LogInformation("- Try from a different network");
|
||||
_natDevice = null;
|
||||
_isInitialized = false;
|
||||
}
|
||||
@@ -74,6 +97,84 @@ public class UPnPManager : IUPnPManager
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<string> GetUPnPDiagnosticsAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
var diagnostics = new List<string>();
|
||||
|
||||
// Check if we can discover devices
|
||||
diagnostics.Add("🔍 UPnP Discovery Test:");
|
||||
|
||||
var discoverer = new NatDiscoverer();
|
||||
|
||||
// Test UPnP
|
||||
try
|
||||
{
|
||||
var upnpDevice = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, new CancellationTokenSource(TimeSpan.FromSeconds(5)));
|
||||
if (upnpDevice != null)
|
||||
{
|
||||
diagnostics.Add("✅ UPnP: Available");
|
||||
var externalIp = await upnpDevice.GetExternalIPAsync();
|
||||
diagnostics.Add($" External IP: {externalIp}");
|
||||
}
|
||||
else
|
||||
{
|
||||
diagnostics.Add("❌ UPnP: Not available");
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
diagnostics.Add($"❌ UPnP: Error - {ex.Message}");
|
||||
}
|
||||
|
||||
// Test NAT-PMP
|
||||
try
|
||||
{
|
||||
var pmpDevice = await discoverer.DiscoverDeviceAsync(PortMapper.Pmp, new CancellationTokenSource(TimeSpan.FromSeconds(5)));
|
||||
if (pmpDevice != null)
|
||||
{
|
||||
diagnostics.Add("✅ NAT-PMP: Available");
|
||||
var externalIp = await pmpDevice.GetExternalIPAsync();
|
||||
diagnostics.Add($" External IP: {externalIp}");
|
||||
}
|
||||
else
|
||||
{
|
||||
diagnostics.Add("❌ NAT-PMP: Not available");
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
diagnostics.Add($"❌ NAT-PMP: Error - {ex.Message}");
|
||||
}
|
||||
|
||||
// Note: PCP is not supported by Open.NAT library
|
||||
diagnostics.Add("❌ PCP: Not supported by Open.NAT library");
|
||||
|
||||
// Network information
|
||||
diagnostics.Add("\n🌐 Network Information:");
|
||||
var localIp = GetLocalIpAddress();
|
||||
diagnostics.Add($"Local IP: {localIp?.ToString() ?? "Unknown"}");
|
||||
|
||||
// Try external IP service as fallback
|
||||
try
|
||||
{
|
||||
var externalIp = await GetExternalIpFromServiceAsync();
|
||||
diagnostics.Add($"External IP (Service): {externalIp?.ToString() ?? "Unknown"}");
|
||||
}
|
||||
catch
|
||||
{
|
||||
diagnostics.Add("External IP (Service): Failed");
|
||||
}
|
||||
|
||||
return string.Join("\n", diagnostics);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
return $"Diagnostics failed: {ex.Message}";
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IPAddress?> GetExternalIpAddressAsync()
|
||||
{
|
||||
try
|
||||
|
||||
Reference in New Issue
Block a user