Add in-progress code that causes ICE

Author: andrew-d

Cargo.toml

@@ -3,3 +3,9 @@
 name = "tinycdb-rs"
 version = "0.0.1"
 authors = ["Andrew Dunham <[email protected]>"]
+build = "make"
+
+[[bin]]
+
+name = "encode"
+path = "util/encode.rs"

Makefile

@@ -0,0 +1,9 @@
+TINYCDB_VERSION := 0.78
+TINYCDB_PATH    := deps/tinycdb-$(TINYCDB_VERSION)
+CFLAGS          := -fPIC
+
+all: $(TINYCDB_PATH)/libcdb_pic.a
+	@cp $< $(OUT_DIR)/libcdb.a
+
+$(TINYCDB_PATH)/libcdb_pic.a:
+	$(MAKE) -C $(TINYCDB_PATH) piclib

deps/.gitignore

@@ -6,5 +6,5 @@ tests.out
 tests-shared.ok
 
 # Built artifacts
-libcdb.a
+libcdb*.a
 cdb

src/base.rs

@@ -0,0 +1,157 @@
+use std;
+use std::mem;
+use std::os::errno;
+
+use libc;
+use libc::{c_int, c_uint, c_void};
+use libc::funcs::posix88::fcntl::open;
+use libc::consts::os::posix88::{O_CREAT, O_RDONLY, O_RDWR};
+
+use ffi::ffi;
+
+pub struct CdbError {
+    code: c_int,
+    cause: String,
+}
+
+impl CdbError {
+    pub fn new(code: c_int) -> CdbError {
+        CdbError {
+            code: code,
+            cause: String::from_str("TODO"),
+        }
+    }
+
+    #[inline]
+    pub fn get_code(&self) -> c_int {
+        self.code
+    }
+}
+
+pub struct Cdb {
+    cdb: ffi::cdb,
+}
+
+impl Cdb {
+    pub fn open(path: &str) -> Result<Cdb, CdbError> {
+        let fd = path.with_c_str(|path| unsafe {
+            open(path, O_RDONLY, 0)
+        });
+
+        if fd < 0 {
+            return Err(CdbError::new(errno() as c_int));
+        }
+
+        let mut cdb: ffi::cdb = unsafe { std::mem::zeroed() };
+        let err = unsafe { ffi::cdb_init(&mut cdb as *mut ffi::cdb, fd) };
+        if err < 0 {
+            return Err(CdbError::new(errno() as c_int));
+        }
+
+        Ok(Cdb{
+            cdb: cdb,
+        })
+    }
+
+    fn cdb_ptr(&self) -> *const ffi::cdb {
+        &self.cdb as *const ffi::cdb
+    }
+
+    fn cdb_mut_ptr(&mut self) -> *mut ffi::cdb {
+        &mut self.cdb as *mut ffi::cdb
+    }
+
+    pub fn find(&mut self, key: &[u8]) -> Option<Vec<u8>> {
+        let res = unsafe {
+            ffi::cdb_find(
+                self.cdb_mut_ptr(),
+                key.as_ptr() as *const c_void,
+                key.len() as c_uint,
+            )
+        };
+        if res <= 0 {
+            return None
+        }
+
+        let ret = Vec::with_capacity(self.cdb.cdb_datalen() as uint);
+
+        // TODO: Pretty sure this never returns an error...
+        unsafe {
+            ffi::cdb_read(
+                self.cdb_ptr(),
+                ret.as_ptr() as *mut c_void,
+                self.cdb.cdb_datalen(),
+                self.cdb.cdb_datapos()
+            )
+        };
+
+        Some(ret)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate flate;
+    extern crate serialize;
+
+    use std::io::{File, fs};
+    use std::path::Path;
+    use self::flate::inflate_bytes;
+    use self::serialize::base64::FromBase64;
+
+    use super::*;
+
+    // De-base64s and decompresses
+    fn decompress_and_write(input: &[u8], path: &Path) {
+        let raw = match input.from_base64() {
+            Err(why) => fail!("Could not decode base64: {}", why),
+            Ok(val) => val,
+        };
+        let decomp = match inflate_bytes(raw.as_slice()) {
+            None => fail!("Could not inflate bytes: {}"),
+            Some(val) => val,
+        };
+
+        let mut file = match File::create(path) {
+            Err(why) => fail!("Couldn't create {}: {}", path.display(), why),
+            Ok(file) => file,
+        };
+
+        match file.write(decomp.as_slice()) {
+            Err(why) => fail!("Couldn't write to {}: {}", path.display(), why),
+            Ok(_) => {},
+        };
+    }
+
+    fn with_test_file(input: &[u8], name: &str, f: |&str|) {
+        let p = Path::new(name);
+
+        decompress_and_write(input, &p);
+        f(p.as_str().unwrap());
+        match fs::unlink(&p) {
+            Err(why) => println!("Couldn't remove temp file: {}", why),
+            Ok(_) => {},
+        };
+    }
+
+    static HelloCDB: &'static [u8] = (
+        b"7dIxCoAwDAXQoohCF8/QzdUjuOgdXETMVswiiKNTr20qGdydWn7g8/ghY1xj3nHwt4XY\
+          a4cwNeP/DtohhPlbSioJ7zSR9xx7LTlOHpm39aJuCbbV6+/cc7BG9g8="
+    );
+
+    #[test]
+    fn test_basic_open() {
+        with_test_file(HelloCDB, "basic.cdb", |path| {
+            let c = match Cdb::open(path) {
+                Err(why) => fail!("Could not open CDB"),
+                Ok(c) => c,
+            };
+            let res = match c.find("one".as_bytes()) {
+                None => fail!("Could not find 'one' in CDB"),
+                Some(val) => val,
+            };
+
+            assert!(res.as_slice(), "Hello".as_slice());
+        });
+    }
+}

