Fix memory leak in error handling

Author: jbaiter

fstwrapper/src/map.rs

@@ -119,16 +119,14 @@ pub extern "C" fn fst_map_get(ctx: *mut Context,
                               -> libc::uint64_t {
     let key = cstr_to_str(key);
     let ctx = mutref_from_ptr!(ctx);
-    ctx.has_error = false;
+    ctx.clear();
     match ref_from_ptr!(ptr).get(key) {
         Some(val) => val,
         None => {
             let msg = str_to_cstr(&format!("Key '{}' not in map.", key));
             ctx.has_error = true;
-            ctx.error_type = str_to_cstr("KeyError");
-            ctx.error_debug = msg;
+            ctx.error_type = str_to_cstr("py::KeyError");
             ctx.error_display = msg;
-            ctx.error_description = msg;
             return 0;
         }
     }
@@ -150,16 +148,14 @@ make_free_fn!(fst_mapvalues_free, *mut map::Values);
 #[no_mangle]
 pub extern "C" fn fst_mapvalues_next(ctx: *mut Context, ptr: *mut map::Values) -> libc::uint64_t {
     let ctx = mutref_from_ptr!(ctx);
-    ctx.has_error = false;
+    ctx.clear();
     match mutref_from_ptr!(ptr).next() {
         Some(val) => val,
         None => {
             let msg = str_to_cstr("No more values.");
             ctx.has_error = true;
             ctx.error_type = str_to_cstr("StopIteration");
-            ctx.error_debug = msg;
             ctx.error_display = msg;
-            ctx.error_description = msg;
             return 0;
         }
     }

fstwrapper/src/util.rs

@@ -13,10 +13,28 @@ use fst::{Levenshtein,Regex};
 /// Exposes information about errors over the ABI
 pub struct Context {
     pub has_error: bool,
-    pub error_type: *const libc::c_char,
-    pub error_debug: *const libc::c_char,
-    pub error_display: *const libc::c_char,
-    pub error_description: *const libc::c_char,
+    pub error_type: *mut libc::c_char,
+    pub error_debug: *mut libc::c_char,
+    pub error_display: *mut libc::c_char,
+    pub error_description: *mut libc::c_char,
+}
+
+impl Context {
+    pub fn clear(&mut self) {
+        self.has_error = false;
+        if !self.error_type.is_null() {
+            fst_string_free(self.error_type);
+        }
+        if !self.error_debug.is_null() {
+            fst_string_free(self.error_debug);
+        }
+        if !self.error_display.is_null() {
+            fst_string_free(self.error_display);
+        }
+        if !self.error_description.is_null() {
+            fst_string_free(self.error_description);
+        }
+    }
 }
 
 
@@ -43,10 +61,10 @@ pub fn get_typename<T>(_: &T) -> &'static str {
 pub extern "C" fn fst_context_new() -> *mut Context {
     to_raw_ptr(Context {
         has_error: false,
-        error_type: ptr::null(),
-        error_description: ptr::null(),
-        error_display: ptr::null(),
-        error_debug: ptr::null(),
+        error_type: ptr::null_mut(),
+        error_description: ptr::null_mut(),
+        error_display: ptr::null_mut(),
+        error_debug: ptr::null_mut(),
     })
 }
 make_free_fn!(fst_context_free, *mut Context);

rust_fst/lib.py

@@ -48,18 +48,25 @@ def find_library():
     'fst::Error::Regex': RegexError,
     'fst::Error::Levenshtein': LevenshteinError,
     'fst::Error::Io': IoError,
+    'py::KeyError': KeyError
 }
 
 
 def checked_call(fn, ctx, *args):
     res = fn(ctx, *args)
     if not ctx.has_error:
         return res
-    msg = ffi.string(ctx.error_display).decode('utf8').replace('\n', ' ')
     type_str = ffi.string(ctx.error_type).decode('utf8')
+    if ctx.error_display != ffi.NULL:
+        msg = ffi.string(ctx.error_display).decode('utf8').replace('\n', ' ')
+    else:
+        msg = None
     err_type = EXCEPTION_MAP.get(type_str)
     if err_type is FstError:
-        desc_str = ffi.string(ctx.error_description).decode('utf8')
+        if ctx.error_description != ffi.NULL:
+            desc_str = ffi.string(ctx.error_description).decode('utf8')
+        else:
+            desc_str = None
         enum_val = re.match(r'(\w+)\(.*?\)', desc_str, re.DOTALL).group(1)
         err_type = EXCEPTION_MAP.get("{}::{}".format(type_str, enum_val))
         if err_type is None: