Merge pull request #10 from tutao/send-documents-2

implement MapiSendDocuments

Author: johnbotris

.github/workflows/test.yml

@@ -13,5 +13,9 @@ jobs:
 
     steps:
       - uses: actions/checkout@v2
+      - name: Check formatting
+        run: cargo fmt -- --check
+      - name: Run lints
+        run: cargo clippy --target "x86_64-pc-windows-msvc" -- -D clippy::all
       - name: Run tests
         run: cargo test --verbose --target "x86_64-pc-windows-msvc"

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mapirs"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["nig <nig@tutao.de>"]
 edition = "2018"
 

Cargo.toml

@@ -17,12 +17,15 @@ fn reg_key() -> io::Result<RegKey> {
     // let subkey_path_release = "SOFTWARE\\450699d2-1c81-5ee5-aec6-08dddb7af9d7"
 
     // the client saves the path to the executable to hklm/software/Clients/Mail/tutanota/EXEPath
+    // or hkcu/software/Clients/Mail/tutanota/EXEPath
     // that key must be there, otherwise windows couldn't have called this DLL because
     // the path to it is next to it under DLLPath.
 
     let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    let subk = "SOFTWARE\\Clients\\Mail\\tutanota";
     // if this fails, the client is not installed correctly or the registry is borked.
-    hklm.open_subkey("SOFTWARE\\Clients\\Mail\\tutanota")
+    hkcu.open_subkey(subk).or_else(|_| hklm.open_subkey(subk))
 }
 
 /// access the registry to try and get
