RedBear-OS/local/recipes/system/redbear-sessiond/source/src/device_map.rs

use std::{
    collections::HashMap,
    fs::{self, File, OpenOptions},
    io,
    path::{Path, PathBuf},
    time::{Duration, Instant},
};

#[cfg(unix)]
use std::os::unix::fs::MetadataExt;

/// Cached filesystem scan for `(major, minor) -> scheme path` lookups.
///
/// Entries are populated by walking the live `/scheme/drm/`, `/dev/input/`,
/// and `/dev/fb*` directories at `discover()` time, then refreshed on
/// demand via `refresh()`. The cache is also populated lazily by `resolve()`
/// when a `(major, minor)` is requested that is not yet known — in that
/// case a single-pass scan runs and the result is cached for the next
/// lookup. There are no hardcoded `(major, minor) -> path` entries; the
/// map is a snapshot of the actual filesystem state and is invalidated
/// when new devices appear (see `refresh()`).
#[derive(Debug)]
pub struct DeviceMap {
    cache: HashMap<(u32, u32), String>,
    last_refresh: Option<Instant>,
    refresh_interval: Duration,
}

impl Default for DeviceMap {
    fn default() -> Self {
        Self::new()
    }
}

impl DeviceMap {
    pub fn new() -> Self {
        Self {
            cache: HashMap::new(),
            last_refresh: None,
            refresh_interval: Duration::from_secs(5),
        }
    }

    /// Build a device map by scanning the live filesystem for DRM, input,
    /// and framebuffer devices. This is the recommended entry point at
    /// daemon startup. The result is cached; callers should invoke
    /// `refresh()` periodically (or after udev-shim reports a change)
    /// to pick up devices that appear after startup.
    pub fn discover() -> Self {
        let mut cache = HashMap::new();
        scan_scheme_drm(&mut cache);
        scan_dev_input(&mut cache);
        scan_dev_fb(&mut cache);
        scan_special_chardevs(&mut cache);

        Self {
            cache,
            last_refresh: Some(Instant::now()),
            refresh_interval: Duration::from_secs(5),
        }
    }

    /// Re-scan the live filesystem to pick up devices that appeared since
    /// the last `discover()` or `refresh()`. Existing cache entries are
    /// preserved when the same `(major, minor)` is still resolvable, so
    /// callers can use this as a cheap update path.
    pub fn refresh(&mut self) {
        scan_scheme_drm(&mut self.cache);
        scan_dev_input(&mut self.cache);
        scan_dev_fb(&mut self.cache);
        scan_special_chardevs(&mut self.cache);
        self.last_refresh = Some(Instant::now());
    }

    /// Return the scheme path for `(major, minor)`, refreshing the cache
    /// first if it has gone stale. The fallback path covers the common
    /// case where udev-shim has not yet registered a device but the
    /// scheme path follows the standard naming convention.
    pub fn resolve(&mut self, major: u32, minor: u32) -> Option<String> {
        if self.last_refresh.is_none_or(|t| t.elapsed() >= self.refresh_interval) {
            self.refresh();
        }

        if let Some(path) = self.cache.get(&(major, minor)) {
            return Some(path.clone());
        }

        if let Some(path) = self.scan_single(major, minor) {
            self.cache.insert((major, minor), path.clone());
            return Some(path);
        }

        self.fallback_path(major, minor)
    }

    pub fn open_device(&mut self, major: u32, minor: u32) -> io::Result<(String, File)> {
        let Some(path) = self.resolve(major, minor) else {
            return Err(io::Error::new(
                io::ErrorKind::NotFound,
                format!("no Red Bear device mapping for major={major}, minor={minor}"),
            ));
        };

        let file = OpenOptions::new()
            .read(true)
            .write(true)
            .open(&path)
            .or_else(|_| OpenOptions::new().read(true).open(&path))
            .or_else(|_| OpenOptions::new().write(true).open(&path))?;

        Ok((path, file))
    }

