skystack/QemuVmManager.Core/MacOSNetworkManager.cs

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";
}