intermediate commit

src/configure/auto_mozilla.rs

@@ -1,10 +1,8 @@
-use libc::free;
 use quick_xml;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText};
 
 use crate::constants::*;
 use crate::context::Context;
-use crate::dc_tools::*;
 use crate::login_param::LoginParam;
 
 use super::read_autoconf_file;
@@ -24,26 +22,28 @@ struct moz_autoconfigure_t<'a> {
     pub tag_config: libc::c_int,
 }
 
-pub unsafe fn moz_autoconfigure(
+pub fn moz_autoconfigure(
     context: &Context,
     url: &str,
     param_in: &LoginParam,
 ) -> Option<LoginParam> {
-    let xml_raw = read_autoconf_file(context, url);
-    if xml_raw.is_null() {
-        return None;
-    }
+    let xml_raw = match read_autoconf_file(context, url) {
+        Err(err) => {
+            info!(context, "can't read file: {}", err);
+            return None;
+        }
+        Ok(content) => content,
+    };
 
     // Split address into local part and domain part.
     let p = param_in.addr.find("@");
     if p.is_none() {
-        free(xml_raw as *mut libc::c_void);
         return None;
     }
     let (in_emaillocalpart, in_emaildomain) = param_in.addr.split_at(p.unwrap());
     let in_emaildomain = &in_emaildomain[1..];
 
-    let mut reader = quick_xml::Reader::from_str(as_str(xml_raw));
+    let mut reader = quick_xml::Reader::from_str(&xml_raw);
     reader.trim_text(true);
 
     let mut buf = Vec::new();
@@ -88,11 +88,9 @@ pub unsafe fn moz_autoconfigure(
     {
         let r = moz_ac.out.to_string();
         warn!(context, "Bad or incomplete autoconfig: {}", r,);
-        free(xml_raw as *mut libc::c_void);
         return None;
     }
 
-    free(xml_raw as *mut libc::c_void);
     Some(moz_ac.out)
 }
 

src/configure/auto_outlook.rs

@@ -1,13 +1,10 @@
-use std::ptr;
-
-use libc::free;
+use std::collections::HashMap;
 use quick_xml;
-use quick_xml::events::{BytesEnd, BytesStart, BytesText};
 
 use crate::constants::*;
 use crate::context::Context;
-use crate::dc_tools::*;
 use crate::login_param::LoginParam;
+use quick_xml::events::{BytesEnd};
 
 use super::read_autoconf_file;
 /* ******************************************************************************
@@ -17,60 +14,52 @@ use super::read_autoconf_file;
 struct outlk_autodiscover_t<'a> {
     pub in_0: &'a LoginParam,
     pub out: LoginParam,
-    pub out_imap_set: libc::c_int,
-    pub out_smtp_set: libc::c_int,
-    pub tag_config: libc::c_int,
-    pub config: [*mut libc::c_char; 6],
+    pub out_imap_set: bool,
+    pub out_smtp_set: bool,
+    pub config: HashMap<String, String>,
 }
 
-pub unsafe fn outlk_autodiscover(
+pub fn outlk_autodiscover(
     context: &Context,
     url__: &str,
     param_in: &LoginParam,
 ) -> Option<LoginParam> {
-    let mut xml_raw: *mut libc::c_char = ptr::null_mut();
-    let mut url = url__.strdup();
+    let mut url = url__.to_string();
     let mut outlk_ad = outlk_autodiscover_t {
         in_0: param_in,
         out: LoginParam::new(),
-        out_imap_set: 0,
-        out_smtp_set: 0,
-        tag_config: 0,
-        config: [ptr::null_mut(); 6],
+        out_imap_set: false,
+        out_smtp_set: false,
+        config: HashMap::new(),
     };
-    let ok_to_continue;
-    let mut i = 0;
-    loop {
-        if i >= 10 {
-            ok_to_continue = true;
-            break;
-        }
-        libc::memset(
-            &mut outlk_ad as *mut outlk_autodiscover_t as *mut libc::c_void,
-            0,
-            ::std::mem::size_of::<outlk_autodiscover_t>(),
-        );
-        xml_raw = read_autoconf_file(context, as_str(url));
-        if xml_raw.is_null() {
-            ok_to_continue = false;
-            break;
+    for i in 0..10 {
+        let xml_raw = read_autoconf_file(context, &url);
+        if xml_raw.is_err() {
+            return Some(outlk_ad.out);
         }
+        let xml_raw = xml_raw.unwrap();
 
-        let mut reader = quick_xml::Reader::from_str(as_str(xml_raw));
+        let mut reader = quick_xml::Reader::from_str(&xml_raw);
         reader.trim_text(true);
 
         let mut buf = Vec::new();
-
+        let current_tag: Option<String> = None;
         loop {
             match reader.read_event(&mut buf) {
                 Ok(quick_xml::events::Event::Start(ref e)) => {
-                    outlk_autodiscover_starttag_cb(e, &mut outlk_ad)
+                    current_tag = Some(String::from_utf8_lossy(e.name()).trim().to_lowercase());
                 }
                 Ok(quick_xml::events::Event::End(ref e)) => {
-                    outlk_autodiscover_endtag_cb(e, &mut outlk_ad)
+                    if "protocol" == String::from_utf8_lossy(e.name()).trim().to_lowercase() {
+                        finish_settings(e, &mut outlk_ad);
+                    }
+                    current_tag = None;
                 }
                 Ok(quick_xml::events::Event::Text(ref e)) => {
-                    outlk_autodiscover_text_cb(e, &mut outlk_ad, &reader)
+                    if let Some(current_tag) = current_tag {
+                        let val = e.unescape_and_decode(&reader).unwrap_or_default();
+                        &outlk_ad.config.insert(current_tag, val);
+                    }
                 }
                 Err(e) => {
                     error!(
@@ -79,134 +68,70 @@ pub unsafe fn outlk_autodiscover(
                         reader.buffer_position(),
                         e
                     );
+                    break;
                 }
                 Ok(quick_xml::events::Event::Eof) => break,
                 _ => (),
             }
             buf.clear();
         }
-
-        if !(!outlk_ad.config[5].is_null()
-            && 0 != *outlk_ad.config[5usize].offset(0isize) as libc::c_int)
-        {
-            ok_to_continue = true;
-            break;
+        if let Some(next_url) = outlk_ad.config.get("redirecturl") {
+            if !next_url.is_empty() {
+                url = next_url.to_string();
+                continue;
+            }
         }
-        free(url as *mut libc::c_void);
-        url = dc_strdup(outlk_ad.config[5usize]);
-
-        outlk_clean_config(&mut outlk_ad);
-        free(xml_raw as *mut libc::c_void);
-        xml_raw = ptr::null_mut();
-        i += 1;
+        break;
     }
 
-    if ok_to_continue {
-        if outlk_ad.out.mail_server.is_empty()
-            || outlk_ad.out.mail_port == 0
-            || outlk_ad.out.send_server.is_empty()
-            || outlk_ad.out.send_port == 0
-        {
-            let r = outlk_ad.out.to_string();
-            warn!(context, "Bad or incomplete autoconfig: {}", r,);
-            free(url as *mut libc::c_void);
-            free(xml_raw as *mut libc::c_void);
-            outlk_clean_config(&mut outlk_ad);
+    if outlk_ad.out.mail_server.is_empty()
+        || outlk_ad.out.mail_port == 0
+        || outlk_ad.out.send_server.is_empty()
+        || outlk_ad.out.send_port == 0
+    {
+        let r = outlk_ad.out.to_string();
+        warn!(context, "Bad or incomplete autoconfig: {}", r,);
 
-            return None;
-        }
+        return None;
     }
-    free(url as *mut libc::c_void);
-    free(xml_raw as *mut libc::c_void);
-    outlk_clean_config(&mut outlk_ad);
     Some(outlk_ad.out)
 }
 
-unsafe fn outlk_clean_config(mut outlk_ad: *mut outlk_autodiscover_t) {
-    for i in 0..6 {
-        free((*outlk_ad).config[i] as *mut libc::c_void);
-        (*outlk_ad).config[i] = ptr::null_mut();
-    }
-}
-
-fn outlk_autodiscover_text_cb<B: std::io::BufRead>(
-    event: &BytesText,
-    outlk_ad: &mut outlk_autodiscover_t,
-    reader: &quick_xml::Reader<B>,
-) {
-    let val = event.unescape_and_decode(reader).unwrap_or_default();
-
-    unsafe {
-        free(outlk_ad.config[outlk_ad.tag_config as usize].cast());
-        outlk_ad.config[outlk_ad.tag_config as usize] = val.trim().strdup();
-    }
-}
-
-unsafe fn outlk_autodiscover_endtag_cb(event: &BytesEnd, outlk_ad: &mut outlk_autodiscover_t) {
-    let tag = String::from_utf8_lossy(event.name()).trim().to_lowercase();
-
-    if tag == "protocol" {
-        if !outlk_ad.config[1].is_null() {
-            let port = dc_atoi_null_is_0(outlk_ad.config[3]);
-            let ssl_on = (!outlk_ad.config[4].is_null()
-                && strcasecmp(
-                    outlk_ad.config[4],
-                    b"on\x00" as *const u8 as *const libc::c_char,
-                ) == 0) as libc::c_int;
-            let ssl_off = (!outlk_ad.config[4].is_null()
-                && strcasecmp(
-                    outlk_ad.config[4],
-                    b"off\x00" as *const u8 as *const libc::c_char,
-                ) == 0) as libc::c_int;
-            if strcasecmp(
-                outlk_ad.config[1],
-                b"imap\x00" as *const u8 as *const libc::c_char,
-            ) == 0
-                && outlk_ad.out_imap_set == 0
-            {
-                outlk_ad.out.mail_server = to_string_lossy(outlk_ad.config[2]);
-                outlk_ad.out.mail_port = port;
-                if 0 != ssl_on {
-                    outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_SSL as i32
-                } else if 0 != ssl_off {
-                    outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_PLAIN as i32
-                }
-                outlk_ad.out_imap_set = 1
-            } else if strcasecmp(
-                outlk_ad.config[1usize],
-                b"smtp\x00" as *const u8 as *const libc::c_char,
-            ) == 0
-                && outlk_ad.out_smtp_set == 0
-            {
-                outlk_ad.out.send_server = to_string_lossy(outlk_ad.config[2]);
-                outlk_ad.out.send_port = port;
-                if 0 != ssl_on {
-                    outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_SSL as i32
-                } else if 0 != ssl_off {
-                    outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_PLAIN as i32
-                }
-                outlk_ad.out_smtp_set = 1
+fn finish_settings(event: &BytesEnd, outlk_ad: &mut outlk_autodiscover_t) {
+    let ssl_on = false;
+    let ssl_off = false;
+    let config = &outlk_ad.config;
+    if let Some(type_val) = &config.get("type") {
+        let port = match config.get("port") {
+            None => 0,
+            Some(r) => {
+                r.parse::<i32>().unwrap_or_default()
             }
+        };
+        if let Some(ssl) = &config.get("ssl") {
+            ssl_on = *ssl == "on";
+            ssl_off = *ssl == "off";
+        }
+        let type_val = *type_val;
+        if !outlk_ad.out_imap_set && type_val == "imap" {
+            outlk_ad.out.mail_server = config.get("server").unwrap_or("".to_string());
+            outlk_ad.out.mail_port = port;
+            if ssl_on {
+                outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_SSL as i32;
+            } else if ssl_off {
+                outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_PLAIN as i32;
+            }
+            outlk_ad.out_imap_set = true;
+        } else if !outlk_ad.out_smtp_set && type_val == "smtp" {
+            outlk_ad.out.send_server = &config.get("server").unwrap_or_default();
+            outlk_ad.out.send_port = port;
+
+            if ssl_on {
+                outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_SSL as i32
+            } else if ssl_off {
+                outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_PLAIN as i32
+            }
+            outlk_ad.out_smtp_set = true;
         }
-        outlk_clean_config(outlk_ad);
     }
-    outlk_ad.tag_config = 0;
-}
-
-fn outlk_autodiscover_starttag_cb(event: &BytesStart, outlk_ad: &mut outlk_autodiscover_t) {
-    let tag = String::from_utf8_lossy(event.name()).trim().to_lowercase();
-
-    if tag == "protocol" {
-        unsafe { outlk_clean_config(outlk_ad) };
-    } else if tag == "type" {
-        outlk_ad.tag_config = 1
-    } else if tag == "server" {
-        outlk_ad.tag_config = 2
-    } else if tag == "port" {
-        outlk_ad.tag_config = 3
-    } else if tag == "ssl" {
-        outlk_ad.tag_config = 4
-    } else if tag == "redirecturl" {
-        outlk_ad.tag_config = 5
-    };
 }

src/configure/mod.rs

@@ -5,6 +5,7 @@ use crate::constants::*;
 use crate::context::Context;
 use crate::dc_tools::*;
 use crate::e2ee;
+use crate::error::*;
 use crate::imap::*;
 use crate::job::*;
 use crate::login_param::LoginParam;
@@ -27,7 +28,7 @@ macro_rules! progress {
 }
 
 // connect
-pub unsafe fn configure(context: &Context) {
+pub fn configure(context: &Context) {
     if dc_has_ongoing(context) {
         warn!(context, "There is already another ongoing process running.",);
         return;
@@ -46,7 +47,7 @@ pub fn dc_is_configured(context: &Context) -> bool {
  ******************************************************************************/
 // the other dc_job_do_DC_JOB_*() functions are declared static in the c-file
 #[allow(non_snake_case, unused_must_use)]
-pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
+pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
     let mut success = false;
     let mut imap_connected_here = false;
     let mut smtp_connected_here = false;
@@ -633,7 +634,7 @@ pub fn dc_stop_ongoing_process(context: &Context) {
     };
 }
 
-pub fn read_autoconf_file(context: &Context, url: &str) -> *mut libc::c_char {
+pub fn read_autoconf_file(context: &Context, url: &str) -> Result<String> {
     info!(context, "Testing {} ...", url);
 
     match reqwest::Client::new()
@@ -641,12 +642,10 @@ pub fn read_autoconf_file(context: &Context, url: &str) -> *mut libc::c_char {
         .send()
         .and_then(|mut res| res.text())
     {
-        Ok(res) => unsafe { res.strdup() },
-        Err(_err) => {
-            info!(context, "Can\'t read file.",);
-
-            std::ptr::null_mut()
+        Err(err) => {
+            bail!("{}", err);
         }
+        Ok(res) => Ok(res.to_string()),
     }
 }
 
@@ -664,8 +663,6 @@ mod tests {
             .set_config(Config::Addr, Some("probably@unexistant.addr"))
             .unwrap();
         t.ctx.set_config(Config::MailPw, Some("123456")).unwrap();
-        unsafe {
-            dc_job_do_DC_JOB_CONFIGURE_IMAP(&t.ctx);
-        }
+        dc_job_do_DC_JOB_CONFIGURE_IMAP(&t.ctx);
     }
 }

src/job.rs

@@ -12,7 +12,7 @@ use crate::dc_tools::*;
 use crate::error::Error;
 use crate::events::Event;
 use crate::imap::*;
-use crate::imex::*;
+use crate::imex::job_do_DC_JOB_IMEX_IMAP;
 use crate::location;
 use crate::login_param::LoginParam;
 use crate::message::{self, Message, MessageState};
@@ -781,13 +781,8 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
                 Action::MarkseenMdnOnImap => job.do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context),
                 Action::MoveMsg => job.do_DC_JOB_MOVE_MSG(context),
                 Action::SendMdn => job.do_DC_JOB_SEND(context),
-                Action::ConfigureImap => unsafe { dc_job_do_DC_JOB_CONFIGURE_IMAP(context) },
-                Action::ImexImap => match job_do_DC_JOB_IMEX_IMAP(context, &job) {
-                    Ok(()) => {}
-                    Err(err) => {
-                        error!(context, "{}", err);
-                    }
-                },
+                Action::ImexImap => job_do_DC_JOB_IMEX_IMAP(context, &job),
+                Action::ConfigureImap => dc_job_do_DC_JOB_CONFIGURE_IMAP(context),
                 Action::MaybeSendLocations => {
                     location::job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context, &job)
                 }