Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-05-21 07:46:31 +03:00
Code Issues Packages Projects Releases Wiki Activity

reorganize dc_job_do_DC_JOB_CONFIGURE_IMAP

Browse Source
This commit is contained in:
Simon Laux
2019-08-14 03:12:48 +02:00
committed by holger krekel
parent 906b901e3d
commit 66ab6874f8
1 changed files with 436 additions and 470 deletions
Download Patch File Download Diff File Expand all files Collapse all files

382
src/configure/mod.rs
View File

@@ -1,6 +1,7 @@
use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC}; use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
use crate::constants::Event; use crate::constants::Event;
use crate::constants::DC_CREATE_MVBOX;
use crate::context::Context; use crate::context::Context;
use crate::dc_loginparam::*; use crate::dc_loginparam::*;
use crate::dc_tools::*; use crate::dc_tools::*;
@@ -73,13 +74,12 @@ unsafe fn dc_has_ongoing(context: &Context) -> libc::c_int {
// the other dc_job_do_DC_JOB_*() functions are declared static in the c-file // the other dc_job_do_DC_JOB_*() functions are declared static in the c-file
#[allow(non_snake_case, unused_must_use)] #[allow(non_snake_case, unused_must_use)]
pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) { pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
let flags: libc::c_int;
let mut success = false; let mut success = false;
let mut imap_connected_here = false; let mut imap_connected_here = false;
let mut smtp_connected_here = false; let mut smtp_connected_here = false;
let mut ongoing_allocated_here = false; let mut ongoing_allocated_here = false;
let mut param_autoconfig = None; let mut param_autoconfig: Option<dc_loginparam_t> = None;
if !(0 == dc_alloc_ongoing(context)) { if !(0 == dc_alloc_ongoing(context)) {
ongoing_allocated_here = true; ongoing_allocated_here = true;
if !context.sql.is_open() { if !context.sql.is_open() {
@@ -104,21 +104,47 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
let s_a = context.running_state.clone(); let s_a = context.running_state.clone();
let s = s_a.read().unwrap(); let s = s_a.read().unwrap();
if !s.shall_stop_ongoing { // Variables that are shared between steps:
progress!(context, 1); let mut param: dc_loginparam_t = dc_loginparam_read(context, &context.sql, "");
// need all vars here to be mutable because rust thinks the same step could be called multiple times
// and also initilize, because otherwise rust thinks it's used while unitilized, even if thats not the case as the loop goes only forward
let mut param_domain = "undefined.undefined".to_owned();
let mut param_addr_urlencoded: String =
"Internal Error: this value should never be used".to_owned();
let mut keep_flags = std::i32::MAX;
let mut param = dc_loginparam_read(context, &context.sql, ""); const STEP_3_INDEX: u8 = 13;
let mut step_counter: u8 = 0;
loop {
step_counter = step_counter + 1;
if s.shall_stop_ongoing {
// if step_counter == 3 {
// // Skip Autoconfig? (ok_to_continue 7)
// // But wouldn't it need to reset s.shall_stop_ongoing then, too?
// // It needs to run sth. but fail afterwards anyway, I'm still not sure about this, because the C code doesn't work like this so I guess we should ignore it
// step_counter = STEP_3_INDEX;
// } else {
// break;
// }
break;
}
let success = match step_counter {
// Read login parameters from the database
1 => {
progress!(context, 1);
if param.addr.is_empty() { if param.addr.is_empty() {
error!(context, 0, "Please enter an email address.",); error!(context, 0, "Please enter an email address.",);
} else { }
let ok_to_continue0; !param.addr.is_empty()
}
// Step 1: Load the parameters and check email-address and password
2 => {
if 0 != param.server_flags & 0x2 { if 0 != param.server_flags & 0x2 {
// the used oauth2 addr may differ, check this. // the used oauth2 addr may differ, check this.
// if dc_get_oauth2_addr() is not available in the oauth2 implementation, // if dc_get_oauth2_addr() is not available in the oauth2 implementation,
// just use the given one. // just use the given one.
if s.shall_stop_ongoing {
ok_to_continue0 = false;
} else {
progress!(context, 10); progress!(context, 10);
if let Some(oauth2_addr) = if let Some(oauth2_addr) =
dc_get_oauth2_addr(context, &param.addr, &param.mail_pw) dc_get_oauth2_addr(context, &param.addr, &param.mail_pw)
@@ -130,59 +156,54 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
.set_config(context, "addr", Some(param.addr.as_str())) .set_config(context, "addr", Some(param.addr.as_str()))
.ok(); .ok();
} }
if s.shall_stop_ongoing {
ok_to_continue0 = false;
} else {
progress!(context, 20); progress!(context, 20);
ok_to_continue0 = true;
} }
true // no oauth? - just continue it's no error
} }
} else { 3 => {
ok_to_continue0 = true;
}
if ok_to_continue0 {
let mut ok_to_continue7 = false;
if let Ok(parsed) = param.addr.parse() { if let Ok(parsed) = param.addr.parse() {
let parsed: EmailAddress = parsed; let parsed: EmailAddress = parsed;
let param_domain = parsed.domain; param_domain = parsed.domain;
let param_addr_urlencoded = param_addr_urlencoded =
utf8_percent_encode(&param.addr, NON_ALPHANUMERIC).to_string(); utf8_percent_encode(&param.addr, NON_ALPHANUMERIC).to_string();
true
if !s.shall_stop_ongoing { } else {
error!(context, 0, "Bad email-address.");
false
}
}
// Step 2: Autoconfig
4 => {
progress!(context, 200); progress!(context, 200);
/* 2. Autoconfig
**************************************************************************/
if param.mail_server.is_empty() if param.mail_server.is_empty()
&& param.mail_port == 0 && param.mail_port == 0
/*&&param.mail_user.is_empty() -- the user can enter a loginname which is used by autoconfig then */
&& param.send_server.is_empty() && param.send_server.is_empty()
&& param.send_port == 0 && param.send_port == 0
&& param.send_user.is_empty() && param.send_user.is_empty()
/*&&param.send_pw.is_empty() -- the password cannot be auto-configured and is no criterion for autoconfig or not */
&& param.server_flags & !0x2 == 0 && param.server_flags & !0x2 == 0
{ {
let ok_to_continue1; keep_flags = param.server_flags & 0x2;
/*&&param->mail_user ==NULL -- the user can enter a loginname which is used by autoconfig then */ } else {
/*&&param->send_pw ==NULL -- the password cannot be auto-configured and is no criterion for autoconfig or not */ // Autoconfig is not needed so skip it.
/* flags but OAuth2 avoid autoconfig */ step_counter = STEP_3_INDEX - 1;
let keep_flags = param.server_flags & 0x2; }
true
}
/* A. Search configurations from the domain used in the email-address, prefer encrypted */ /* A. Search configurations from the domain used in the email-address, prefer encrypted */
5 => {
if param_autoconfig.is_none() { if param_autoconfig.is_none() {
let url = format!( let url = format!(
"https://autoconfig.{}/mail/config-v1.1.xml?emailaddress={}", "https://autoconfig.{}/mail/config-v1.1.xml?emailaddress={}",
param_domain, param_domain, param_addr_urlencoded
param_addr_urlencoded
); );
param_autoconfig = moz_autoconfigure(context, &url, &param); param_autoconfig = moz_autoconfigure(context, &url, &param);
if s.shall_stop_ongoing { }
ok_to_continue1 = false; true
} else { }
6 => {
progress!(context, 300); progress!(context, 300);
ok_to_continue1 = true;
}
} else {
ok_to_continue1 = true;
}
if ok_to_continue1 {
let ok_to_continue2;
if param_autoconfig.is_none() { if param_autoconfig.is_none() {
// the doc does not mention `emailaddress=`, however, Thunderbird adds it, see https://releases.mozilla.org/pub/thunderbird/ , which makes some sense // the doc does not mention `emailaddress=`, however, Thunderbird adds it, see https://releases.mozilla.org/pub/thunderbird/ , which makes some sense
let url = format!( let url = format!(
@@ -190,145 +211,93 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
param_domain, param_domain,
param_addr_urlencoded param_addr_urlencoded
); );
param_autoconfig = param_autoconfig = moz_autoconfigure(context, &url, &param);
moz_autoconfigure(context, &url, &param); }
if s.shall_stop_ongoing { true
ok_to_continue2 = false; }
} else { /* Outlook section start ------------- */
/* Outlook uses always SSL but different domains (this comment describes the next two steps) */
7 => {
progress!(context, 310); progress!(context, 310);
ok_to_continue2 = true;
}
} else {
ok_to_continue2 = true;
}
if ok_to_continue2 {
let mut i: libc::c_int = 0;
let ok_to_continue3;
loop {
if !(i <= 1) {
ok_to_continue3 = true;
break;
}
if param_autoconfig.is_none() { if param_autoconfig.is_none() {
/* Outlook uses always SSL but different domains */
let url = format!( let url = format!(
"https://{}{}/autodiscover/autodiscover.xml", "https://{}{}/autodiscover/autodiscover.xml",
if i == 0 { "", param_domain
""
} else {
"autodiscover."
},
param_domain
); );
param_autoconfig = param_autoconfig = outlk_autodiscover(context, &url, &param);
outlk_autodiscover(context, &url, &param);
if s.shall_stop_ongoing {
ok_to_continue3 = false;
break;
} }
progress!(context, 320 + i * 10); true
} }
i += 1 8 => {
progress!(context, 320);
if param_autoconfig.is_none() {
let url = format!(
"https://{}{}/autodiscover/autodiscover.xml",
"autodiscover.", param_domain
);
param_autoconfig = outlk_autodiscover(context, &url, &param);
} }
if ok_to_continue3 { true
let ok_to_continue4; }
/* ----------- Outlook section end */
9 => {
progress!(context, 330);
if param_autoconfig.is_none() { if param_autoconfig.is_none() {
let url = format!( let url = format!(
"http://autoconfig.{}/mail/config-v1.1.xml?emailaddress={}", "http://autoconfig.{}/mail/config-v1.1.xml?emailaddress={}",
param_domain, param_domain, param_addr_urlencoded
param_addr_urlencoded
); );
param_autoconfig = param_autoconfig = moz_autoconfigure(context, &url, &param);
moz_autoconfigure(context, &url, &param); }
true
if s.shall_stop_ongoing { }
ok_to_continue4 = false; 10 => {
} else {
progress!(context, 340); progress!(context, 340);
ok_to_continue4 = true;
}
} else {
ok_to_continue4 = true;
}
if ok_to_continue4 {
let ok_to_continue5;
if param_autoconfig.is_none() { if param_autoconfig.is_none() {
// do not transfer the email-address unencrypted // do not transfer the email-address unencrypted
let url = format!( let url = format!(
"http://{}/.well-known/autoconfig/mail/config-v1.1.xml", "http://{}/.well-known/autoconfig/mail/config-v1.1.xml",
param_domain param_domain
); );
param_autoconfig = moz_autoconfigure( param_autoconfig = moz_autoconfigure(context, &url, &param);
context, &url, &param,
);
if s.shall_stop_ongoing {
ok_to_continue5 = false;
} else {
progress!(context, 350);
ok_to_continue5 = true;
} }
} else { true
ok_to_continue5 = true;
} }
if ok_to_continue5 {
let ok_to_continue6;
/* B. If we have no configuration yet, search configuration in Thunderbird's centeral database */ /* B. If we have no configuration yet, search configuration in Thunderbird's centeral database */
11 => {
progress!(context, 350);
if param_autoconfig.is_none() { if param_autoconfig.is_none() {
/* always SSL for Thunderbird's database */ /* always SSL for Thunderbird's database */
let url = let url =
format!("https://autoconfig.thunderbird.net/v1.1/{}", format!("https://autoconfig.thunderbird.net/v1.1/{}", param_domain);
param_domain param_autoconfig = moz_autoconfigure(context, &url, &param);
); }
param_autoconfig = moz_autoconfigure( true
context, &url, &param, }
); /* C. Do we have any result? */
if s.shall_stop_ongoing { 12 => {
ok_to_continue6 = false;
} else {
progress!(context, 500); progress!(context, 500);
ok_to_continue6 = true; if let Some(ref cfg) = param_autoconfig {
} let r = dc_loginparam_get_readable(cfg);
} else { info!(context, 0, "Got autoconfig: {}", r);
ok_to_continue6 = true;
}
if ok_to_continue6 {
if let Some(ref cfg) = param_autoconfig
{
let r =
dc_loginparam_get_readable(cfg);
info!(
context,
0, "Got autoconfig: {}", r
);
if !cfg.mail_user.is_empty() { if !cfg.mail_user.is_empty() {
param.mail_user = param.mail_user = cfg.mail_user.clone();
cfg.mail_user.clone();
} }
param.mail_server = param.mail_server = cfg.mail_server.clone(); /* all other values are always NULL when entering autoconfig */
cfg.mail_server.clone();
param.mail_port = cfg.mail_port; param.mail_port = cfg.mail_port;
param.send_server = param.send_server = cfg.send_server.clone();
cfg.send_server.clone();
param.send_port = cfg.send_port; param.send_port = cfg.send_port;
param.send_user = param.send_user = cfg.send_user.clone();
cfg.send_user.clone(); param.server_flags = cfg.server_flags;
param.server_flags = /* althoug param_autoconfig's data are no longer needed from, it is important to keep the object as
cfg.server_flags; we may enter "deep guessing" if we could not read a configuration */
} }
param.server_flags |= keep_flags; param.server_flags |= keep_flags;
ok_to_continue7 = true; true
} }
} // Step 3: Fill missing fields with defaults
} 13 => {
} // if you move this, don't forget to update STEP_3_INDEX, too
}
}
}
} else {
ok_to_continue7 = true;
}
if ok_to_continue7 {
if param.mail_server.is_empty() { if param.mail_server.is_empty() {
param.mail_server = format!("imap.{}", param_domain,) param.mail_server = format!("imap.{}", param_domain,)
} }
@@ -345,8 +314,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
if param.send_server.is_empty() && !param.mail_server.is_empty() { if param.send_server.is_empty() && !param.mail_server.is_empty() {
param.send_server = param.mail_server.clone(); param.send_server = param.mail_server.clone();
if param.send_server.starts_with("imap.") { if param.send_server.starts_with("imap.") {
param.send_server = param.send_server = param.send_server.replacen("imap", "smtp", 1);
param.send_server.replacen("imap", "smtp", 1);
} }
} }
if param.send_port == 0 { if param.send_port == 0 {
@@ -368,12 +336,9 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
param.server_flags &= !(0x2 | 0x4); param.server_flags &= !(0x2 | 0x4);
param.server_flags |= 0x4 param.server_flags |= 0x4
} }
if !dc_exactly_one_bit_set( if !dc_exactly_one_bit_set(param.server_flags & (0x100 | 0x200 | 0x400)) {
param.server_flags & (0x100 | 0x200 | 0x400),
) {
param.server_flags &= !(0x100 | 0x200 | 0x400); param.server_flags &= !(0x100 | 0x200 | 0x400);
param.server_flags |= param.server_flags |= if param.send_port == 143 { 0x100 } else { 0x200 }
if param.send_port == 143 { 0x100 } else { 0x200 }
} }
if !dc_exactly_one_bit_set( if !dc_exactly_one_bit_set(
param.server_flags & (0x10000 | 0x20000 | 0x40000), param.server_flags & (0x10000 | 0x20000 | 0x40000),
@@ -398,8 +363,13 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
|| param.send_pw.is_empty() || param.send_pw.is_empty()
|| param.server_flags == 0 || param.server_flags == 0
{ {
error!(context, 0, "Account settings incomplete.",); error!(context, 0, "Account settings incomplete.");
} else if !s.shall_stop_ongoing { false
} else {
true
}
}
14 => {
progress!(context, 600); progress!(context, 600);
/* try to connect to IMAP - if we did not got an autoconfig, /* try to connect to IMAP - if we did not got an autoconfig,
do some further tries with different settings and username variations */ do some further tries with different settings and username variations */
@@ -465,21 +435,23 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
param.mail_port = 993; param.mail_port = 993;
if let Some(at) = param.mail_user.find('@') { if let Some(at) = param.mail_user.find('@') {
param.mail_user = param.mail_user = param.mail_user.split_at(at).0.to_string();
param.mail_user.split_at(at).0.to_string();
} }
if let Some(at) = param.send_user.find('@') { if let Some(at) = param.send_user.find('@') {
param.send_user = param.send_user = param.send_user.split_at(at).0.to_string();
param.send_user.split_at(at).0.to_string();
} }
username_variation += 1 username_variation += 1
} }
if ok_to_continue8 { if ok_to_continue8 {
// success, so we are connected and should disconnect in cleanup
imap_connected_here = true; imap_connected_here = true;
if !s.shall_stop_ongoing { }
ok_to_continue8
}
15 => {
progress!(context, 800); progress!(context, 800);
let ok_to_continue9; let success;
/* try to connect to SMTP - if we did not got an autoconfig, the first try was SSL-465 and we do a second try with STARTTLS-587 */ /* try to connect to SMTP - if we did not got an autoconfig, the first try was SSL-465 and we do a second try with STARTTLS-587 */
if !context if !context
.smtp .smtp
@@ -489,13 +461,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
.connect(context, &param) .connect(context, &param)
{ {
if !param_autoconfig.is_none() { if !param_autoconfig.is_none() {
ok_to_continue9 = false; success = false;
} else if s.shall_stop_ongoing { } else if s.shall_stop_ongoing {
ok_to_continue9 = false; success = false;
} else { } else {
progress!(context, 850); progress!(context, 850);
param.server_flags &= param.server_flags &= !(0x10000 | 0x20000 | 0x40000);
!(0x10000 | 0x20000 | 0x40000);
param.server_flags |= 0x10000; param.server_flags |= 0x10000;
param.send_port = 587; param.send_port = 587;
let r_3 = dc_loginparam_get_readable(&param); let r_3 = dc_loginparam_get_readable(&param);
@@ -509,15 +480,13 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
.connect(context, &param) .connect(context, &param)
{ {
if s.shall_stop_ongoing { if s.shall_stop_ongoing {
ok_to_continue9 = false; success = false;
} else { } else {
progress!(context, 860); progress!(context, 860);
param.server_flags &= param.server_flags &= !(0x10000 | 0x20000 | 0x40000);
!(0x10000 | 0x20000 | 0x40000);
param.server_flags |= 0x10000; param.server_flags |= 0x10000;
param.send_port = 25; param.send_port = 25;
let r_4 = let r_4 = dc_loginparam_get_readable(&param);
dc_loginparam_get_readable(&param);
info!(context, 0, "Trying: {}", r_4); info!(context, 0, "Trying: {}", r_4);
if !context if !context
@@ -527,23 +496,26 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
.unwrap() .unwrap()
.connect(context, &param) .connect(context, &param)
{ {
ok_to_continue9 = false; success = false;
} else { } else {
ok_to_continue9 = true; success = true;
} }
} }
} else { } else {
ok_to_continue9 = true; success = true;
} }
} }
} else { } else {
ok_to_continue9 = true; success = true;
} }
if ok_to_continue9 { if success {
smtp_connected_here = true; smtp_connected_here = true;
if !s.shall_stop_ongoing { }
success
}
16 => {
progress!(context, 900); progress!(context, 900);
flags = if 0 let flags: libc::c_int = if 0
!= context != context
.sql .sql
.get_config_int(context, "mvbox_watch") .get_config_int(context, "mvbox_watch")
@@ -553,55 +525,49 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
.get_config_int(context, "mvbox_move") .get_config_int(context, "mvbox_move")
.unwrap_or_else(|| 1) .unwrap_or_else(|| 1)
{ {
0x1 DC_CREATE_MVBOX as i32
} else { } else {
0 0
}; };
context context
.inbox .inbox
.read() .read()
.unwrap() .unwrap()
.configure_folders(context, flags); .configure_folders(context, flags);
if !s.shall_stop_ongoing { true
}
17 => {
progress!(context, 910); progress!(context, 910);
/* configuration success - write back the configured parameters with the "configured_" prefix; also write the "configured"-flag */
dc_loginparam_write( dc_loginparam_write(
context, context,
&param, &param,
&context.sql, &context.sql,
"configured_", "configured_", /*the trailing underscore is correct*/
); );
context context.sql.set_config_int(context, "configured", 1).ok();
.sql true
.set_config_int( }
context, 18 => {
"configured",
1,
)
.ok();
if !s.shall_stop_ongoing {
progress!(context, 920); progress!(context, 920);
// we generate the keypair just now - we could also postpone this until the first message is sent, however,
// this may result in a unexpected and annoying delay when the user sends his very first message
// (~30 seconds on a Moto G4 play) and might looks as if message sending is always that slow.
e2ee::ensure_secret_key_exists(context); e2ee::ensure_secret_key_exists(context);
success = true; success = true;
info!( info!(context, 0, "Configure completed.");
context,
0, "Configure completed."
);
if !s.shall_stop_ongoing {
progress!(context, 940); progress!(context, 940);
break; // We are done here
} }
_ => {
error!(context, 0, "Internal error: step counter out of bound",);
break;
} }
} };
}
} if !success {
} break;
}
}
}
} else {
error!(context, 0, "Bad email-address.");
}
}
} }
} }
} }