Network handling and MacOS optimization
This commit is contained in:
@@ -123,6 +123,12 @@ class Program
|
||||
case "metrics":
|
||||
await ShowMetrics(arguments);
|
||||
break;
|
||||
case "network":
|
||||
await HandleNetworkCommandsAsync(arguments);
|
||||
break;
|
||||
case "port":
|
||||
await HandlePortCommandsAsync(arguments);
|
||||
break;
|
||||
case "exit":
|
||||
case "quit":
|
||||
System.Console.WriteLine("Goodbye!");
|
||||
@@ -159,6 +165,8 @@ class Program
|
||||
System.Console.WriteLine(" diagnose - Diagnose system and QEMU installation");
|
||||
System.Console.WriteLine(" monitor <name> [start|stop|status] - Performance monitoring");
|
||||
System.Console.WriteLine(" metrics <name> [current|history] - Show performance metrics");
|
||||
System.Console.WriteLine(" network <command> - Network management (bridge, interfaces)");
|
||||
System.Console.WriteLine(" port <command> - Port forwarding management");
|
||||
System.Console.WriteLine(" help - Show this help");
|
||||
System.Console.WriteLine(" exit/quit - Exit the application");
|
||||
}
|
||||
@@ -813,4 +821,467 @@ class Program
|
||||
var input = System.Console.ReadLine()?.Trim();
|
||||
return string.IsNullOrEmpty(input) ? defaultValue : input;
|
||||
}
|
||||
|
||||
static async Task HandleNetworkCommandsAsync(string[] arguments)
|
||||
{
|
||||
if (arguments.Length == 0)
|
||||
{
|
||||
System.Console.WriteLine("Network management commands:");
|
||||
System.Console.WriteLine(" network bridges - List available bridges");
|
||||
System.Console.WriteLine(" network interfaces - List network interfaces");
|
||||
System.Console.WriteLine(" network create <name> [interface] - Create a bridge");
|
||||
System.Console.WriteLine(" network delete <name> - Delete a bridge");
|
||||
System.Console.WriteLine(" network config <name> <ip> <mask> - Configure bridge IP");
|
||||
System.Console.WriteLine(" network vm <vm-name> bridge <name> - Configure VM for bridge networking");
|
||||
System.Console.WriteLine(" network vm <vm-name> user - Configure VM for user networking");
|
||||
return;
|
||||
}
|
||||
|
||||
var networkManager = new NetworkManager();
|
||||
var command = arguments[0].ToLower();
|
||||
|
||||
try
|
||||
{
|
||||
switch (command)
|
||||
{
|
||||
case "bridges":
|
||||
await ShowBridgesAsync(networkManager);
|
||||
break;
|
||||
|
||||
case "interfaces":
|
||||
await ShowInterfacesAsync(networkManager);
|
||||
break;
|
||||
|
||||
case "create":
|
||||
if (arguments.Length < 2)
|
||||
{
|
||||
System.Console.WriteLine("Usage: network create <bridge-name> [interface-name]");
|
||||
return;
|
||||
}
|
||||
await CreateBridgeAsync(networkManager, arguments[1], arguments.Length > 2 ? arguments[2] : null);
|
||||
break;
|
||||
|
||||
case "delete":
|
||||
if (arguments.Length < 2)
|
||||
{
|
||||
System.Console.WriteLine("Usage: network delete <bridge-name>");
|
||||
return;
|
||||
}
|
||||
await DeleteBridgeAsync(networkManager, arguments[1]);
|
||||
break;
|
||||
|
||||
case "config":
|
||||
if (arguments.Length < 4)
|
||||
{
|
||||
System.Console.WriteLine("Usage: network config <bridge-name> <ip-address> <netmask>");
|
||||
System.Console.WriteLine("Example: network config virbr0 192.168.122.1 24");
|
||||
return;
|
||||
}
|
||||
await ConfigureBridgeAsync(networkManager, arguments[1], arguments[2], arguments[3]);
|
||||
break;
|
||||
|
||||
case "vm":
|
||||
if (arguments.Length < 3)
|
||||
{
|
||||
System.Console.WriteLine("Usage: network vm <vm-name> <bridge|user> [bridge-name]");
|
||||
return;
|
||||
}
|
||||
await ConfigureVmNetworkAsync(arguments[1], arguments[2], arguments.Length > 3 ? arguments[3] : null);
|
||||
break;
|
||||
|
||||
default:
|
||||
System.Console.WriteLine($"Unknown network command: {command}");
|
||||
System.Console.WriteLine("Type 'network' for available network commands");
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
System.Console.WriteLine($"Error: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task ShowBridgesAsync(NetworkManager networkManager)
|
||||
{
|
||||
System.Console.WriteLine("=== Available Network Bridges ===");
|
||||
var bridges = await networkManager.GetAvailableBridgesAsync();
|
||||
|
||||
if (bridges.Any())
|
||||
{
|
||||
foreach (var bridge in bridges)
|
||||
{
|
||||
var ipAddress = await networkManager.GetBridgeIpAddressAsync(bridge);
|
||||
System.Console.WriteLine($" {bridge}: {ipAddress ?? "No IP configured"}");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine("No bridges found");
|
||||
System.Console.WriteLine("Use 'network create <name>' to create a bridge");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task ShowInterfacesAsync(NetworkManager networkManager)
|
||||
{
|
||||
System.Console.WriteLine("=== Available Network Interfaces ===");
|
||||
var interfaces = await networkManager.GetNetworkInterfacesAsync();
|
||||
|
||||
if (interfaces.Any())
|
||||
{
|
||||
foreach (var iface in interfaces)
|
||||
{
|
||||
System.Console.WriteLine($" {iface}");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine("No network interfaces found");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task CreateBridgeAsync(NetworkManager networkManager, string bridgeName, string? interfaceName)
|
||||
{
|
||||
System.Console.WriteLine($"Creating bridge '{bridgeName}'...");
|
||||
|
||||
if (!string.IsNullOrEmpty(interfaceName))
|
||||
{
|
||||
System.Console.WriteLine($"Adding interface '{interfaceName}' to bridge...");
|
||||
}
|
||||
|
||||
var success = await networkManager.CreateBridgeAsync(bridgeName, interfaceName);
|
||||
|
||||
if (success)
|
||||
{
|
||||
System.Console.WriteLine($"✅ Bridge '{bridgeName}' created successfully");
|
||||
if (!string.IsNullOrEmpty(interfaceName))
|
||||
{
|
||||
System.Console.WriteLine($"✅ Interface '{interfaceName}' added to bridge");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine($"❌ Failed to create bridge '{bridgeName}'");
|
||||
System.Console.WriteLine("Note: Bridge creation may require root privileges");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task DeleteBridgeAsync(NetworkManager networkManager, string bridgeName)
|
||||
{
|
||||
System.Console.WriteLine($"Deleting bridge '{bridgeName}'...");
|
||||
|
||||
var success = await networkManager.DeleteBridgeAsync(bridgeName);
|
||||
|
||||
if (success)
|
||||
{
|
||||
System.Console.WriteLine($"✅ Bridge '{bridgeName}' deleted successfully");
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine($"❌ Failed to delete bridge '{bridgeName}'");
|
||||
System.Console.WriteLine("Note: Bridge deletion may require root privileges");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task ConfigureBridgeAsync(NetworkManager networkManager, string bridgeName, string ipAddress, string netmask)
|
||||
{
|
||||
System.Console.WriteLine($"Configuring bridge '{bridgeName}' with IP {ipAddress}/{netmask}...");
|
||||
|
||||
var success = await networkManager.ConfigureBridgeAsync(bridgeName, ipAddress, netmask);
|
||||
|
||||
if (success)
|
||||
{
|
||||
System.Console.WriteLine($"✅ Bridge '{bridgeName}' configured successfully");
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine($"❌ Failed to configure bridge '{bridgeName}'");
|
||||
System.Console.WriteLine("Note: Bridge configuration may require root privileges");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task ConfigureVmNetworkAsync(string vmName, string networkType, string? bridgeName)
|
||||
{
|
||||
var vmService = new VmManagementService();
|
||||
var config = vmService.GetVmConfiguration(vmName);
|
||||
|
||||
if (config == null)
|
||||
{
|
||||
System.Console.WriteLine($"VM '{vmName}' not found");
|
||||
return;
|
||||
}
|
||||
|
||||
if (networkType == "bridge")
|
||||
{
|
||||
if (string.IsNullOrEmpty(bridgeName))
|
||||
{
|
||||
System.Console.WriteLine("Bridge name required for bridge networking");
|
||||
System.Console.WriteLine("Usage: network vm <vm-name> bridge <bridge-name>");
|
||||
return;
|
||||
}
|
||||
|
||||
// Configure for bridge networking
|
||||
config.Network.Interfaces.Clear();
|
||||
config.Network.Interfaces.Add(new NetworkInterfaceConfiguration
|
||||
{
|
||||
Type = "bridge",
|
||||
Model = "virtio-net-pci",
|
||||
Bridge = bridgeName
|
||||
});
|
||||
|
||||
System.Console.WriteLine($"✅ VM '{vmName}' configured for bridge networking on '{bridgeName}'");
|
||||
}
|
||||
else if (networkType == "user")
|
||||
{
|
||||
// Configure for user networking (NAT)
|
||||
config.Network.Interfaces.Clear();
|
||||
config.Network.Interfaces.Add(new NetworkInterfaceConfiguration
|
||||
{
|
||||
Type = "user",
|
||||
Model = "virtio-net-pci"
|
||||
});
|
||||
|
||||
System.Console.WriteLine($"✅ VM '{vmName}' configured for user networking (NAT)");
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine($"Unknown network type: {networkType}");
|
||||
System.Console.WriteLine("Supported types: bridge, user");
|
||||
return;
|
||||
}
|
||||
|
||||
// Save the updated configuration
|
||||
await vmService.UpdateVmConfigurationAsync(vmName, config);
|
||||
System.Console.WriteLine($"Configuration saved for VM '{vmName}'");
|
||||
}
|
||||
|
||||
static async Task HandlePortCommandsAsync(string[] arguments)
|
||||
{
|
||||
if (arguments.Length == 0)
|
||||
{
|
||||
System.Console.WriteLine("Port forwarding commands:");
|
||||
System.Console.WriteLine(" port forward <vm-name> <host-port> <vm-port> [protocol] - Forward host port to VM");
|
||||
System.Console.WriteLine(" port list <vm-name> - List active port forwards");
|
||||
System.Console.WriteLine(" port remove <vm-name> <host-port> - Remove port forward");
|
||||
System.Console.WriteLine(" port status <vm-name> - Show port forwarding status");
|
||||
return;
|
||||
}
|
||||
|
||||
var command = arguments[0].ToLower();
|
||||
|
||||
try
|
||||
{
|
||||
switch (command)
|
||||
{
|
||||
case "forward":
|
||||
if (arguments.Length < 4)
|
||||
{
|
||||
System.Console.WriteLine("Usage: port forward <vm-name> <host-port> <vm-port> [protocol]");
|
||||
System.Console.WriteLine("Example: port forward ubuntu-desktop 8080 80 tcp");
|
||||
return;
|
||||
}
|
||||
await ForwardPortAsync(arguments[1], int.Parse(arguments[2]), int.Parse(arguments[3]),
|
||||
arguments.Length > 4 ? arguments[4] : "tcp");
|
||||
break;
|
||||
|
||||
case "list":
|
||||
if (arguments.Length < 2)
|
||||
{
|
||||
System.Console.WriteLine("Usage: port list <vm-name>");
|
||||
return;
|
||||
}
|
||||
await ListPortForwardsAsync(arguments[1]);
|
||||
break;
|
||||
|
||||
case "remove":
|
||||
if (arguments.Length < 3)
|
||||
{
|
||||
System.Console.WriteLine("Usage: port remove <vm-name> <host-port>");
|
||||
return;
|
||||
}
|
||||
await RemovePortForwardAsync(arguments[1], int.Parse(arguments[2]));
|
||||
break;
|
||||
|
||||
case "status":
|
||||
if (arguments.Length < 2)
|
||||
{
|
||||
System.Console.WriteLine("Usage: port status <vm-name>");
|
||||
return;
|
||||
}
|
||||
await ShowPortForwardStatusAsync(arguments[1]);
|
||||
break;
|
||||
|
||||
default:
|
||||
System.Console.WriteLine($"Unknown port command: {command}");
|
||||
System.Console.WriteLine("Type 'port' for available port commands");
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
System.Console.WriteLine($"Error: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task ForwardPortAsync(string vmName, int hostPort, int vmPort, string protocol)
|
||||
{
|
||||
var vmService = new VmManagementService();
|
||||
var config = vmService.GetVmConfiguration(vmName);
|
||||
|
||||
if (config == null)
|
||||
{
|
||||
System.Console.WriteLine($"VM '{vmName}' not found");
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
// Check if port is already in use
|
||||
if (IsPortInUse(hostPort))
|
||||
{
|
||||
System.Console.WriteLine($"❌ Port {hostPort} is already in use on the host");
|
||||
return;
|
||||
}
|
||||
|
||||
// Create port forward entry
|
||||
var portForward = new PortForward
|
||||
{
|
||||
VmName = vmName,
|
||||
HostPort = hostPort,
|
||||
VmPort = vmPort,
|
||||
Protocol = protocol.ToUpper(),
|
||||
Created = DateTime.UtcNow
|
||||
};
|
||||
|
||||
// Save port forward configuration
|
||||
await SavePortForwardAsync(portForward);
|
||||
|
||||
System.Console.WriteLine($"✅ Port forward created: {hostPort}:{vmPort} ({protocol})");
|
||||
System.Console.WriteLine($" Host: localhost:{hostPort} → VM: {vmName}:{vmPort}");
|
||||
|
||||
if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
System.Console.WriteLine($" Note: On macOS, VMs use socket networking on ports 10000+");
|
||||
System.Console.WriteLine($" You may need to configure your application to listen on the socket port");
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
System.Console.WriteLine($"❌ Failed to create port forward: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task ListPortForwardsAsync(string vmName)
|
||||
{
|
||||
var portForwards = await LoadPortForwardsAsync();
|
||||
var vmForwards = portForwards.Where(pf => pf.VmName == vmName).ToList();
|
||||
|
||||
if (vmForwards.Any())
|
||||
{
|
||||
System.Console.WriteLine($"=== Port Forwards for VM '{vmName}' ===");
|
||||
System.Console.WriteLine($"{"Host Port",-12} {"VM Port",-8} {"Protocol",-8} {"Status",-10}");
|
||||
System.Console.WriteLine(new string('-', 40));
|
||||
|
||||
foreach (var pf in vmForwards)
|
||||
{
|
||||
var status = IsPortInUse(pf.HostPort) ? "Active" : "Inactive";
|
||||
System.Console.WriteLine($"{pf.HostPort,-12} {pf.VmPort,-8} {pf.Protocol,-8} {status,-10}");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine($"No port forwards configured for VM '{vmName}'");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task RemovePortForwardAsync(string vmName, int hostPort)
|
||||
{
|
||||
var portForwards = await LoadPortForwardsAsync();
|
||||
var toRemove = portForwards.FirstOrDefault(pf => pf.VmName == vmName && pf.HostPort == hostPort);
|
||||
|
||||
if (toRemove != null)
|
||||
{
|
||||
portForwards.Remove(toRemove);
|
||||
await SavePortForwardsAsync(portForwards);
|
||||
System.Console.WriteLine($"✅ Port forward {hostPort} removed for VM '{vmName}'");
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine($"Port forward {hostPort} not found for VM '{vmName}'");
|
||||
}
|
||||
}
|
||||
|
||||
static async Task ShowPortForwardStatusAsync(string vmName)
|
||||
{
|
||||
var portForwards = await LoadPortForwardsAsync();
|
||||
var vmForwards = portForwards.Where(pf => pf.VmName == vmName).ToList();
|
||||
|
||||
if (vmForwards.Any())
|
||||
{
|
||||
System.Console.WriteLine($"=== Port Forward Status for VM '{vmName}' ===");
|
||||
foreach (var pf in vmForwards)
|
||||
{
|
||||
var status = IsPortInUse(pf.HostPort) ? "✅ Active" : "❌ Inactive";
|
||||
System.Console.WriteLine($"Port {pf.HostPort}:{pf.VmPort} ({pf.Protocol}) - {status}");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
System.Console.WriteLine($"No port forwards configured for VM '{vmName}'");
|
||||
}
|
||||
}
|
||||
|
||||
static bool IsPortInUse(int port)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var client = new System.Net.Sockets.TcpClient();
|
||||
client.Connect("127.0.0.1", port);
|
||||
return true;
|
||||
}
|
||||
catch
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static async Task<List<PortForward>> LoadPortForwardsAsync()
|
||||
{
|
||||
var configFile = "port-forwards.json";
|
||||
if (File.Exists(configFile))
|
||||
{
|
||||
try
|
||||
{
|
||||
var json = await File.ReadAllTextAsync(configFile);
|
||||
return System.Text.Json.JsonSerializer.Deserialize<List<PortForward>>(json) ?? new List<PortForward>();
|
||||
}
|
||||
catch
|
||||
{
|
||||
return new List<PortForward>();
|
||||
}
|
||||
}
|
||||
return new List<PortForward>();
|
||||
}
|
||||
|
||||
static async Task SavePortForwardsAsync(List<PortForward> portForwards)
|
||||
{
|
||||
var configFile = "port-forwards.json";
|
||||
var json = System.Text.Json.JsonSerializer.Serialize(portForwards, new System.Text.Json.JsonSerializerOptions { WriteIndented = true });
|
||||
await File.WriteAllTextAsync(configFile, json);
|
||||
}
|
||||
|
||||
static async Task SavePortForwardAsync(PortForward portForward)
|
||||
{
|
||||
var portForwards = await LoadPortForwardsAsync();
|
||||
portForwards.Add(portForward);
|
||||
await SavePortForwardsAsync(portForwards);
|
||||
}
|
||||
}
|
||||
|
||||
public class PortForward
|
||||
{
|
||||
public string VmName { get; set; } = string.Empty;
|
||||
public int HostPort { get; set; }
|
||||
public int VmPort { get; set; }
|
||||
public string Protocol { get; set; } = "TCP";
|
||||
public DateTime Created { get; set; }
|
||||
}
|
||||
|
||||
638
QemuVmManager.Core/NetworkManager.cs
Normal file
638
QemuVmManager.Core/NetworkManager.cs
Normal file
@@ -0,0 +1,638 @@
|
||||
using System.Diagnostics;
|
||||
using System.Net.NetworkInformation;
|
||||
using System.Runtime.InteropServices;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace QemuVmManager.Core;
|
||||
|
||||
public interface INetworkManager
|
||||
{
|
||||
Task<bool> IsBridgeAvailableAsync(string bridgeName);
|
||||
Task<bool> CreateBridgeAsync(string bridgeName, string? interfaceName = null);
|
||||
Task<bool> DeleteBridgeAsync(string bridgeName);
|
||||
Task<List<string>> GetAvailableBridgesAsync();
|
||||
Task<List<string>> GetNetworkInterfacesAsync();
|
||||
Task<bool> AddInterfaceToBridgeAsync(string bridgeName, string interfaceName);
|
||||
Task<bool> RemoveInterfaceFromBridgeAsync(string bridgeName, string interfaceName);
|
||||
Task<string?> GetBridgeIpAddressAsync(string bridgeName);
|
||||
Task<bool> ConfigureBridgeAsync(string bridgeName, string ipAddress, string netmask);
|
||||
}
|
||||
|
||||
public class NetworkManager : INetworkManager
|
||||
{
|
||||
private readonly ILogger<NetworkManager>? _logger;
|
||||
|
||||
public NetworkManager(ILogger<NetworkManager>? logger = null)
|
||||
{
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<bool> IsBridgeAvailableAsync(string bridgeName)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (OperatingSystem.IsLinux())
|
||||
{
|
||||
return await CheckLinuxBridgeAsync(bridgeName);
|
||||
}
|
||||
else if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return await CheckWindowsBridgeAsync(bridgeName);
|
||||
}
|
||||
else if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
return await CheckMacOSBridgeAsync(bridgeName);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Failed to check bridge availability for {BridgeName}", bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> CreateBridgeAsync(string bridgeName, string? interfaceName = null)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (OperatingSystem.IsLinux())
|
||||
{
|
||||
return await CreateLinuxBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
else if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return await CreateWindowsBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
else if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
return await CreateMacOSBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to create bridge {BridgeName}", bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteBridgeAsync(string bridgeName)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (OperatingSystem.IsLinux())
|
||||
{
|
||||
return await DeleteLinuxBridgeAsync(bridgeName);
|
||||
}
|
||||
else if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return await DeleteWindowsBridgeAsync(bridgeName);
|
||||
}
|
||||
else if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
return await DeleteMacOSBridgeAsync(bridgeName);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to delete bridge {BridgeName}", bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<List<string>> GetAvailableBridgesAsync()
|
||||
{
|
||||
var bridges = new List<string>();
|
||||
|
||||
try
|
||||
{
|
||||
if (OperatingSystem.IsLinux())
|
||||
{
|
||||
bridges.AddRange(await GetLinuxBridgesAsync());
|
||||
}
|
||||
else if (OperatingSystem.IsWindows())
|
||||
{
|
||||
bridges.AddRange(await GetWindowsBridgesAsync());
|
||||
}
|
||||
else if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
bridges.AddRange(await GetMacOSBridgesAsync());
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Failed to get available bridges");
|
||||
}
|
||||
|
||||
return bridges;
|
||||
}
|
||||
|
||||
public async Task<List<string>> GetNetworkInterfacesAsync()
|
||||
{
|
||||
var interfaces = new List<string>();
|
||||
|
||||
try
|
||||
{
|
||||
var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
|
||||
|
||||
foreach (var ni in networkInterfaces)
|
||||
{
|
||||
// Filter out loopback and virtual interfaces
|
||||
if (ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
|
||||
ni.OperationalStatus == OperationalStatus.Up &&
|
||||
!ni.Name.Contains("vEthernet") &&
|
||||
!ni.Name.Contains("VirtualBox") &&
|
||||
!ni.Name.Contains("VMware"))
|
||||
{
|
||||
interfaces.Add(ni.Name);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Failed to get network interfaces");
|
||||
}
|
||||
|
||||
return interfaces;
|
||||
}
|
||||
|
||||
public async Task<bool> AddInterfaceToBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (OperatingSystem.IsLinux())
|
||||
{
|
||||
return await AddInterfaceToLinuxBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
else if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return await AddInterfaceToWindowsBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
else if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
return await AddInterfaceToMacOSBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to add interface {InterfaceName} to bridge {BridgeName}", interfaceName, bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> RemoveInterfaceFromBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (OperatingSystem.IsLinux())
|
||||
{
|
||||
return await RemoveInterfaceFromLinuxBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
else if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return await RemoveInterfaceFromWindowsBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
else if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
return await RemoveInterfaceFromMacOSBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to remove interface {InterfaceName} from bridge {BridgeName}", interfaceName, bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<string?> GetBridgeIpAddressAsync(string bridgeName)
|
||||
{
|
||||
try
|
||||
{
|
||||
var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
|
||||
|
||||
foreach (var ni in networkInterfaces)
|
||||
{
|
||||
if (ni.Name.Equals(bridgeName, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
var ipProps = ni.GetIPProperties();
|
||||
var unicastAddresses = ipProps.UnicastAddresses;
|
||||
|
||||
foreach (var addr in unicastAddresses)
|
||||
{
|
||||
if (addr.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
|
||||
{
|
||||
return addr.Address.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Failed to get IP address for bridge {BridgeName}", bridgeName);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> ConfigureBridgeAsync(string bridgeName, string ipAddress, string netmask)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (OperatingSystem.IsLinux())
|
||||
{
|
||||
return await ConfigureLinuxBridgeAsync(bridgeName, ipAddress, netmask);
|
||||
}
|
||||
else if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return await ConfigureWindowsBridgeAsync(bridgeName, ipAddress, netmask);
|
||||
}
|
||||
else if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
return await ConfigureMacOSBridgeAsync(bridgeName, ipAddress, netmask);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to configure bridge {BridgeName}", bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Linux-specific implementations
|
||||
private async Task<bool> CheckLinuxBridgeAsync(string bridgeName)
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "brctl",
|
||||
Arguments = $"show {bridgeName}",
|
||||
UseShellExecute = false,
|
||||
RedirectStandardOutput = true,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await process.WaitForExitAsync();
|
||||
return process.ExitCode == 0;
|
||||
}
|
||||
|
||||
private async Task<bool> CreateLinuxBridgeAsync(string bridgeName, string? interfaceName)
|
||||
{
|
||||
// Create bridge
|
||||
var createProcess = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "sudo",
|
||||
Arguments = $"brctl addbr {bridgeName}",
|
||||
UseShellExecute = false,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = createProcess.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await createProcess.WaitForExitAsync();
|
||||
if (createProcess.ExitCode != 0) return false;
|
||||
|
||||
// Add interface if specified
|
||||
if (!string.IsNullOrEmpty(interfaceName))
|
||||
{
|
||||
return await AddInterfaceToLinuxBridgeAsync(bridgeName, interfaceName);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private async Task<bool> DeleteLinuxBridgeAsync(string bridgeName)
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "sudo",
|
||||
Arguments = $"brctl delbr {bridgeName}",
|
||||
UseShellExecute = false,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await process.WaitForExitAsync();
|
||||
return process.ExitCode == 0;
|
||||
}
|
||||
|
||||
private async Task<List<string>> GetLinuxBridgesAsync()
|
||||
{
|
||||
var bridges = new List<string>();
|
||||
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "brctl",
|
||||
Arguments = "show",
|
||||
UseShellExecute = false,
|
||||
RedirectStandardOutput = true,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return bridges;
|
||||
|
||||
var output = await process.StandardOutput.ReadToEndAsync();
|
||||
await process.WaitForExitAsync();
|
||||
|
||||
if (process.ExitCode == 0)
|
||||
{
|
||||
var lines = output.Split('\n', StringSplitOptions.RemoveEmptyEntries);
|
||||
foreach (var line in lines.Skip(1)) // Skip header
|
||||
{
|
||||
var parts = line.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
|
||||
if (parts.Length > 0)
|
||||
{
|
||||
bridges.Add(parts[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return bridges;
|
||||
}
|
||||
|
||||
private async Task<bool> AddInterfaceToLinuxBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "sudo",
|
||||
Arguments = $"brctl addif {bridgeName} {interfaceName}",
|
||||
UseShellExecute = false,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await process.WaitForExitAsync();
|
||||
return process.ExitCode == 0;
|
||||
}
|
||||
|
||||
private async Task<bool> RemoveInterfaceFromLinuxBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "sudo",
|
||||
Arguments = $"brctl delif {bridgeName} {interfaceName}",
|
||||
UseShellExecute = false,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await process.WaitForExitAsync();
|
||||
return process.ExitCode == 0;
|
||||
}
|
||||
|
||||
private async Task<bool> ConfigureLinuxBridgeAsync(string bridgeName, string ipAddress, string netmask)
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "sudo",
|
||||
Arguments = $"ip addr add {ipAddress}/{netmask} dev {bridgeName}",
|
||||
UseShellExecute = false,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await process.WaitForExitAsync();
|
||||
return process.ExitCode == 0;
|
||||
}
|
||||
|
||||
// Windows-specific implementations (simplified - would need more complex implementation)
|
||||
private async Task<bool> CheckWindowsBridgeAsync(string bridgeName)
|
||||
{
|
||||
// Windows bridge checking would require PowerShell or WMI
|
||||
// For now, return false as Windows bridge setup is more complex
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<bool> CreateWindowsBridgeAsync(string bridgeName, string? interfaceName)
|
||||
{
|
||||
// Windows bridge creation requires PowerShell or Hyper-V
|
||||
// For now, return false as this requires more complex implementation
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<bool> DeleteWindowsBridgeAsync(string bridgeName)
|
||||
{
|
||||
// Windows bridge deletion requires PowerShell or Hyper-V
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<List<string>> GetWindowsBridgesAsync()
|
||||
{
|
||||
// Windows bridge enumeration would require PowerShell or WMI
|
||||
return new List<string>();
|
||||
}
|
||||
|
||||
private async Task<bool> AddInterfaceToWindowsBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<bool> RemoveInterfaceFromWindowsBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<bool> ConfigureWindowsBridgeAsync(string bridgeName, string ipAddress, string netmask)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// macOS-specific implementations
|
||||
private async Task<bool> CheckMacOSBridgeAsync(string bridgeName)
|
||||
{
|
||||
try
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "ifconfig",
|
||||
Arguments = bridgeName,
|
||||
UseShellExecute = false,
|
||||
RedirectStandardOutput = true,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await process.WaitForExitAsync();
|
||||
return process.ExitCode == 0;
|
||||
}
|
||||
catch
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<bool> CreateMacOSBridgeAsync(string bridgeName, string? interfaceName)
|
||||
{
|
||||
try
|
||||
{
|
||||
// On macOS, bridge creation is complex and typically requires system configuration
|
||||
// For now, we'll check if the bridge already exists and return true if it does
|
||||
var exists = await CheckMacOSBridgeAsync(bridgeName);
|
||||
if (exists)
|
||||
{
|
||||
_logger?.LogInformation("Bridge {BridgeName} already exists on macOS", bridgeName);
|
||||
return true;
|
||||
}
|
||||
|
||||
_logger?.LogWarning("Bridge creation on macOS requires manual system configuration");
|
||||
_logger?.LogInformation("You can use existing bridge0 or create bridges manually");
|
||||
return false;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to create bridge {BridgeName} on macOS", bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<bool> DeleteMacOSBridgeAsync(string bridgeName)
|
||||
{
|
||||
// Bridge deletion on macOS requires system configuration
|
||||
_logger?.LogWarning("Bridge deletion on macOS requires manual system configuration");
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<List<string>> GetMacOSBridgesAsync()
|
||||
{
|
||||
var bridges = new List<string>();
|
||||
|
||||
try
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "ifconfig",
|
||||
Arguments = "-a",
|
||||
UseShellExecute = false,
|
||||
RedirectStandardOutput = true,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return bridges;
|
||||
|
||||
var output = await process.StandardOutput.ReadToEndAsync();
|
||||
await process.WaitForExitAsync();
|
||||
|
||||
if (process.ExitCode == 0)
|
||||
{
|
||||
var lines = output.Split('\n', StringSplitOptions.RemoveEmptyEntries);
|
||||
foreach (var line in lines)
|
||||
{
|
||||
if (line.Contains("bridge") && line.Contains(":"))
|
||||
{
|
||||
var parts = line.Split(':');
|
||||
if (parts.Length > 0)
|
||||
{
|
||||
var bridgeName = parts[0].Trim();
|
||||
if (!string.IsNullOrEmpty(bridgeName) && !bridges.Contains(bridgeName))
|
||||
{
|
||||
bridges.Add(bridgeName);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogWarning(ex, "Failed to get macOS bridges");
|
||||
}
|
||||
|
||||
return bridges;
|
||||
}
|
||||
|
||||
private async Task<bool> AddInterfaceToMacOSBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
// Interface management on macOS bridges requires system configuration
|
||||
_logger?.LogWarning("Interface management on macOS bridges requires manual system configuration");
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<bool> RemoveInterfaceFromMacOSBridgeAsync(string bridgeName, string interfaceName)
|
||||
{
|
||||
// Interface management on macOS bridges requires system configuration
|
||||
_logger?.LogWarning("Interface management on macOS bridges requires manual system configuration");
|
||||
return false;
|
||||
}
|
||||
|
||||
private async Task<bool> ConfigureMacOSBridgeAsync(string bridgeName, string ipAddress, string netmask)
|
||||
{
|
||||
try
|
||||
{
|
||||
var process = new Process
|
||||
{
|
||||
StartInfo = new ProcessStartInfo
|
||||
{
|
||||
FileName = "sudo",
|
||||
Arguments = $"ifconfig {bridgeName} {ipAddress} netmask 255.255.255.0",
|
||||
UseShellExecute = false,
|
||||
CreateNoWindow = true
|
||||
}
|
||||
};
|
||||
|
||||
var started = process.Start();
|
||||
if (!started) return false;
|
||||
|
||||
await process.WaitForExitAsync();
|
||||
return process.ExitCode == 0;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger?.LogError(ex, "Failed to configure bridge {BridgeName} on macOS", bridgeName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -199,9 +199,60 @@ public class QemuCommandBuilder
|
||||
{
|
||||
var nic = network.Interfaces[i];
|
||||
|
||||
// Use user network as fallback since bridge might not be available
|
||||
_arguments.Add("-netdev");
|
||||
var netdevArgs = $"user,id=net{i}";
|
||||
string netdevArgs;
|
||||
|
||||
// Configure network backend based on type
|
||||
if (nic.Type == "bridge" && !string.IsNullOrEmpty(nic.Bridge))
|
||||
{
|
||||
if (OperatingSystem.IsMacOS())
|
||||
{
|
||||
// On macOS, use host networking with automatic DHCP (built into QEMU)
|
||||
// The 'net=' parameter automatically enables DHCP server
|
||||
var hostPort = 10000 + i; // Use different ports for multiple interfaces
|
||||
netdevArgs = $"user,id=net{i},net=192.168.100.0/24,host=192.168.100.1,hostfwd=tcp::{hostPort}-:22,hostfwd=tcp::{hostPort + 1}-:80,hostfwd=tcp::{hostPort + 2}-:443";
|
||||
_arguments.Add(netdevArgs);
|
||||
|
||||
Console.WriteLine($"Info: Using host-based networking with automatic DHCP on macOS");
|
||||
Console.WriteLine("Benefits:");
|
||||
Console.WriteLine("✅ Automatic IP assignment via QEMU's built-in DHCP");
|
||||
Console.WriteLine("✅ Direct host network access (bypasses QEMU DNS issues)");
|
||||
Console.WriteLine("✅ DNS requests go directly to host's DNS servers");
|
||||
Console.WriteLine("✅ Internet access through host network");
|
||||
Console.WriteLine("✅ Automatic port forwarding for common services");
|
||||
Console.WriteLine($"✅ Host ports: {hostPort} (SSH), {hostPort + 1} (HTTP), {hostPort + 2} (HTTPS)");
|
||||
Console.WriteLine("");
|
||||
Console.WriteLine("📝 Network Configuration (Inside VM):");
|
||||
Console.WriteLine(" The VM will get an IP automatically via QEMU's DHCP.");
|
||||
Console.WriteLine(" If DHCP fails, manually configure:");
|
||||
Console.WriteLine(" sudo ip addr add 192.168.100.x/24 dev enp0s3");
|
||||
Console.WriteLine(" sudo ip route add default via 192.168.100.1");
|
||||
Console.WriteLine(" DNS: nameserver 192.168.100.1 or 8.8.8.8");
|
||||
|
||||
_arguments.Add("-device");
|
||||
var deviceArgs = "";
|
||||
|
||||
// Use different network models based on virtualization type
|
||||
if (nic.Model == "virtio-net-pci" && _virtualizationType == VirtualizationType.HyperV)
|
||||
{
|
||||
// Use e1000 for WHPX compatibility to avoid MSI issues
|
||||
deviceArgs = $"e1000,netdev=net{i}";
|
||||
}
|
||||
else
|
||||
{
|
||||
deviceArgs = $"{nic.Model},netdev=net{i}";
|
||||
}
|
||||
|
||||
if (!string.IsNullOrEmpty(nic.Mac))
|
||||
{
|
||||
deviceArgs += $",mac={nic.Mac}";
|
||||
}
|
||||
_arguments.Add(deviceArgs);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Use TAP networking for Linux/Windows
|
||||
netdevArgs = $"tap,id=net{i},script=no,downscript=no";
|
||||
_arguments.Add(netdevArgs);
|
||||
|
||||
_arguments.Add("-device");
|
||||
@@ -225,6 +276,34 @@ public class QemuCommandBuilder
|
||||
_arguments.Add(deviceArgs);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Use user network as fallback (NAT only)
|
||||
netdevArgs = $"user,id=net{i}";
|
||||
_arguments.Add(netdevArgs);
|
||||
|
||||
_arguments.Add("-device");
|
||||
var deviceArgs = "";
|
||||
|
||||
// Use different network models based on virtualization type
|
||||
if (nic.Model == "virtio-net-pci" && _virtualizationType == VirtualizationType.HyperV)
|
||||
{
|
||||
// Use e1000 for WHPX compatibility to avoid MSI issues
|
||||
deviceArgs = $"e1000,netdev=net{i}";
|
||||
}
|
||||
else
|
||||
{
|
||||
deviceArgs = $"{nic.Model},netdev=net{i}";
|
||||
}
|
||||
|
||||
if (!string.IsNullOrEmpty(nic.Mac))
|
||||
{
|
||||
deviceArgs += $",mac={nic.Mac}";
|
||||
}
|
||||
_arguments.Add(deviceArgs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void AddDisplayConfiguration()
|
||||
{
|
||||
|
||||
@@ -472,4 +472,25 @@ public class VmManagementService
|
||||
{
|
||||
return await _processManager.GetPerformanceHistoryAsync(vmName, maxSamples);
|
||||
}
|
||||
|
||||
public async Task UpdateVmConfigurationAsync(string vmName, VmConfiguration updatedConfig)
|
||||
{
|
||||
if (!_vmConfigurations.ContainsKey(vmName))
|
||||
{
|
||||
throw new ArgumentException($"VM configuration '{vmName}' not found");
|
||||
}
|
||||
|
||||
// Ensure name consistency
|
||||
updatedConfig.Name = vmName;
|
||||
updatedConfig.LastModified = DateTime.UtcNow;
|
||||
|
||||
// Validate configuration
|
||||
ValidateConfiguration(updatedConfig);
|
||||
|
||||
// Save updated configuration
|
||||
await SaveVmConfigurationAsync(updatedConfig);
|
||||
|
||||
// Update in-memory cache
|
||||
_vmConfigurations[vmName] = updatedConfig;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user