openNGVFS/init-wasm/openngvfs_init_wasm_lib/src/lib.rs

mod raw_fn;
pub mod error;
pub mod afs;
pub mod bep_ovfs;

use std::sync::OnceLock;
use std::env;
use crate::error::MkdirError;

#[no_mangle]
pub extern "C" fn auto_mount() -> i32 {
    AUTO_MOUNT_HANDLER.get().unwrap()()
}

type AutoMountHandler = fn() -> i32;

pub static AUTO_MOUNT_HANDLER: OnceLock<AutoMountHandler> = OnceLock::new();

pub fn set_auto_mount_handler(handler: AutoMountHandler) {
    AUTO_MOUNT_HANDLER.set(handler).unwrap();
}

/// Get API version
/// returns the Major Version, Minor Version and Patch Version
pub fn api_ver_get() -> (i32, i32, i32) {
    let mut maj: i32 = 0;
    let mut min: i32 = 0;
    let mut pat: i32 = 0;
    unsafe {
        raw_fn::api_ver_get(&mut maj, &mut min, &mut pat);
    }
    (maj, min, pat)
}

/// Check if key exists in exkv
pub fn exkv_has_key(key: &str) -> bool {
    let ret = unsafe {
        raw_fn::exkv_get_len(key.as_ptr(), key.len())
    };
    ret >= 0
}

/// Get value of key in exkv
pub fn exkv_get(key: &str) ->Result<Vec<u8>, error::GetKeyError> {
    let ret = unsafe {
        raw_fn::exkv_get_len(key.as_ptr(), key.len())
    };
    let len: usize = match ret {
        -2 => return Err(error::GetKeyError::KeyNotExists),
        -1 => return Err(error::GetKeyError::InternalError(
            String::from("exkv_get_len: reading key from memory out of bounds")
        )),
        v if v > 0 => v.try_into().unwrap(),
        _ => return Err(error::GetKeyError::InternalError(
            format!("exkv_get_len: unknown error: code = {}", ret)
        )),
    };
    let mut buf = vec![0; len as usize];
    let ret = unsafe {
        raw_fn::exkv_get_val(key.as_ptr(), key.len(), buf.as_mut_ptr(), len)
    };
    match ret {
        -3 => Err(error::GetKeyError::InternalError(
            String::from("exkv_get_val: reading key from memory out of bounds")
        )),
        -2 => Err(error::GetKeyError::KeyNotExists),
        -1 => Err(error::GetKeyError::InternalError(
            String::from("exkv_get_val: writing value to buffer memory out of bounds")
        )),
        0 => Err(error::GetKeyError::InternalError(
            String::from("exkv_get_val: buffer length <= 0")
        )),
        v if v >= 0 => if <i32 as TryInto<usize>>::try_into(v).unwrap() == len { Ok(buf) } else{
            Err(error::GetKeyError::InternalError(
                format!("exkv_get_val: length not match: value len={}, write to buffer {} bytes", len, v)
            ))
        },
        _ => Err(error::GetKeyError::InternalError(
            format!("exkv_get_val: unknown error: code = {}", ret)
        ))
    }
}

/// Create directory for prepare mount point. Works like `mkdir -p`.
pub fn vfs_mkdir(path: &str, mode: i32) -> Result<(), MkdirError> {
    let r = unsafe {
        raw_fn::vfs_mkdir(path.as_ptr(), path.len(), mode)
    };
    match r {
        0 => Ok(()),
        -1 => Err(MkdirError::InternalError(
            String::from("vfs_mkdir: reading path from memory out of bounds")
        )),
        -2 => Err(MkdirError::InternalError(
            String::from("vfs_mkdir: failed create directory: see logs.")
        )),
        _ => Err(MkdirError::InternalError(
            format!("vfs_mkdir: unknown error: code = {}", r)
        )),
    }
}

/// Get app name form env variable 'NAGAE_APP_NAME'
pub fn get_app_name() -> String {
    let key = "NAGAE_APP_NAME";
    match env::var(key) {
        Ok(val) => val,
        Err(e) => match e {
            std::env::VarError::NotPresent => String::new(),
            std::env::VarError::NotUnicode(v) => {
                panic!("env variable {} is not unicode: {:?}", key, v)
            }
        },
    }
}

/// Get nagae rov root path from env variable 'NAGAE_ROV_ROOT'
pub fn get_nagae_rov_root() -> String {
    let key = "NAGAE_ROV_ROOT";
    match env::var(key) {
        Ok(val) => val,
        Err(e) => match e {
            std::env::VarError::NotPresent => String::new(),
            std::env::VarError::NotUnicode(v) => {
                panic!("env variable {} is not unicode: {:?}", key, v)
            }
        },
    }
}