src/ffi.rs

@@ -0,0 +1,108 @@
+#[allow(dead_code)]
+#[allow(non_camel_case_types)]
+pub mod ffi {
+    use libc::{c_char, c_int, c_uchar, c_uint, c_void};
+
+    pub struct cdb {
+        // File descriptor
+        pub cdb_fd: c_int,
+
+        // Datafile size
+        cdb_fsize: c_uint,
+
+        // End of data ptr
+        cdb_dend: c_uint,
+
+        // mmap'ed file memory
+        cdb_mem: *const c_uchar,
+
+        // Found data
+        cdb_vpos: c_uint,
+        cdb_vlen: c_uint,
+
+        // Found key
+        cdb_kpos: c_uint,
+        cdb_klen: c_uint,
+    }
+
+    // Macros defined in C
+    impl cdb {
+        #[inline]
+        pub fn cdb_datapos(&self) -> c_uint {
+            self.cdb_vpos
+        }
+
+        #[inline]
+        pub fn cdb_datalen(&self) -> c_uint {
+            self.cdb_vlen
+        }
+
+        #[inline]
+        pub fn cdb_keypos(&self) -> c_uint {
+            self.cdb_kpos
+        }
+
+        #[inline]
+        pub fn cdb_keylen(&self) -> c_uint {
+            self.cdb_klen
+        }
+    }
+
+    pub struct cdb_find {
+        cdb_cdbp: *mut cdb,
+        cdb_hval: c_uint,
+        cdb_htp: *const c_uchar,
+        cdb_htab: *const c_uchar,
+        cdb_htend: *const c_uchar,
+        cdb_httodo: c_uint,
+        cdb_key: *const c_void,
+        cdb_klen: c_uint,
+    }
+
+    pub struct cdb_make {
+        // File descriptor
+        pub cdb_fd: c_int,
+
+        // Data position so far
+        cdb_dpos: c_uint,
+
+        // Record count so far
+        cdb_rcnt: c_uint,
+
+        // Write buffer
+        cdb_buf: [c_uchar, ..4096],
+
+        // Current buf position
+        cdb_bpos: *mut c_uchar,
+
+        // List of arrays of record infos
+        // OLD: cdb_rl*
+        cdb_rec: [*mut c_void, ..256],
+    }
+
+    pub static CDB_PUT_ADD: c_uint = 0;
+    pub static CDB_PUT_REPLACE: c_uint = 1;
+    pub static CDB_PUT_INSERT: c_uint = 2;
+    pub static CDB_PUT_WARN: c_uint = 3;
+    pub static CDB_PUT_REPLACE0: c_uint = 4;
+
+    pub static CDB_FIND: c_uint = 0;            // == CDB_PUT_ADD
+    pub static CDB_FIND_REMOVE: c_uint = 1;     // == CDB_PUT_REPLACE
+    pub static CDB_FIND_FILL0: c_uint = 4;      // == CDB_PUT_REPLACE0
+
+
+    #[link(name = "cdb", kind = "static")]
+    extern "C" {
+        pub fn cdb_init(cdbp: *mut cdb, fd: c_int) -> c_int;
+        pub fn cdb_free(cdbp: *mut cdb);
+        pub fn cdb_read(cdbp: *const cdb, buf: *mut c_void, len: c_uint, pos: c_uint) -> c_int;
+        pub fn cdb_get(cdbp: *const cdb, len: c_uint, pos: c_uint) -> *const c_void;
+
+        pub fn cdb_find(cdbp: *mut cdb, key: *const c_void, klen: c_uint) -> c_int;
+        pub fn cdb_findinit(cdbfp: *mut cdb_find, cdb: *mut cdb,
+                            key: *const c_void, klen: c_uint) -> c_int;
+        pub fn cdb_findnext(cdbfp: *mut cdb_find) -> c_int;
+
+
+    }
+}

src/lib.rs

@@ -0,0 +1,6 @@
+#![feature(globs)]
+
+extern crate libc;
+
+mod ffi;
+pub mod base;

target/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

util/Makefile

@@ -0,0 +1,6 @@
+.SUFFIXES:
+
+all: hello.cdb
+
+%.cdb: %.cdbmake
+	@cdb -c $@ $<

util/encode.rs

@@ -0,0 +1,34 @@
+/// This is a simple helper utility to encode a cdb file for use in our tests.
+/// Pass it a filename as the first argument and it will DEFLATE and then
+/// Base64 encode the contents, writing the output to stdout.
+
+extern crate flate;
+extern crate serialize;
+
+use std::io::File;
+use std::os;
+use flate::deflate_bytes;
+use serialize::base64::{STANDARD, ToBase64};
+
+fn main() {
+    let args = os::args();
+    let fname = args[1].as_slice();
+
+    let mut file = match File::open(&Path::new(fname)) {
+        Err(why) => fail!("Couldn't open {}: {}", fname, why.desc),
+        Ok(file) => file,
+    };
+
+    let s = match file.read_to_end() {
+        Err(why) => fail!("Couldn't read {}: {}", fname, why.desc),
+        Ok(s) => s,
+    };
+
+    let deflated = match deflate_bytes(s.as_slice()) {
+        None => fail!("Error encoding to bytes"),
+        Some(v) => v,
+    };
+
+    let encoded = deflated.as_slice().to_base64(STANDARD);
+    print!("{}", encoded);
+}

util/hello.cdb

@@ -0,0 +1,3 @@
++3,5:one->Hello
++3,7:two->Goodbye
+