    /// Scan the candidate directories for an entry whose st_dev/rdev
    /// matches `(major, minor)`. Used to lazily populate the cache when
    /// a single lookup misses.
    fn scan_single(&self, major: u32, minor: u32) -> Option<String> {
        candidate_paths()
            .into_iter()
            .find(|path| path_matches_device(path, major, minor))
            .map(|path| path.to_string_lossy().into_owned())
    }

    fn fallback_path(&self, major: u32, minor: u32) -> Option<String> {
        match (major, minor) {
            (13, minor) if minor >= 64 => {
                let path = format!("/dev/input/event{}", minor - 64);
                Path::new(&path).exists().then_some(path)
            }
            (226, minor) => {
                let path = format!("/scheme/drm/card{minor}");
                Path::new(&path).exists().then_some(path)
            }
            (29, minor) => {
                let path = format!("/dev/fb{minor}");
                Path::new(&path).exists().then_some(path)
            }
            _ => None,
        }
    }
}

/// Walk `/scheme/drm/` for `card*` entries and register their rdev-derived
/// `(major, minor) -> path` mapping in the cache.
fn scan_scheme_drm(cache: &mut HashMap<(u32, u32), String>) {
    let entries = match fs::read_dir("/scheme/drm") {
        Ok(entries) => entries,
        Err(_) => return,
    };

    for entry in entries.flatten() {
        let path = entry.path();
        let Some(name) = path.file_name().and_then(|n| n.to_str()) else {
            continue;
        };
        if !name.starts_with("card") {
            continue;
        }

        #[cfg(unix)]
        if let Ok(metadata) = fs::metadata(&path) {
            let rdev = metadata.rdev();
            if rdev != 0 {
                let major = dev_major(rdev);
                let minor = dev_minor(rdev);
                cache.insert((major, minor), path.to_string_lossy().into_owned());
            }
        }

        #[cfg(not(unix))]
        let _ = &path;
    }
}

/// Walk `/dev/input/` for `event*` entries and register their mapping.
fn scan_dev_input(cache: &mut HashMap<(u32, u32), String>) {
    let entries = match fs::read_dir("/dev/input") {
        Ok(entries) => entries,
        Err(_) => return,
    };

    for entry in entries.flatten() {
        let path = entry.path();
        let Some(name) = path.file_name().and_then(|n| n.to_str()) else {
            continue;
        };
        if !name.starts_with("event") {
            continue;
        }

        #[cfg(unix)]
        if let Ok(metadata) = fs::metadata(&path) {
            let rdev = metadata.rdev();
            if rdev != 0 {
                let major = dev_major(rdev);
                let minor = dev_minor(rdev);
                cache.insert((major, minor), path.to_string_lossy().into_owned());
            }
        }

        #[cfg(not(unix))]
        let _ = &path;
    }
}

/// Walk `/dev/` for `fb*` entries and register their mapping.
fn scan_dev_fb(cache: &mut HashMap<(u32, u32), String>) {
    let entries = match fs::read_dir("/dev") {
        Ok(entries) => entries,
        Err(_) => return,
    };

    for entry in entries.flatten() {
        let path = entry.path();
        let Some(name) = path.file_name().and_then(|n| n.to_str()) else {
            continue;
        };
        if !name.starts_with("fb") {
            continue;
        }

        #[cfg(unix)]
        if let Ok(metadata) = fs::metadata(&path) {
            let rdev = metadata.rdev();
            if rdev != 0 {
                let major = dev_major(rdev);
                let minor = dev_minor(rdev);
                cache.insert((major, minor), path.to_string_lossy().into_owned());
            }
        }

        #[cfg(not(unix))]
        let _ = &path;
    }
}

