micronona/DiskManager.cs
Hans-Jörg Meyer e0078538c3 Keyboard-Layout-Detection, SN76489-Sound, Text-Editor
- KeyboardLayoutDetector (KMAP-Befehl und --detect-keyboard-CLI)
  inkl. loadkeys-Integration und Persistenz im .micronona-Marker
- SN76489 PSG mit SDL-Audio-Anbindung
- Voll-Bildschirm-Texteditor (edit <file>) mit Undo, Cut/Paste,
  horizontalem Scrollen und Speicherbestätigung
- DiskManager-Erweiterungen: FindMicrononaMount, SaveKeyboardLayout,
  Dir-Listing
- ^-Glyph für die Editor-Statuszeile

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-13 22:09:57 +02:00

381 lines
13 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text;
/// <summary>
/// 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.
/// </summary>
public class DiskManager : IDisposable
{
// -------------------------------------------------------------------------
// Events
// -------------------------------------------------------------------------
public event Action<string>? 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<SockaddrNl>()) < 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)
// -------------------------------------------------------------------------
/// <summary>
/// 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.
/// </summary>
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;
}
/// <summary>
/// Write or update the [keyboard] layout entry in the stick's .micronona file.
/// Preserves all other existing keys.
/// </summary>
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
// -------------------------------------------------------------------------
/// <summary>
/// Current mount path, or null if no stick is present.
/// </summary>
public string? MountPath => _mountPath;
/// <summary>
/// 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.
/// </summary>
public (string? Error, IReadOnlyList<FileInfo>? 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;
}
}
}