@@ -38,20 +41,32 @@ pub fn client_path() -> io::Result<OsString> {
 #[cfg(not(test))]
 fn log_path() -> io::Result<OsString> {
     let tutanota_key = reg_key()?;
-    tutanota_key.get_value("LOGPath")
+    let log_dir: String = tutanota_key.get_value("LOGPath")?;
+    replace_profile(log_dir)
 }
 
 #[cfg(test)]
 fn log_path() -> io::Result<OsString> {
     Ok(OsString::from("C:\\some\\weird\\path"))
 }
 
+/// replace the %USERPROFILE% placeholder in a String with
+/// the value of the USERPROFILE env variable
+fn replace_profile(val: String) -> io::Result<OsString> {
+    let profile =
+        std::env::var("USERPROFILE").map_err(|_e| io::Error::from(io::ErrorKind::NotFound))?;
+    Ok(OsString::from(
+        val.replace("%USERPROFILE%", profile.as_str()),
+    ))
+}
+
 /// retrieve the configured tmp dir from the registry and
 /// try to ensure the directory is there.
 #[cfg(not(test))]
 pub fn tmp_path() -> io::Result<OsString> {
     let tutanota_key = reg_key()?;
-    let tmp_dir = tutanota_key.get_value("TMPPath")?;
+    let tmp_dir: String = tutanota_key.get_value("TMPPath")?;
+    let tmp_dir = replace_profile(tmp_dir)?;
     fs::create_dir_all(&tmp_dir)?;
     Ok(tmp_dir)
 }
@@ -140,6 +155,8 @@ pub fn current_time_formatted() -> String {
 
 #[cfg(test)]
 mod test {
+    use crate::environment::replace_profile;
+
     #[test]
     fn sha_head_works() {
         use crate::environment::sha_head;
@@ -150,4 +167,19 @@ mod test {
         assert_eq!("e3b0", out);
         assert_eq!(4, out.capacity());
     }
+
+    #[test]
+    fn replace_profile_works() {
+        let var = std::env::var("USERPROFILE");
+        std::env::set_var("USERPROFILE", "C:\\meck");
+        assert_eq!(
+            "C:\\meck\\a\\file.txt",
+            replace_profile("%USERPROFILE%\\a\\file.txt".to_owned()).unwrap()
+        );
+        std::env::remove_var("USERPROFILE");
+        assert!(replace_profile("%USERPROFILE%\\a\\file.txt".to_owned()).is_err());
+        if var.is_ok() {
+            std::env::set_var("USERPROFILE", var.unwrap());
+        }
+    }
 }

licenses.html

@@ -86,3 +86,50 @@ pub fn copy_c_array_to_vec<T: Clone>(ptr: *const T, count: usize) -> Vec<T> {
         slc.to_vec()
     }
 }
+
+/// MapiSendDocuments gets its file paths as a list packed into a string with
+/// a delimiter:
+/// C:\a.txt;C:\b.txt;A:\d.jpg
+pub fn unpack_strings(packed: String, delim: &str) -> Vec<String> {
+    match delim {
+        "" => vec![packed],
+        _ => packed
+            .split(delim)
+            .filter(|s| !s.is_empty())
+            .map(|s| s.to_owned())
+            .collect(),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::ffi::conversion::unpack_strings;
+
+    #[test]
+    fn unpack_strings_works() {
+        let delim = ";";
+        assert_eq!(
+            unpack_strings("A;B;C".to_owned(), delim),
+            vec!["A", "B", "C"]
+        );
+
+        assert_eq!(unpack_strings("".to_owned(), delim), Vec::<String>::new());
+
+        assert_eq!(unpack_strings(";;".to_owned(), delim), Vec::<String>::new());
+
+        assert_eq!(
+            unpack_strings("C:\\a.txt;C:\\b.jpg".to_owned(), ""),
+            vec!["C:\\a.txt;C:\\b.jpg"]
+        );
+
+        assert_eq!(
+            unpack_strings("C:\\a.txt;C:\\b.jpg".to_owned(), "%"),
+            vec!["C:\\a.txt;C:\\b.jpg"]
+        );
+
+        assert_eq!(
+            unpack_strings(";C:\\a.txt;".to_owned(), delim),
+            vec!["C:\\a.txt"]
+        );
+    }
+}

src/environment.rs

@@ -2,6 +2,7 @@ use std::convert::TryFrom;
 
 use crate::commands;
 use crate::commands::send_mail;
+use crate::ffi::conversion::{maybe_string_from_raw_ptr, unpack_strings};
 use crate::flags::{
     MapiAddressFlags, MapiDetailsFlags, MapiFindNextFlags, MapiLogonFlags, MapiReadMailFlags,
     MapiResolveNameFlags, MapiSaveMailFlags, MapiSendMailFlags, MapiStatusCode,
@@ -81,15 +82,35 @@ pub extern "C" fn MAPISendMail(
 pub extern "C" fn MAPISendDocuments(
     _ui_param: ULongPtr,
     // __in LPSTR lpszDelimChar
-    _delim_char: InLpStr,
+    delim_char: InLpStr,
     // __in LPSTR lpszFilePaths
-    _file_paths: InLpStr,
+    file_paths: InLpStr,
     // __in LPSTR lpszFileNames
-    _file_names: InLpStr,
+    file_names: InLpStr,
     _reserved: ULong,
 ) -> MapiStatusCode {
     commands::log_to_file("mapisenddocuments", "");
-    MapiStatusCode::NotSupported
+    // some app may put null as delim if there's only one path
+    let delim = maybe_string_from_raw_ptr(delim_char).unwrap_or_else(|| "".to_owned());
+
+    // spec says if this is empty or null, show sendmail dialog without attachments
+    let packed_paths = maybe_string_from_raw_ptr(file_paths).unwrap_or_else(|| "".to_owned());
+    // spec says if this is empty or null, ignore
+    let packed_names = maybe_string_from_raw_ptr(file_names).unwrap_or_else(|| "".to_owned());
+
+    let paths = unpack_strings(packed_paths, &delim);
+    let names = unpack_strings(packed_names, &delim);
+
+    let msg = Message::from_paths(paths, names);
+
+    commands::log_to_file("mapisenddocument", "parsed documents, sending...");
+    if let Err(e) = send_mail(msg) {
+        commands::log_to_file("mapisenddocument", &format!("could not send mail: {:?}", e));
+        MapiStatusCode::Failure
+    } else {
+        commands::log_to_file("mapisenddocument", "sent message!");
+        MapiStatusCode::Success
+    }
 }
 
 /// https://docs.microsoft.com/en-us/windows/win32/api/mapi/nc-mapi-mapifindnext

src/ffi/conversion.rs

@@ -113,7 +113,6 @@ impl TryFrom<&RawMapiFileDesc> for FileDescriptor {
 }
 
 impl FileDescriptor {
-    #[cfg(test)]
     pub fn new(file_path: &str, file_name: Option<&str>) -> Self {
         Self {
             flags: MapiFileFlags::empty(),

src/ffi/mod.rs

@@ -204,6 +204,34 @@ impl Message {
             files: attach,
         }
     }
+
+    pub fn from_paths(paths: Vec<String>, names: Vec<String>) -> Self {
+        // if we got file names, but not the the same amount as paths, we
+        // will use the file paths as-is
+        let names: Vec<Option<&str>> = if names.is_empty() || names.len() != paths.len() {
+            vec![None; paths.len()]
+        } else {
+            names.iter().map(AsRef::as_ref).map(Some).collect()
+        };
+
+        let files = paths
+            .into_iter()
+            .zip(names.into_iter())
+            .map(|(p, n)| FileDescriptor::new(&p, n))
+            .collect();
+
+        Self {
+            subject: None,
+            note_text: None,
+            message_type: None,
+            date_received: None,
+            conversation_id: None,
+            flags: MapiMessageFlags::empty(),
+            originator: None,
+            recips: vec![],
+            files,
+        }
+    }
 }
 
 #[cfg(test)]

src/structs/file_descriptor.rs

@@ -57,11 +57,23 @@ impl TryFrom<*const RawMapiRecipDesc> for RecipientDescriptor {
 
 impl From<&RawMapiRecipDesc> for RecipientDescriptor {
     fn from(raw: &RawMapiRecipDesc) -> Self {
+        // some applications (Sage50) prefix the mail addresses with SMTP: which is
+        // technically not valid, but we're going to make a best effort to allow this.
+        // ":" is only allowed in quoted local parts so we're not going to destroy
+        // valid mail addresses with this.
+        let address = conversion::maybe_string_from_raw_ptr(raw.address).map(|a| {
+            if a.starts_with("SMTP:") {
+                a.strip_prefix("SMTP:").unwrap().to_owned()
+            } else {
+                a
+            }
+        });
+
         RecipientDescriptor {
             recip_class: raw.recip_class,
             name: conversion::maybe_string_from_raw_ptr(raw.name)
                 .unwrap_or_else(|| "MISSING_RECIP_NAME".to_owned()),
-            address: conversion::maybe_string_from_raw_ptr(raw.address),
+            address,
             entry_id: conversion::copy_c_array_to_vec(raw.entry_id, raw.eid_size as usize),
         }
     }
@@ -78,3 +90,33 @@ impl RecipientDescriptor {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use std::ffi::CStr;
+
+    use crate::structs::{RawMapiRecipDesc, RecipientDescriptor};
+
+    #[test]
+    fn smtp_prefix_is_stripped() {
+        let raw = |a: &str| RawMapiRecipDesc {
+            reserved: 0,
+            recip_class: 0,
+            name: std::ptr::null(),
+            address: CStr::from_bytes_with_nul(a.as_bytes()).unwrap().as_ptr(),
+            eid_size: 0,
+            entry_id: std::ptr::null(),
+        };
+
+        let address1 = raw(&"SMTP:a@b.c\0");
+        let address2 = raw(&"\"SMTP:a\"@b.c\0");
+        assert_eq!(
+            RecipientDescriptor::from(&address1).address,
+            Some("a@b.c".to_owned())
+        );
+        assert_eq!(
+            RecipientDescriptor::from(&address2).address,
+            Some("\"SMTP:a\"@b.c".to_owned())
+        );
+    }
+}