Use the shared_library crate instead of loading symbols manually

5 files changed, 48 insertions, 207 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 7075df7..f059bad 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,6 +19,7 @@ headless = []
 gl_common = "*"
 lazy_static = "0.1"
 libc = "*"
+shared_library = "0.1"
 
 [build-dependencies]
 gl_generator = "*"
diff --git a/src/api/caca/ffi.rs b/src/api/caca/ffi.rs
new file mode 100644
index 0000000..e0921ae
--- /dev/null
+++ b/src/api/caca/ffi.rs
@@ -0,0 +1,23 @@
+use libc;
+use std::ffi::CStr;
+use std::mem;
+
+pub type caca_display_t = libc::c_void;
+pub type caca_canvas_t = libc::c_void;
+pub type caca_dither_t = libc::c_void;
+
+shared_library!(LibCaca, "libcaca.so.0",
+    pub fn caca_create_display(cv: *mut caca_canvas_t) -> *mut caca_display_t,
+    pub fn caca_free_display(dp: *mut caca_display_t) -> libc::c_int,
+    pub fn caca_get_canvas(dp: *mut caca_display_t) -> *mut caca_canvas_t,
+    pub fn caca_refresh_display(dp: *mut caca_display_t) -> libc::c_int,
+    pub fn caca_dither_bitmap(cv: *mut caca_canvas_t, x: libc::c_int, y: libc::c_int,
+                              w: libc::c_int, h: libc::c_int, d: *const caca_dither_t,
+                              pixels: *const libc::c_void) -> libc::c_int,
+    pub fn caca_free_dither(d: *mut caca_dither_t) -> libc::c_int,
+    pub fn caca_create_dither(bpp: libc::c_int, w: libc::c_int, h: libc::c_int,
+                              pitch: libc::c_int, rmask: libc::uint32_t, gmask: libc::uint32_t,
+                              bmask: libc::uint32_t, amask: libc::uint32_t) -> *mut caca_dither_t,
+    pub fn caca_get_canvas_width(cv: *mut caca_canvas_t) -> libc::c_int,
+    pub fn caca_get_canvas_height(cv: *mut caca_canvas_t) -> libc::c_int,
+);
diff --git a/src/api/caca/libcaca.rs b/src/api/caca/libcaca.rs
deleted file mode 100644
index ce2d281..0000000
--- a/src/api/caca/libcaca.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-use libc;
-use std::ffi::CStr;
-use std::mem;
-use api::dlopen;
-
-pub type caca_display_t = libc::c_void;
-pub type caca_canvas_t = libc::c_void;
-pub type caca_dither_t = libc::c_void;
-
-pub struct LibCaca {
-    lib: *mut libc::c_void,
-
-    caca_create_display: unsafe extern fn(*mut caca_canvas_t) -> *mut caca_display_t,
-    caca_free_display: unsafe extern fn(*mut caca_display_t) -> libc::c_int,
-    caca_get_canvas: unsafe extern fn(*mut caca_display_t) -> *mut caca_canvas_t,
-    caca_refresh_display: unsafe extern fn(*mut caca_display_t) -> libc::c_int,
-    caca_dither_bitmap: unsafe extern fn(*mut caca_canvas_t, libc::c_int, libc::c_int, libc::c_int,
-                                         libc::c_int, *const caca_dither_t, *const libc::c_void)
-                                         -> libc::c_int,
-    caca_free_dither: unsafe extern fn(*mut caca_dither_t) -> libc::c_int,
-    caca_create_dither: unsafe extern fn(libc::c_int, libc::c_int, libc::c_int, libc::c_int,
-                                         libc::uint32_t, libc::uint32_t, libc::uint32_t,
-                                         libc::uint32_t) -> *mut caca_dither_t,
-    caca_get_canvas_width: unsafe extern fn(*mut caca_canvas_t) -> libc::c_int,
-    caca_get_canvas_height: unsafe extern fn(*mut caca_canvas_t) -> libc::c_int,
-}
-
-#[derive(Debug)]
-pub struct OpenError {
-    reason: String
-}
-
-impl LibCaca {
-    pub fn open() -> Result<LibCaca, OpenError> {
-        let lib = unsafe { dlopen::dlopen(b"libcaca.so.0\0".as_ptr() as *const _,
-                                          dlopen::RTLD_NOW) };
-
-        if lib.is_null() {
-            let cstr = unsafe { CStr::from_ptr(dlopen::dlerror()) };
-            let reason = String::from_utf8(cstr.to_bytes().to_vec()).unwrap();
-            return Err(OpenError { reason: reason });
-        }
-
-        let caca_create_display = match unsafe { dlopen::dlsym(lib,
-                                        b"caca_create_display\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_create_display".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_free_display = match unsafe { dlopen::dlsym(lib,
-                                      b"caca_free_display\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_free_display".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_get_canvas = match unsafe { dlopen::dlsym(lib,
-                                    b"caca_get_canvas\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_get_canvas".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_refresh_display = match unsafe { dlopen::dlsym(lib,
-                                         b"caca_refresh_display\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_refresh_display".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_dither_bitmap = match unsafe { dlopen::dlsym(lib,
-                                       b"caca_dither_bitmap\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_dither_bitmap".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_free_dither = match unsafe { dlopen::dlsym(lib,
-                                     b"caca_free_dither\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_free_dither".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_create_dither = match unsafe { dlopen::dlsym(lib,
-                                       b"caca_create_dither\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_create_dither".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_get_canvas_width = match unsafe { dlopen::dlsym(lib,
-                                          b"caca_get_canvas_width\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_get_canvas_width".to_string()
-            }),
-            ptr => ptr
-        };
-
-        let caca_get_canvas_height = match unsafe { dlopen::dlsym(lib,
-                                           b"caca_get_canvas_height\0".as_ptr() as *const _) }
-        {
-            ptr if ptr.is_null() => return Err(OpenError {
-                reason: "Could not load caca_get_canvas_height".to_string()
-            }),
-            ptr => ptr
-        };
-
-        Ok(LibCaca {
-            lib: lib,
-
-            caca_create_display: unsafe { mem::transmute(caca_create_display) },
-            caca_free_display: unsafe { mem::transmute(caca_free_display) },
-            caca_get_canvas: unsafe { mem::transmute(caca_get_canvas) },
-            caca_refresh_display: unsafe { mem::transmute(caca_refresh_display) },
-            caca_dither_bitmap: unsafe { mem::transmute(caca_dither_bitmap) },
-            caca_free_dither: unsafe { mem::transmute(caca_free_dither) },
-            caca_create_dither: unsafe { mem::transmute(caca_create_dither) },
-            caca_get_canvas_width: unsafe { mem::transmute(caca_get_canvas_width) },
-            caca_get_canvas_height: unsafe { mem::transmute(caca_get_canvas_height) },
-        })
-    }
-
-    pub unsafe fn caca_create_display(&self, cv: *mut caca_canvas_t) -> *mut caca_display_t {
-        (self.caca_create_display)(cv)
-    }
-
-    pub unsafe fn caca_free_display(&self, dp: *mut caca_display_t) -> libc::c_int {
-        (self.caca_free_display)(dp)
-    }
-
-    pub unsafe fn caca_get_canvas(&self, dp: *mut caca_display_t) -> *mut caca_canvas_t {
-        (self.caca_get_canvas)(dp)
-    }
-
-    pub unsafe fn caca_refresh_display(&self, dp: *mut caca_display_t) -> libc::c_int {
-        (self.caca_refresh_display)(dp)
-    }
-
-    pub unsafe fn caca_dither_bitmap(&self, cv: *mut caca_canvas_t, x: libc::c_int, y: libc::c_int,
-                                     w: libc::c_int, h: libc::c_int, d: *const caca_dither_t,
-                                     pixels: *const libc::c_void) -> libc::c_int
-    {
-        (self.caca_dither_bitmap)(cv, x, y, w, h, d, pixels)
-    }
-
-    pub unsafe fn caca_free_dither(&self, d: *mut caca_dither_t) -> libc::c_int {
-        (self.caca_free_dither)(d)
-    }
-
-    pub unsafe fn caca_create_dither(&self, bpp: libc::c_int, w: libc::c_int, h: libc::c_int,
-                                     pitch: libc::c_int, rmask: libc::uint32_t, gmask: libc::uint32_t,
-                                     bmask: libc::uint32_t, amask: libc::uint32_t) -> *mut caca_dither_t
-    {
-        (self.caca_create_dither)(bpp, w, h, pitch, rmask, gmask, bmask, amask)
-    }
-
-    pub unsafe fn caca_get_canvas_width(&self, cv: *mut caca_canvas_t) -> libc::c_int {
-        (self.caca_get_canvas_width)(cv)
-    }
-
-    pub unsafe fn caca_get_canvas_height(&self, cv: *mut caca_canvas_t) -> libc::c_int {
-        (self.caca_get_canvas_height)(cv)
-    }
-}
-
-impl Drop for LibCaca {
-    fn drop(&mut self) {
-        unsafe { dlopen::dlclose(self.lib); }
-    }
-}
diff --git a/src/api/caca/mod.rs b/src/api/caca/mod.rs
index 6888e49..d8199dd 100644
--- a/src/api/caca/mod.rs
+++ b/src/api/caca/mod.rs
@@ -11,15 +11,16 @@ use CursorState;
 use MouseCursor;
 
 use std::collections::VecDeque;
+use std::path::Path;
 use std::ptr;
 
-mod libcaca;
+mod ffi;
 
 pub struct Window {
-    libcaca: libcaca::LibCaca,
-    display: *mut libcaca::caca_display_t,
+    libcaca: ffi::LibCaca,
+    display: *mut ffi::caca_display_t,
     opengl: OsMesaContext,
-    dither: *mut libcaca::caca_dither_t,
+    dither: *mut ffi::caca_dither_t,
 }
 
 #[derive(Clone)]
@@ -83,12 +84,12 @@ impl Window {
         let opengl = try!(OsMesaContext::new(builder));
         let opengl_dimensions = opengl.get_dimensions();
 
-        let libcaca = match libcaca::LibCaca::open() {
+        let libcaca = match ffi::LibCaca::open(&Path::new("libcaca.so.0")) {
             Err(_) => return Err(CreationError::NotSupported),
             Ok(l) => l
         };
 
-        let display = unsafe { libcaca.caca_create_display(ptr::null_mut()) };
+        let display = unsafe { (libcaca.caca_create_display)(ptr::null_mut()) };
 
         if display.is_null() {
             return Err(CreationError::OsError("caca_create_display failed".to_string()));
@@ -101,14 +102,14 @@ impl Window {
             fn get_masks() -> (u32, u32, u32, u32) { (0xff000000, 0xff0000, 0xff00, 0xff) }
 
             let masks = get_masks();
-            libcaca.caca_create_dither(32, opengl_dimensions.0 as libc::c_int,
-                                       opengl_dimensions.1 as libc::c_int,
-                                       opengl_dimensions.0 as libc::c_int * 4,
-                                       masks.0, masks.1, masks.2, masks.3)
+            (libcaca.caca_create_dither)(32, opengl_dimensions.0 as libc::c_int,
+                                         opengl_dimensions.1 as libc::c_int,
+                                         opengl_dimensions.0 as libc::c_int * 4,
+                                         masks.0, masks.1, masks.2, masks.3)
         };
 
         if dither.is_null() {
-            unsafe { libcaca.caca_free_display(display) };
+            unsafe { (libcaca.caca_free_display)(display) };
             return Err(CreationError::OsError("caca_create_dither failed".to_string()));
         }
 
@@ -182,17 +183,17 @@ impl Window {
 
     pub fn swap_buffers(&self) {
         unsafe {
-            let canvas = self.libcaca.caca_get_canvas(self.display);
-            let width = self.libcaca.caca_get_canvas_width(canvas);
-            let height = self.libcaca.caca_get_canvas_height(canvas);
+            let canvas = (self.libcaca.caca_get_canvas)(self.display);
+            let width = (self.libcaca.caca_get_canvas_width)(canvas);
+            let height = (self.libcaca.caca_get_canvas_height)(canvas);
 
             let buffer = self.opengl.get_framebuffer().chunks(self.opengl.get_dimensions().0 as usize)
                                     .flat_map(|i| i.iter().cloned()).rev().collect::<Vec<u32>>();
 
-            self.libcaca.caca_dither_bitmap(canvas, 0, 0, width as libc::c_int,
-                                            height as libc::c_int, self.dither,
-                                            buffer.as_ptr() as *const _);
-            self.libcaca.caca_refresh_display(self.display);
+            (self.libcaca.caca_dither_bitmap)(canvas, 0, 0, width as libc::c_int,
+                                              height as libc::c_int, self.dither,
+                                              buffer.as_ptr() as *const _);
+            (self.libcaca.caca_refresh_display)(self.display);
         };
     }
 
@@ -234,8 +235,8 @@ impl Window {
 impl Drop for Window {
     fn drop(&mut self) {
         unsafe {
-            self.libcaca.caca_free_dither(self.dither);
-            self.libcaca.caca_free_display(self.display);
+            (self.libcaca.caca_free_dither)(self.dither);
+            (self.libcaca.caca_free_display)(self.display);
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 6583e16..b12b894 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -26,6 +26,9 @@
 #[macro_use]
 extern crate lazy_static;
 
+#[macro_use]
+extern crate shared_library;
+
 extern crate gl_common;
 extern crate libc;