1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! # erfs-rt (Embedded Resource Filesystem - runtime libarary)
//!
//! `erfs-rt` access the generated fs.


#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[allow(non_upper_case_globals)]
mod erfs_binding;

use std::slice;

/// handle of a ERFS instance, returned by the generated codes.
pub use erfs_binding::ErfsRoot;

/// handle of a directory entry
pub use erfs_binding::ErfsHandle;

/// get content of specified file. 
pub fn read(fs: ErfsRoot, path: &str) -> Result<&'static [u8], i32> {
    let mut buf = 0 as *const u8;
    let mut size :u32 = 0;
    let pbuf = &mut buf as *mut *const u8;
    let psize = &mut size as *mut u32;

    let ret :i32;
    unsafe { 
        ret = erfs_binding::erfs_read(fs, path.as_ptr(), path.len() as u32, pbuf, psize);
    }
    if ret == 0 {
        unsafe {
            Ok(slice::from_raw_parts(buf, size as usize))
        }
    } else {
        Err(ret)
    }  
}

/// get directory entry handle from pathname.
pub fn open(fs: ErfsRoot, path: &str) -> Result<(ErfsHandle, u32), i32> {
    let mut handle: ErfsHandle = 0 as ErfsHandle;
    let mut size :u32 = 0;
    let phandle = &mut handle as *mut ErfsHandle;
    let psize = &mut size as *mut u32;

    let ret :i32;
    unsafe { 
        ret = erfs_binding::erfs_open(fs, path.as_ptr(), path.len() as u32, phandle, psize);
    }
    if ret == 0 {
        Ok((handle, size as u32))
    } else {
        Err(ret)
    }  
}

/// get flags of the specified directory entry.
pub fn entry_flags(entry: ErfsHandle) -> Result<u32, i32> {
    let mut flags :u32 = 0;
    let pflags = &mut flags as *mut u32;
    let ret:i32;
    unsafe { 
        ret = erfs_binding::erfs_entryflags(entry, pflags);
    }
    if ret == 0 {
        Ok(flags)
    } else {
        Err(ret as i32)
    }
}

/// get size of the specified directory entry.
pub fn entry_size(entry: ErfsHandle) -> Result<u32, i32> {
    let mut size :u32 = 0;
    let psize = &mut size as *mut u32;
    let ret:i32;
    unsafe { 
        ret = erfs_binding::erfs_entryflags(entry, psize);
    }
    if ret == 0 {
        Ok(size)
    } else {
        Err(ret as i32)
    }
}

/// get file name of a directory entry
pub fn entry_name(fs: ErfsRoot, entry: ErfsHandle) -> Result<&'static [u8], i32> {
    let mut buf = 0 as *const u8;
    let mut size :u32 = 0;
    let pbuf = &mut buf as *mut *const u8;
    let psize = &mut size as *mut u32;

    let ret :i32;
    unsafe { 
        ret = erfs_binding::erfs_entryname(fs, entry, pbuf, psize);
    }
    if ret == 0 {
        unsafe {
            Ok(slice::from_raw_parts(buf, size as usize))
        }
    } else {
        Err(ret)
    } 
}

/// get content of a directory entry
pub fn read_file(fs: ErfsRoot, entry: ErfsHandle) -> Result<&'static [u8], i32> {
    let mut buf = 0 as *const u8;
    let mut size :u32 = 0;
    let pbuf = &mut buf as *mut *const u8;
    let psize = &mut size as *mut u32;

    let ret :i32;
    unsafe { 
        ret = erfs_binding::erfs_readfile(fs, entry, pbuf, psize);
    }
    if ret == 0 {
        unsafe {
            Ok(slice::from_raw_parts(buf, size as usize))
        }
    } else {
        Err(ret)
    } 
}

/// read a directory
pub fn read_dir(fs: ErfsRoot, dir: ErfsHandle, index: u32) -> Result<ErfsHandle, i32> {
    let mut handle: ErfsHandle = 0 as ErfsHandle;
    let phandle = &mut handle as *mut ErfsHandle;

    let ret :i32;
    unsafe { 
        ret = erfs_binding::erfs_readdir(fs, dir, index, phandle);
    }
    if ret == 0 {
        Ok(handle)
    } else {
        Err(ret)
    } 
}

/*
use erfs_binding::ErfsVisitFn;
pub fn erfs_travel(fs: ErfsRoot, func: ErfsVisitFn, ctx: *mut ::std::os::raw::c_void) -> i32 {
    unsafe { 
        erfs_binding::erfs_travel(fs, func, ctx) 
    }
}
*/