using System.Net.Sockets; using System.Runtime.InteropServices; using System.Text; /// /// Monitors block devices via kernel netlink and manages the Micronona USB stick. /// /// Events: /// OnMicrononaStickInserted – stick is ready (initialized if necessary), includes mount path /// OnStickRemoved – stick was removed /// /// Empty sticks are initialized automatically with a new .micronona file. /// Only one stick is tracked at a time. /// public class DiskManager : IDisposable { // ------------------------------------------------------------------------- // Events // ------------------------------------------------------------------------- public event Action? OnMicrononaStickInserted; public event Action? OnStickRemoved; // ------------------------------------------------------------------------- // State // ------------------------------------------------------------------------- private string? _mountedDevice; // e.g. "/dev/sda1" private string? _mountPath; // e.g. "/mnt/micronona" public const string MarkerFile = ".micronona"; // ------------------------------------------------------------------------- // Netlink socket // ------------------------------------------------------------------------- private const int AF_NETLINK = 16; private const int NETLINK_KOBJECT_UEVENT = 15; [StructLayout(LayoutKind.Sequential)] private struct SockaddrNl { public ushort nl_family; public ushort nl_pad; public uint nl_pid; public uint nl_groups; } [DllImport("libc", SetLastError = true)] private static extern int socket(int domain, int type, int protocol); [DllImport("libc", SetLastError = true)] private static extern int bind(int sockfd, ref SockaddrNl addr, int addrlen); [DllImport("libc", SetLastError = true)] private static extern int recv(int sockfd, byte[] buf, int len, int flags); [DllImport("libc", SetLastError = true)] private static extern int close(int fd); private int _fd = -1; private CancellationTokenSource? _cts; // ------------------------------------------------------------------------- // Lifecycle // ------------------------------------------------------------------------- public void Start() { _fd = socket(AF_NETLINK, (int)SocketType.Raw, NETLINK_KOBJECT_UEVENT); if (_fd < 0) throw new InvalidOperationException("Failed to open netlink socket."); var addr = new SockaddrNl { nl_family = AF_NETLINK, nl_groups = 1 }; if (bind(_fd, ref addr, Marshal.SizeOf()) < 0) throw new InvalidOperationException("Failed to bind netlink socket."); _cts = new CancellationTokenSource(); Task.Run(() => WatchLoop(_cts.Token)); // Scan for sticks that were already inserted at startup foreach (var entry in Directory.EnumerateDirectories("/sys/class/block/")) { var name = Path.GetFileName(entry); if (name.StartsWith("mmcblk")) continue; if (!name[^1..].All(char.IsDigit)) continue; // Only consider removable devices (USB sticks) var parent = name.TrimEnd('0', '1', '2', '3', '4', '5', '6', '7', '8', '9'); var removablePath = $"/sys/class/block/{parent}/removable"; if (!File.Exists(removablePath)) continue; if (File.ReadAllText(removablePath).Trim() != "1") continue; HandleAdd("/dev/" + name); if (_mountedDevice != null) break; } Console.WriteLine("[DiskManager] Started."); } private void WatchLoop(CancellationToken ct) { var buffer = new byte[4096]; while (!ct.IsCancellationRequested) { int len = recv(_fd, buffer, buffer.Length, 0); if (len <= 0) continue; var message = Encoding.UTF8.GetString(buffer, 0, len); ParseUevent(message); } } // ------------------------------------------------------------------------- // Uevent parsing // ------------------------------------------------------------------------- private void ParseUevent(string message) { var parts = message.Split('\0', StringSplitOptions.RemoveEmptyEntries); string? action = null; string? devtype = null; string? devname = null; foreach (var part in parts) { if (part.StartsWith("ACTION=")) action = part[7..]; if (part.StartsWith("DEVTYPE=")) devtype = part[8..]; if (part.StartsWith("DEVNAME=")) devname = part[8..]; } // Only care about partitions (or disks without partitions) if (devtype != "partition" && devtype != "disk") return; if (devname == null) return; // Ignore internal SD card if (devname.StartsWith("mmcblk")) return; var devPath = "/dev/" + devname; if (action == "add") HandleAdd(devPath); else if (action == "remove") HandleRemove(devPath); } // ------------------------------------------------------------------------- // Add / Remove // ------------------------------------------------------------------------- private void HandleAdd(string devPath) { if (_mountedDevice != null) return; // already tracking a stick if (!devPath[^1..].All(char.IsDigit)) return; Console.WriteLine($"[DiskManager] Device added: {devPath}"); string? mountPath = null; for (int i = 0; i < 5; i++) { Thread.Sleep(300); mountPath = UdisksMount(devPath); if (mountPath != null) break; } if (mountPath == null) { Console.WriteLine($"[DiskManager] Mount failed for {devPath}, ignoring."); return; } _mountedDevice = devPath; _mountPath = mountPath; var markerPath = Path.Combine(mountPath, MarkerFile); if (!File.Exists(markerPath)) { bool isEmpty; try { isEmpty = !Directory.EnumerateFileSystemEntries(mountPath).Any(); } catch (UnauthorizedAccessException) { isEmpty = false; } if (!isEmpty) { Console.WriteLine($"[DiskManager] Not a Micronona stick, ignoring: {mountPath}"); UdisksUnmount(devPath); _mountedDevice = null; _mountPath = null; return; } Console.WriteLine($"[DiskManager] Initializing new stick at {mountPath}"); InitializeStick(markerPath); } Console.WriteLine($"[DiskManager] Micronona stick at {mountPath}"); OnMicrononaStickInserted?.Invoke(mountPath); } private void HandleRemove(string devPath) { if (_mountedDevice != devPath) return; Console.WriteLine($"[DiskManager] Device removed: {devPath}"); UdisksUnmount(devPath); _mountedDevice = null; _mountPath = null; OnStickRemoved?.Invoke(); } // ------------------------------------------------------------------------- // Stick initialization // ------------------------------------------------------------------------- private static void InitializeStick(string markerPath) { var model = new Tomlyn.Model.TomlTable { ["drive"] = new Tomlyn.Model.TomlTable { ["id"] = Guid.NewGuid().ToString() } }; File.WriteAllText(markerPath, Tomlyn.Toml.FromModel(model)); Console.WriteLine($"[DiskManager] Written {markerPath}"); } // ------------------------------------------------------------------------- // Stick discovery and config update (CLI use) // ------------------------------------------------------------------------- /// /// Scan standard udisks mount roots for a currently-mounted Micronona stick. /// Returns the mount path of the first stick whose root contains the marker /// file, or null if none is found. Independent of the netlink watcher. /// public static string? FindMicrononaMount() { foreach (string root in new[] { "/run/media", "/media" }) { if (!Directory.Exists(root)) continue; foreach (string userDir in Directory.EnumerateDirectories(root)) foreach (string mount in Directory.EnumerateDirectories(userDir)) if (File.Exists(Path.Combine(mount, MarkerFile))) return mount; } return null; } /// /// Write or update the [keyboard] layout entry in the stick's .micronona file. /// Preserves all other existing keys. /// public static void SaveKeyboardLayout(string mountPath, string layout) { string markerPath = Path.Combine(mountPath, MarkerFile); Tomlyn.Model.TomlTable model = File.Exists(markerPath) ? Tomlyn.Toml.ToModel(File.ReadAllText(markerPath)) : new Tomlyn.Model.TomlTable(); if (!model.TryGetValue("keyboard", out object? kbObj) || kbObj is not Tomlyn.Model.TomlTable kb) { kb = new Tomlyn.Model.TomlTable(); model["keyboard"] = kb; } kb["layout"] = layout; File.WriteAllText(markerPath, Tomlyn.Toml.FromModel(model)); } // ------------------------------------------------------------------------- // Mount helpers (udisksctl — no root required) // ------------------------------------------------------------------------- private static string? UdisksMount(string devPath) { var psi = new System.Diagnostics.ProcessStartInfo { FileName = "udisksctl", Arguments = $"mount -b {devPath} --no-user-interaction", RedirectStandardOutput = true, RedirectStandardError = true }; var p = System.Diagnostics.Process.Start(psi)!; var output = p.StandardOutput.ReadToEnd(); var error = p.StandardError.ReadToEnd(); p.WaitForExit(); // Erfolgreich gemountet var idx = output.IndexOf(" at "); if (idx >= 0) return output[(idx + 4)..].Trim().TrimEnd('.'); // Bereits gemountet — Pfad aus Fehlermeldung lesen var alreadyIdx = error.IndexOf("already mounted at `"); if (alreadyIdx >= 0) { var start = alreadyIdx + 20; var end = error.IndexOf("'", start); if (end > start) return error[start..end]; } Console.WriteLine($"[DiskManager] udisksctl: {error.Trim()}"); return null; } private static void UdisksUnmount(string devPath) { var psi = new System.Diagnostics.ProcessStartInfo { FileName = "udisksctl", RedirectStandardError = true }; psi.ArgumentList.Add("unmount"); psi.ArgumentList.Add("-b"); psi.ArgumentList.Add(devPath); psi.ArgumentList.Add("--no-user-interaction"); var p = System.Diagnostics.Process.Start(psi)!; p.WaitForExit(); } // ------------------------------------------------------------------------- // Public accessors // ------------------------------------------------------------------------- /// /// Current mount path, or null if no stick is present. /// public string? MountPath => _mountPath; /// /// Lists files on the inserted stick, sorted by last-edited descending. /// Excludes the marker file, directories, files with names longer than 12 /// characters, and files whose names contain non-elementary ASCII characters. /// Returns (null, files) on success, or (error message, null) on failure. /// public (string? Error, IReadOnlyList? Files) Dir() { if (_mountPath == null) return ("no disk inserted", null); var files = new DirectoryInfo(_mountPath) .GetFiles() .Where(f => f.Name != MarkerFile && f.Name.Length <= 12 && f.Name.All(IsElementaryAscii)) .OrderByDescending(f => f.LastWriteTime) .ToList(); if (files.Count == 0) return ("disk empty", null); return (null, files); } private static bool IsElementaryAscii(char c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '.' || c == '-' || c == '_'; // ------------------------------------------------------------------------- // IDisposable // ------------------------------------------------------------------------- public void Dispose() { _cts?.Cancel(); if (_fd >= 0) { close(_fd); _fd = -1; } } }