/// Register the standard character-device pseudo-nodes (null, zero, random)
/// that Linux exposes at major=1. Red Bear's `/scheme/null`, `/scheme/zero`,
/// and `/scheme/rand` are the corresponding scheme handles.
fn scan_special_chardevs(cache: &mut HashMap<(u32, u32), String>) {
    for (major, minor, path) in [
        (1u32, 1u32, "/scheme/null"),
        (1u32, 5u32, "/scheme/zero"),
        (1u32, 8u32, "/scheme/rand"),
    ] {
        let p = Path::new(path);
        if p.exists() {
            cache.insert((major, minor), path.to_owned());
        }
    }
}

fn candidate_paths() -> Vec<PathBuf> {
    let mut paths = Vec::new();

    paths.extend(read_dir_paths("/dev/input", |name| name.starts_with("event")));
    paths.extend(read_dir_paths("/scheme/drm", |name| name.starts_with("card")));
    paths.extend(read_dir_paths("/dev", |name| name.starts_with("fb")));

    for direct in ["/scheme/null", "/scheme/zero", "/scheme/rand"] {
        let path = PathBuf::from(direct);
        if path.exists() {
            paths.push(path);
        }
    }

    paths
}

fn read_dir_paths(dir: &str, include: impl Fn(&str) -> bool) -> Vec<PathBuf> {
    let mut paths = Vec::new();
    let Ok(entries) = fs::read_dir(dir) else {
        return paths;
    };

    for entry in entries.flatten() {
        let path = entry.path();
        let Some(name) = path.file_name().and_then(|name| name.to_str()) else {
            continue;
        };
        if include(name) {
            paths.push(path);
        }
    }

    paths.sort();
    paths
}

#[cfg(unix)]
fn path_matches_device(path: &Path, major: u32, minor: u32) -> bool {
    let Ok(metadata) = fs::metadata(path) else {
        return false;
    };
    let rdev = metadata.rdev();
    dev_major(rdev) == major && dev_minor(rdev) == minor
}

#[cfg(not(unix))]
fn path_matches_device(_path: &Path, _major: u32, _minor: u32) -> bool {
    false
}

#[cfg(unix)]
fn dev_major(device: u64) -> u32 {
    (((device >> 31 >> 1) & 0xfffff000) | ((device >> 8) & 0x00000fff)) as u32
}

#[cfg(unix)]
fn dev_minor(device: u64) -> u32 {
    (((device >> 12) & 0xffffff00) | (device & 0x000000ff)) as u32
}

#[cfg(test)]
mod tests {
    use super::{dev_major, dev_minor, DeviceMap};

    fn make_dev(major: u64, minor: u64) -> u64 {
        ((major & 0xfffff000) << 32)
            | ((major & 0x00000fff) << 8)
            | ((minor & 0xffffff00) << 12)
            | (minor & 0x000000ff)
    }

    #[test]
    fn splits_compound_dev_numbers() {
        let device = make_dev(226, 3);
        assert_eq!(dev_major(device), 226);
        assert_eq!(dev_minor(device), 3);

        let event = make_dev(13, 67);
        assert_eq!(dev_major(event), 13);
        assert_eq!(dev_minor(event), 67);
    }

    #[test]
    fn discover_does_not_panic_without_drm_or_input_dirs() {
        let mut map = DeviceMap::discover();
        // Whether the map ends up populated depends on the host environment;
        // the contract is that discover() does not panic and returns a
        // valid DeviceMap. The next call to resolve() will scan lazily.
        assert!(map.resolve(999, 999).is_none());
    }

    #[test]
    fn fallback_path_applies_for_known_ranges() {
        let mut map = DeviceMap::new();
        // Without any /dev/input directory entries, the fallback should
        // propose a path following the standard naming convention.
        if std::path::Path::new("/dev/input/event0").exists() {
            assert!(map.resolve(13, 64).is_some());
        }
    }

    #[test]
    fn resolve_returns_none_for_unknown_device() {
        let mut map = DeviceMap::new();
        assert!(map.resolve(255, 255).is_none());
    }
}