refactor: Move proxy_config out of ConfiguredLoginParam (#6712)

We want to store ConfiguredLoginParam in the database as Json per-login,
but proxy_config should be global for all logins.

src/configure.rs

@@ -432,7 +432,6 @@ async fn get_configured_param(
             .collect(),
         smtp_user: param.smtp.user.clone(),
         smtp_password,
-        proxy_config: ProxyConfig::load(ctx).await?,
         provider,
         certificate_checks: match param.certificate_checks {
             EnteredCertificateChecks::Automatic => ConfiguredCertificateChecks::Automatic,
@@ -454,7 +453,8 @@ async fn configure(ctx: &Context, param: &EnteredLoginParam) -> Result<Configure
     let update_device_chats_handle = task::spawn(async move { ctx2.update_device_chats().await });
 
     let configured_param = get_configured_param(ctx, param).await?;
-    let strict_tls = configured_param.strict_tls();
+    let proxy_config = ProxyConfig::load(ctx).await?;
+    let strict_tls = configured_param.strict_tls(proxy_config.is_some());
 
     progress!(ctx, 550);
 
@@ -464,15 +464,15 @@ async fn configure(ctx: &Context, param: &EnteredLoginParam) -> Result<Configure
     let smtp_param = configured_param.smtp.clone();
     let smtp_password = configured_param.smtp_password.clone();
     let smtp_addr = configured_param.addr.clone();
-    let proxy_config = configured_param.proxy_config.clone();
 
+    let proxy_config2 = proxy_config.clone();
     let smtp_config_task = task::spawn(async move {
         let mut smtp = Smtp::new();
         smtp.connect(
             &context_smtp,
             &smtp_param,
             &smtp_password,
-            &proxy_config,
+            &proxy_config2,
             &smtp_addr,
             strict_tls,
             configured_param.oauth2,
@@ -490,7 +490,7 @@ async fn configure(ctx: &Context, param: &EnteredLoginParam) -> Result<Configure
     let mut imap = Imap::new(
         configured_param.imap.clone(),
         configured_param.imap_password.clone(),
-        configured_param.proxy_config.clone(),
+        proxy_config,
         &configured_param.addr,
         strict_tls,
         configured_param.oauth2,

src/imap.rs

@@ -271,12 +271,14 @@ impl Imap {
         let param = ConfiguredLoginParam::load(context)
             .await?
             .context("Not configured")?;
+        let proxy_config = ProxyConfig::load(context).await?;
+        let strict_tls = param.strict_tls(proxy_config.is_some());
         let imap = Self::new(
             param.imap.clone(),
             param.imap_password.clone(),
-            param.proxy_config.clone(),
+            proxy_config,
             &param.addr,
-            param.strict_tls(),
+            strict_tls,
             param.oauth2,
             idle_interrupt_receiver,
         );

src/login_param.rs

@@ -441,9 +441,6 @@ pub(crate) struct ConfiguredLoginParam {
 
     pub smtp_password: String,
 
-    /// Proxy configuration.
-    pub proxy_config: Option<ProxyConfig>,
-
     pub provider: Option<&'static Provider>,
 
     /// TLS options: whether to allow invalid certificates and/or
@@ -742,8 +739,6 @@ impl ConfiguredLoginParam {
             }];
         }
 
-        let proxy_config = ProxyConfig::load(context).await?;
-
         Ok(Some(ConfiguredLoginParam {
             addr,
             imap,
@@ -754,7 +749,6 @@ impl ConfiguredLoginParam {
             smtp_password: send_pw,
             certificate_checks,
             provider,
-            proxy_config,
             oauth2,
         }))
     }
@@ -837,11 +831,11 @@ impl ConfiguredLoginParam {
         Ok(())
     }
 
-    pub(crate) fn strict_tls(&self) -> bool {
+    pub(crate) fn strict_tls(&self, connected_through_proxy: bool) -> bool {
         let provider_strict_tls = self.provider.map(|provider| provider.opt.strict_tls);
         match self.certificate_checks {
             ConfiguredCertificateChecks::OldAutomatic => {
-                provider_strict_tls.unwrap_or(self.proxy_config.is_some())
+                provider_strict_tls.unwrap_or(connected_through_proxy)
             }
             ConfiguredCertificateChecks::Automatic => provider_strict_tls.unwrap_or(true),
             ConfiguredCertificateChecks::Strict => true,
@@ -962,8 +956,6 @@ mod tests {
             }],
             smtp_user: "".to_string(),
             smtp_password: "bar".to_string(),
-            // proxy_config is not saved by `save_to_database`, using default value
-            proxy_config: None,
             provider: None,
             certificate_checks: ConfiguredCertificateChecks::Strict,
             oauth2: false,
@@ -1066,7 +1058,6 @@ mod tests {
             ],
             smtp_user: "alice@posteo.de".to_string(),
             smtp_password: "foobarbaz".to_string(),
-            proxy_config: None,
             provider: get_provider_by_id("posteo"),
             certificate_checks: ConfiguredCertificateChecks::Strict,
             oauth2: false,

src/smtp.rs

@@ -90,13 +90,14 @@ impl Smtp {
         let lp = ConfiguredLoginParam::load(context)
             .await?
             .context("Not configured")?;
+        let proxy_config = ProxyConfig::load(context).await?;
         self.connect(
             context,
             &lp.smtp,
             &lp.smtp_password,
-            &lp.proxy_config,
+            &proxy_config,
             &lp.addr,
-            lp.strict_tls(),
+            lp.strict_tls(proxy_config.is_some()),
             lp.oauth2,
         )
         .await