Remove dc_open call

A new context is now created by calling Context::new and therefore you
always have a valid context.  This is much more in Rust style and will
allow a lot of furture simplifications on the context itself.

The FFI layer has not yet been adjusted in this commit and thus will
fail.

src/context.rs

@@ -1,3 +1,6 @@
+use std::ffi::OsString;
+use std::path::PathBuf;
+use std::ptr;
 use std::sync::{Arc, Condvar, Mutex, RwLock};
 
 use crate::chat::*;
@@ -5,6 +8,7 @@ use crate::constants::*;
 use crate::contact::*;
 use crate::dc_receive_imf::*;
 use crate::dc_tools::*;
+use crate::error::*;
 use crate::imap::*;
 use crate::job::*;
 use crate::job_thread::JobThread;
@@ -17,9 +21,21 @@ use crate::smtp::*;
 use crate::sql::Sql;
 use crate::types::*;
 use crate::x::*;
-use std::ptr;
 
-use std::path::PathBuf;
+/// Callback function type for [Context]
+///
+/// # Parameters
+///
+/// * `context` - The context object as returned by [Context::new].
+/// * `event` - One of the [Event] items.
+/// * `data1` - Depends on the event parameter, see [Event].
+/// * `data2` - Depends on the event parameter, see [Event].
+///
+/// # Returns
+///
+/// This callback must return 0 unless stated otherwise in the event
+/// description at [Event].
+pub type ContextCallback = dyn Fn(&Context, Event, uintptr_t, uintptr_t) -> uintptr_t;
 
 pub struct Context {
     pub userdata: *mut libc::c_void,
@@ -34,7 +50,7 @@ pub struct Context {
     pub smtp: Arc<Mutex<Smtp>>,
     pub smtp_state: Arc<(Mutex<SmtpState>, Condvar)>,
     pub oauth2_critical: Arc<Mutex<()>>,
-    pub cb: Option<dc_callback_t>,
+    pub cb: Box<ContextCallback>,
     pub os_name: Option<String>,
     pub cmdline_sel_chat_id: Arc<RwLock<u32>>,
     pub bob: Arc<RwLock<BobStatus>>,
@@ -54,6 +70,84 @@ pub struct RunningState {
 }
 
 impl Context {
+    pub fn new(cb: Box<ContextCallback>, os_name: String, dbfile: PathBuf) -> Result<Context> {
+        let mut blob_fname = OsString::new();
+        blob_fname.push(dbfile.file_name().unwrap_or_default());
+        blob_fname.push("-blobs");
+        let blobdir = dbfile.with_file_name(blob_fname);
+        if !blobdir.exists() {
+            std::fs::create_dir_all(&blobdir)?;
+        }
+        Context::with_blobdir(cb, os_name, dbfile, blobdir)
+    }
+
+    pub fn with_blobdir(
+        cb: Box<ContextCallback>,
+        os_name: String,
+        dbfile: PathBuf,
+        blobdir: PathBuf,
+    ) -> Result<Context> {
+        ensure!(
+            blobdir.is_dir(),
+            "Blobdir does not exist: {}",
+            blobdir.display()
+        );
+        let blobdir_c = blobdir.to_c_string()?;
+        let ctx = Context {
+            blobdir: Arc::new(RwLock::new(unsafe { dc_strdup(blobdir_c.as_ptr()) })),
+            dbfile: Arc::new(RwLock::new(Some(dbfile))),
+            inbox: Arc::new(RwLock::new({
+                Imap::new(
+                    cb_get_config,
+                    cb_set_config,
+                    cb_precheck_imf,
+                    cb_receive_imf,
+                )
+            })),
+            userdata: std::ptr::null_mut(),
+            cb,
+            os_name: Some(os_name),
+            running_state: Arc::new(RwLock::new(Default::default())),
+            sql: Sql::new(),
+            smtp: Arc::new(Mutex::new(Smtp::new())),
+            smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
+            oauth2_critical: Arc::new(Mutex::new(())),
+            bob: Arc::new(RwLock::new(Default::default())),
+            last_smeared_timestamp: Arc::new(RwLock::new(0)),
+            cmdline_sel_chat_id: Arc::new(RwLock::new(0)),
+            sentbox_thread: Arc::new(RwLock::new(JobThread::new(
+                "SENTBOX",
+                "configured_sentbox_folder",
+                Imap::new(
+                    cb_get_config,
+                    cb_set_config,
+                    cb_precheck_imf,
+                    cb_receive_imf,
+                ),
+            ))),
+            mvbox_thread: Arc::new(RwLock::new(JobThread::new(
+                "MVBOX",
+                "configured_mvbox_folder",
+                Imap::new(
+                    cb_get_config,
+                    cb_set_config,
+                    cb_precheck_imf,
+                    cb_receive_imf,
+                ),
+            ))),
+            probe_imap_network: Arc::new(RwLock::new(false)),
+            perform_inbox_jobs_needed: Arc::new(RwLock::new(false)),
+            generating_key_mutex: Mutex::new(()),
+        };
+        if !ctx
+            .sql
+            .open(&ctx, &ctx.dbfile.read().unwrap().as_ref().unwrap(), 0)
+        {
+            return Err(format_err!("Failed opening sqlite database"));
+        }
+        Ok(ctx)
+    }
+
     pub fn has_dbfile(&self) -> bool {
         self.get_dbfile().is_some()
     }
@@ -73,18 +167,24 @@ impl Context {
     }
 
     pub fn call_cb(&self, event: Event, data1: uintptr_t, data2: uintptr_t) -> uintptr_t {
-        if let Some(cb) = self.cb {
-            unsafe { cb(self, event, data1, data2) }
-        } else {
-            0
-        }
+        (*self.cb)(self, event, data1, data2)
     }
 }
 
 impl Drop for Context {
     fn drop(&mut self) {
         unsafe {
-            dc_close(&self);
+            info!(self, "disconnecting INBOX-watch",);
+            self.inbox.read().unwrap().disconnect(self);
+            info!(self, "disconnecting sentbox-thread",);
+            self.sentbox_thread.read().unwrap().imap.disconnect(self);
+            info!(self, "disconnecting mvbox-thread",);
+            self.mvbox_thread.read().unwrap().imap.disconnect(self);
+            info!(self, "disconnecting SMTP");
+            self.smtp.clone().lock().unwrap().disconnect();
+            self.sql.close(self);
+            let blobdir = self.blobdir.write().unwrap();
+            free(*blobdir as *mut libc::c_void);
         }
     }
 }
@@ -114,60 +214,6 @@ pub struct SmtpState {
     pub probe_network: bool,
 }
 
-// create/open/config/information
-pub fn dc_context_new(
-    cb: Option<dc_callback_t>,
-    userdata: *mut libc::c_void,
-    os_name: Option<String>,
-) -> Context {
-    Context {
-        blobdir: Arc::new(RwLock::new(std::ptr::null_mut())),
-        dbfile: Arc::new(RwLock::new(None)),
-        inbox: Arc::new(RwLock::new({
-            Imap::new(
-                cb_get_config,
-                cb_set_config,
-                cb_precheck_imf,
-                cb_receive_imf,
-            )
-        })),
-        userdata,
-        cb,
-        os_name,
-        running_state: Arc::new(RwLock::new(Default::default())),
-        sql: Sql::new(),
-        smtp: Arc::new(Mutex::new(Smtp::new())),
-        smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
-        oauth2_critical: Arc::new(Mutex::new(())),
-        bob: Arc::new(RwLock::new(Default::default())),
-        last_smeared_timestamp: Arc::new(RwLock::new(0)),
-        cmdline_sel_chat_id: Arc::new(RwLock::new(0)),
-        sentbox_thread: Arc::new(RwLock::new(JobThread::new(
-            "SENTBOX",
-            "configured_sentbox_folder",
-            Imap::new(
-                cb_get_config,
-                cb_set_config,
-                cb_precheck_imf,
-                cb_receive_imf,
-            ),
-        ))),
-        mvbox_thread: Arc::new(RwLock::new(JobThread::new(
-            "MVBOX",
-            "configured_mvbox_folder",
-            Imap::new(
-                cb_get_config,
-                cb_set_config,
-                cb_precheck_imf,
-                cb_receive_imf,
-            ),
-        ))),
-        probe_imap_network: Arc::new(RwLock::new(false)),
-        perform_inbox_jobs_needed: Arc::new(RwLock::new(false)),
-        generating_key_mutex: Mutex::new(()),
-    }
-}
-
 unsafe fn cb_receive_imf(
     context: &Context,
     imf_raw_not_terminated: *const libc::c_char,
@@ -251,70 +297,10 @@ fn cb_get_config(context: &Context, key: &str) -> Option<String> {
     context.sql.get_config(context, key)
 }
 
-pub unsafe fn dc_close(context: &Context) {
-    info!(context, "disconnecting INBOX-watch",);
-    context.inbox.read().unwrap().disconnect(context);
-    info!(context, "disconnecting sentbox-thread",);
-    context
-        .sentbox_thread
-        .read()
-        .unwrap()
-        .imap
-        .disconnect(context);
-    info!(context, "disconnecting mvbox-thread",);
-    context
-        .mvbox_thread
-        .read()
-        .unwrap()
-        .imap
-        .disconnect(context);
-
-    info!(context, "disconnecting SMTP");
-    context.smtp.clone().lock().unwrap().disconnect();
-
-    context.sql.close(context);
-    let mut dbfile = context.dbfile.write().unwrap();
-    *dbfile = None;
-    let mut blobdir = context.blobdir.write().unwrap();
-    free(*blobdir as *mut libc::c_void);
-    *blobdir = ptr::null_mut();
-}
-
-pub unsafe fn dc_is_open(context: &Context) -> libc::c_int {
-    context.sql.is_open() as libc::c_int
-}
-
 pub unsafe fn dc_get_userdata(context: &mut Context) -> *mut libc::c_void {
     context.userdata as *mut _
 }
 
-pub unsafe fn dc_open(context: &Context, dbfile: &str, blobdir: Option<&str>) -> bool {
-    let mut success = false;
-    if 0 != dc_is_open(context) {
-        return false;
-    }
-
-    *context.dbfile.write().unwrap() = Some(PathBuf::from(dbfile));
-    let blobdir = blobdir.unwrap_or_default();
-    if !blobdir.is_empty() {
-        let dir = dc_ensure_no_slash_safe(blobdir).strdup();
-        *context.blobdir.write().unwrap() = dir;
-    } else {
-        let dir = dbfile.to_string() + "-blobs";
-        dc_create_folder(context, &dir);
-        *context.blobdir.write().unwrap() = dir.strdup();
-    }
-    // Create/open sqlite database, this may already use the blobdir
-    let dbfile_path = std::path::Path::new(dbfile);
-    if context.sql.open(context, dbfile_path, 0) {
-        success = true
-    }
-    if !success {
-        dc_close(context);
-    }
-    success
-}
-
 pub unsafe fn dc_get_blobdir(context: &Context) -> *mut libc::c_char {
     dc_strdup(*context.blobdir.clone().read().unwrap())
 }
@@ -607,19 +593,59 @@ pub fn do_heuristics_moves(context: &Context, folder: &str, msg_id: u32) {
 mod tests {
     use super::*;
 
+    use crate::test_utils::*;
+
     #[test]
-    fn no_crashes_on_context_deref() {
-        let ctx = dc_context_new(None, std::ptr::null_mut(), Some("Test OS".into()));
-        std::mem::drop(ctx);
+    fn test_wrong_db() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dbfile = tmp.path().join("db.sqlite");
+        std::fs::write(&dbfile, b"123").unwrap();
+        let res = Context::new(Box::new(|_, _, _, _| 0), "FakeOs".into(), dbfile);
+        assert!(res.is_err());
     }
 
     #[test]
-    fn test_context_double_close() {
-        let ctx = dc_context_new(None, std::ptr::null_mut(), None);
-        unsafe {
-            dc_close(&ctx);
-            dc_close(&ctx);
-        }
-        std::mem::drop(ctx);
+    fn test_blobdir_exists() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dbfile = tmp.path().join("db.sqlite");
+        Context::new(Box::new(|_, _, _, _| 0), "FakeOS".into(), dbfile).unwrap();
+        let blobdir = tmp.path().join("db.sqlite-blobs");
+        assert!(blobdir.is_dir());
+    }
+
+    #[test]
+    fn test_wrong_blogdir() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dbfile = tmp.path().join("db.sqlite");
+        let blobdir = tmp.path().join("db.sqlite-blobs");
+        std::fs::write(&blobdir, b"123").unwrap();
+        let res = Context::new(Box::new(|_, _, _, _| 0), "FakeOS".into(), dbfile);
+        assert!(res.is_err());
+    }
+
+    #[test]
+    fn test_sqlite_parent_not_exists() {
+        let tmp = tempfile::tempdir().unwrap();
+        let subdir = tmp.path().join("subdir");
+        let dbfile = subdir.join("db.sqlite");
+        let dbfile2 = dbfile.clone();
+        Context::new(Box::new(|_, _, _, _| 0), "FakeOS".into(), dbfile).unwrap();
+        assert!(subdir.is_dir());
+        assert!(dbfile2.is_file());
+    }
+
+    #[test]
+    fn test_with_blobdir_not_exists() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dbfile = tmp.path().join("db.sqlite");
+        let blobdir = tmp.path().join("blobs");
+        let res = Context::with_blobdir(Box::new(|_, _, _, _| 0), "FakeOS".into(), dbfile, blobdir);
+        assert!(res.is_err());
+    }
+
+    #[test]
+    fn no_crashes_on_context_deref() {
+        let t = dummy_context();
+        std::mem::drop(t.ctx);
     }
 }