valid_email_checker 0.1.0

data/ext/valid_email_checker/vendor/check-if-email-exists/src/mx/mod.rs

@@ -0,0 +1,165 @@
+// check-if-email-exists
+// Copyright (C) 2018-2023 Reacher
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::syntax::SyntaxDetails;
+use crate::util::ser_with_display::ser_with_display;
+use hickory_resolver::error::{ResolveError, ResolveErrorKind};
+use hickory_resolver::lookup::MxLookup;
+use hickory_resolver::system_conf::read_system_conf;
+use hickory_resolver::TokioAsyncResolver;
+use serde::{ser::SerializeMap, Serialize, Serializer};
+use std::io;
+use thiserror::Error;
+
+/// Details about the MX lookup.
+#[derive(Debug)]
+pub struct MxDetails {
+	/// MX lookup of this DNS.
+	pub lookup: Result<MxLookup, ResolveError>,
+}
+
+impl Default for MxDetails {
+	fn default() -> Self {
+		MxDetails {
+			lookup: Err(ResolveError::from("Skipped")),
+		}
+	}
+}
+
+impl From<MxLookup> for MxDetails {
+	fn from(lookup: MxLookup) -> Self {
+		MxDetails { lookup: Ok(lookup) }
+	}
+}
+
+impl Serialize for MxDetails {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let records: Vec<String> = self
+			.lookup
+			.as_ref()
+			.map(|lookup| {
+				lookup
+					.iter()
+					.map(|host| host.exchange().to_string())
+					.collect::<Vec<_>>()
+			})
+			.unwrap_or_else(|_| Vec::new()); // In case of a resolve error, we don't serialize the error.
+
+		let mut map = serializer.serialize_map(Some(2))?;
+		map.serialize_entry("accepts_mail", &!records.is_empty())?;
+		map.serialize_entry("records", &records)?;
+		map.end()
+	}
+}
+
+/// Errors that can happen on MX lookups.
+#[derive(Debug, Error, Serialize)]
+#[serde(tag = "type", content = "message")]
+pub enum MxError {
+	/// Error with IO.
+	#[serde(serialize_with = "ser_with_display")]
+	#[error("IO error: {0}")]
+	IoError(io::Error),
+	/// Error while resolving MX lookups.
+	#[serde(serialize_with = "ser_with_display")]
+	#[error("Resolve error: {0}")]
+	ResolveError(Box<ResolveError>),
+}
+
+impl From<io::Error> for MxError {
+	fn from(e: io::Error) -> Self {
+		MxError::IoError(e)
+	}
+}
+
+impl From<ResolveError> for MxError {
+	fn from(e: ResolveError) -> Self {
+		MxError::ResolveError(Box::new(e))
+	}
+}
+
+/// Make a MX lookup.
+pub async fn check_mx(syntax: &SyntaxDetails) -> Result<MxDetails, MxError> {
+	// Construct a new Resolver with default configuration options
+	let (config, opts) = read_system_conf()?;
+	let resolver = TokioAsyncResolver::tokio(config, opts);
+
+	match resolver.mx_lookup(&syntax.domain).await {
+		Ok(lookup) => Ok(MxDetails::from(lookup)),
+		Err(err) => match err.kind() {
+			// Prefer to return an empty MX lookup if there are no records.
+			ResolveErrorKind::NoRecordsFound { .. } => Ok(MxDetails { lookup: Err(err) }),
+			_ => Err(err.into()),
+		},
+	}
+}
+
+/// Check if the MX host is from Google, i.e. either a @gmail.com address, or
+/// a Google Suite email.
+pub fn is_gmail(mx_host: &str) -> bool {
+	mx_host.to_lowercase().ends_with(".google.com.")
+}
+
+/// Check if a MX host is from outlook (includes @hotmail.*, @outlook.* and
+/// all Microsoft 365 addresses).
+///
+/// After some testing I got:
+/// After some testing, I got:
+/// - *@outlook.com -> `outlook-com.olc.protection.outlook.com.`
+/// - *@outlook.fr -> `eur.olc.protection.outlook.com.`
+/// - *@hotmail.com -> `hotmail-com.olc.protection.outlook.com.`
+/// - *@hotmail.fr -> `eur.olc.protection.outlook.com.`
+/// - *@hotmail.nl -> `eur.olc.protection.outlook.com.`
+///
+/// But Microsoft 365 (B2B) addresses end with "mail.protection.outlook.com."
+///
+/// TL;DR:
+/// - B2C emails -> end with ".olc.protection.outlook.com."
+/// - B2B emails -> end with ".mail.protection.outlook.com."
+pub fn is_hotmail(mx_host: &str) -> bool {
+	mx_host.to_lowercase().ends_with(".protection.outlook.com.")
+}
+
+/// Check if an address is a Hotmail B2B email address.
+pub fn is_hotmail_b2b(mx_host: &str) -> bool {
+	is_hotmail(mx_host) && !mx_host.ends_with(".olc.protection.outlook.com.")
+}
+
+/// Check if an address is a Hotmail B2C email address.
+pub fn is_hotmail_b2c(mx_host: &str) -> bool {
+	is_hotmail(mx_host) && mx_host.ends_with(".olc.protection.outlook.com.")
+}
+
+/// Check if the MX host is behind Mimecast.
+pub fn is_mimecast(mx_host: &str) -> bool {
+	mx_host.to_lowercase().ends_with(".mimecast.com.")
+}
+
+/// Check if the MX host is behind Proofpoint.
+pub fn is_proofpoint(mx_host: &str) -> bool {
+	mx_host.to_lowercase().ends_with(".pphosted.com.") || mx_host.ends_with("ppe-hosted.com.")
+}
+
+/// Check if the MX host is from Yahoo.
+/// Examples:
+/// - mta7.am0.yahoodns.net.
+/// - mx-eu.mail.am0.yahoodns.net.
+pub fn is_yahoo(mx_host: &str) -> bool {
+	mx_host.to_lowercase().ends_with(".yahoodns.net.")
+}

data/ext/valid_email_checker/vendor/check-if-email-exists/src/rules.json

@@ -0,0 +1,28 @@
+{
+	"by_domain": {
+		"gmail.com": { "rules": ["SkipCatchAll"] },
+		"hotmail.com": { "rules": ["SkipCatchAll"] },
+		"hotmail.fr": { "rules": ["SkipCatchAll"] },
+		"hotmail.nl": { "rules": ["SkipCatchAll"] },
+		"yahoo.com": { "rules": ["SkipCatchAll"] },
+		"yahoo.fr": { "rules": ["SkipCatchAll"] }
+	},
+	"by_mx": {
+		"futuresinitiative.org.": { "rules": ["SmtpTimeout45s"] },
+		"mail.digimarcon.com.": { "rules": ["SmtpTimeout45s"] },
+		"mail.glasasoftball.org.": { "rules": ["SmtpTimeout45s"] },
+		"nosotrosorg.com.": { "rules": ["SmtpTimeout45s"] }
+	},
+	"by_mx_suffix": {
+		".antispamcloud.com.": {
+			"rules": ["SmtpTimeout45s", "SkipCatchAll"],
+			"_comment": "Some <RCPT TO> take 30s to respond (sometimes only on 2nd attempt, not deterministic), so we skip the catch-all one, and bump the timeout to well over 30s."
+		}
+	},
+	"rules": {
+		"SkipCatchAll": { "_comment": "Don't perform catch-all check" },
+		"SmtpTimeout45s": {
+			"_comment": "Set SMTP connection timeout to at least 45s. If the user request set an even higher timeout, take that one. Please note that this timeout is **per SMTP connection**. We might try 2 connections per email: if the 1st one failed, then we connect again to avoid potential greylisting, in which case the whole verification takes 1min30s."
+		}
+	}
+}

data/ext/valid_email_checker/vendor/check-if-email-exists/src/rules.rs

@@ -0,0 +1,105 @@
+// check-if-email-exists
+// Copyright (C) 2018-2023 Reacher
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+//! Read provider- and domain-specific rules from a JSON, then match each
+//! email verification to the domain/provider, and translate those rules into
+//! code.
+//!
+//! IMPORTANT: This is still a beta feature, and probably needs refining.
+
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+pub enum Rule {
+	/// Don't perform catch-all check.
+	SkipCatchAll,
+	/// Set the SMTP timeout to 45s.
+	SmtpTimeout45s,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct RulesByDomain {
+	rules: Vec<Rule>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct AllRules {
+	/// Apply rules by domain name, i.e. after the @ symbol.
+	by_domain: HashMap<String, RulesByDomain>,
+	/// Apply rules by the MX host.
+	by_mx: HashMap<String, RulesByDomain>,
+	/// Apply rules by the MX host. Since each domain potentially has multiple
+	/// MX records, we match by their suffix.
+	by_mx_suffix: HashMap<String, RulesByDomain>,
+}
+
+static ALL_RULES: Lazy<AllRules> =
+	Lazy::new(|| serde_json::from_str::<AllRules>(include_str!("rules.json")).unwrap());
+
+fn does_domain_have_rule(domain: &str, rule: &Rule) -> bool {
+	if let Some(v) = ALL_RULES.by_domain.get(domain) {
+		return v.rules.contains(rule);
+	}
+
+	false
+}
+
+fn does_mx_have_rule(host: &str, rule: &Rule) -> bool {
+	if let Some(v) = ALL_RULES.by_mx.get(host) {
+		return v.rules.contains(rule);
+	}
+
+	false
+}
+
+fn does_mx_suffix_have_rule(host: &str, rule: &Rule) -> bool {
+	for (k, v) in ALL_RULES.by_mx_suffix.iter() {
+		if host.ends_with(k) {
+			return v.rules.contains(rule);
+		}
+	}
+
+	false
+}
+
+/// Check if either the domain or the MX host has any given rule.
+pub fn has_rule(domain: &str, host: &str, rule: &Rule) -> bool {
+	does_domain_have_rule(domain, rule)
+		|| does_mx_have_rule(host, rule)
+		|| does_mx_suffix_have_rule(host, rule)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_skip_catch_all() {
+		assert!(has_rule(
+			"gmail.com",
+			"alt4.aspmx.l.google.com.",
+			&Rule::SkipCatchAll
+		));
+
+		assert!(has_rule(
+			"domain.com",
+			".antispamcloud.com.",
+			&Rule::SkipCatchAll
+		))
+	}
+}

data/ext/valid_email_checker/vendor/check-if-email-exists/src/smtp/connect.rs

@@ -0,0 +1,396 @@
+// check-if-email-exists
+// Copyright (C) 2018-2023 Reacher
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use async_recursion::async_recursion;
+use async_smtp::commands::{MailCommand, RcptCommand};
+use async_smtp::extension::ClientId;
+use async_smtp::{SmtpClient, SmtpTransport};
+use fast_socks5::client::Config;
+use fast_socks5::{client::Socks5Stream, Result};
+use rand::rngs::SmallRng;
+use rand::{distributions::Alphanumeric, Rng, SeedableRng};
+use std::iter;
+use std::str::FromStr;
+use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, BufStream};
+use tokio::net::TcpStream;
+
+use super::parser;
+use super::verif_method::VerifMethodSmtp;
+use super::{SmtpDetails, SmtpError};
+use crate::rules::{has_rule, Rule};
+use crate::{EmailAddress, LOG_TARGET};
+
+// Define a new trait that combines AsyncRead, AsyncWrite, and Unpin
+trait AsyncReadWrite: AsyncRead + AsyncWrite + Unpin + Send {}
+impl<T: AsyncRead + AsyncWrite + Unpin + Send> AsyncReadWrite for T {}
+
+/// Try to send an smtp command, close and return Err if fails.
+macro_rules! try_smtp (
+    ($res: expr, $client: ident, $to_email: expr, $host: expr, $port: expr) => ({
+		if let Err(err) = $res {
+			tracing::debug!(
+				target: LOG_TARGET,
+				email=$to_email.to_string(),
+				mx_host=$host,
+				port=$port,
+				error=?err,
+				"Closing connection due to error"
+			);
+			// Try to close the connection, but ignore if there's an error.
+			let _ = $client.quit().await;
+
+			return Err(SmtpError::AsyncSmtpError(err));
+		}
+    })
+);
+
+/// Connect to an SMTP host and return the configured client transport.
+async fn connect_to_smtp_host(
+	to_email: &EmailAddress,
+	mx_host: &str,
+	verif_method: &VerifMethodSmtp,
+) -> Result<SmtpTransport<BufStream<Box<dyn AsyncReadWrite>>>, SmtpError> {
+	// hostname verification fails if it ends with '.', for example, using
+	// SOCKS5 proxies we can `io: incomplete` error.
+	let clean_host = mx_host.trim_end_matches('.').to_string();
+	let smtp_client = SmtpClient::new()
+		.hello_name(ClientId::Domain(verif_method.config.hello_name.to_string()))
+		// Sometimes, using socks5 proxy, we get an `io: incomplete` error
+		// when using pipelining and sending two consecutive RCPT TO commands.
+		.pipelining(false);
+
+	let stream: BufStream<Box<dyn AsyncReadWrite>> = match &verif_method.proxy {
+		Some(proxy) => {
+			let mut config = Config::default();
+			if let Some(timeout_ms) = proxy.timeout_ms {
+				config.set_connect_timeout(timeout_ms / 1000);
+			}
+
+			let socks_stream =
+				if let (Some(username), Some(password)) = (&proxy.username, &proxy.password) {
+					Socks5Stream::connect_with_password(
+						(proxy.host.as_ref(), proxy.port),
+						clean_host.clone(),
+						verif_method.config.smtp_port,
+						username.clone(),
+						password.clone(),
+						config,
+					)
+					.await?
+				} else {
+					Socks5Stream::connect(
+						(proxy.host.as_ref(), proxy.port),
+						clean_host.clone(),
+						verif_method.config.smtp_port,
+						config,
+					)
+					.await?
+				};
+			BufStream::new(Box::new(socks_stream) as Box<dyn AsyncReadWrite>)
+		}
+		None => {
+			let tcp_stream =
+				TcpStream::connect(format!("{}:{}", clean_host, verif_method.config.smtp_port))
+					.await?;
+			BufStream::new(Box::new(tcp_stream) as Box<dyn AsyncReadWrite>)
+		}
+	};
+
+	let mut smtp_transport = SmtpTransport::new(smtp_client, stream).await?;
+
+	// Set "MAIL FROM"
+	let from_email = EmailAddress::from_str(&verif_method.config.from_email).unwrap_or_else(|_| {
+		tracing::warn!(
+			target: LOG_TARGET,
+			from_email=verif_method.config.from_email,
+			"Invalid 'from_email' provided, using default: 'user@example.org'"
+		);
+		EmailAddress::from_str("user@example.org").expect("Default email is valid")
+	});
+	try_smtp!(
+		smtp_transport
+			.get_mut()
+			.command(MailCommand::new(Some(from_email.into_inner()), vec![]))
+			.await,
+		smtp_transport,
+		to_email,
+		clean_host,
+		verif_method.config.smtp_port
+	);
+
+	Ok(smtp_transport)
+}
+
+/// Description of the deliverability information we can gather from
+/// communicating with the SMTP server.
+struct Deliverability {
+	/// Is this email account's inbox full?
+	has_full_inbox: bool,
+	/// Can we send an email to this address?
+	is_deliverable: bool,
+	/// Is the email blocked or disabled by the provider?
+	is_disabled: bool,
+}
+
+/// Checks deliverability of a target email address using the provided SMTP transport.
+async fn check_email_deliverability<S: AsyncBufRead + AsyncWrite + Unpin + Send>(
+	smtp_transport: &mut SmtpTransport<S>,
+	to_email: &EmailAddress,
+) -> Result<Deliverability, SmtpError> {
+	match smtp_transport
+		.get_mut()
+		.command(RcptCommand::new(to_email.clone().into_inner(), vec![]))
+		.await
+	{
+		// According to RFC 5321, `RCPT TO` command succeeds with 250 and
+		// 251 codes only (no 3xx codes at all):
+		// https://tools.ietf.org/html/rfc5321#page-56
+		//
+		// Where the 251 code is used for forwarding, which is not our case,
+		// because we always deliver to the SMTP server hosting the address
+		// itself.
+		//
+		// So, if `response.is_positive()` (which is a condition for
+		// returning `Ok` from the `command()` method above), then delivery
+		// succeeds, accordingly to RFC 5321.
+		Ok(_) => Ok(Deliverability {
+			has_full_inbox: false,
+			is_deliverable: true, // response.is_positive()
+			is_disabled: false,
+		}),
+		Err(err) => {
+			// We cast to lowercase, because our matched strings below are all
+			// lowercase.
+			let err_string = err.to_string().to_lowercase();
+
+			// Check if the email account has been disabled or blocked.
+			if parser::is_disabled_account(&err_string) {
+				return Ok(Deliverability {
+					has_full_inbox: false,
+					is_deliverable: false,
+					is_disabled: true,
+				});
+			}
+
+			// Check if the email account has a full inbox.
+			if parser::is_full_inbox(&err_string) {
+				return Ok(Deliverability {
+					has_full_inbox: true,
+					is_deliverable: false,
+					is_disabled: false,
+				});
+			}
+
+			// Check error messages that say that user can actually receive
+			// emails.
+			// 4.2.1 The user you are trying to contact is receiving mail at a rate that
+			if err_string
+				.contains("the user you are trying to contact is receiving mail at a rate that")
+			{
+				return Ok(Deliverability {
+					has_full_inbox: false,
+					is_deliverable: true,
+					is_disabled: false,
+				});
+			}
+
+			// Check that the mailbox doesn't exist.
+			if parser::is_invalid(&err_string, to_email) {
+				return Ok(Deliverability {
+					has_full_inbox: false,
+					is_deliverable: false,
+					is_disabled: false,
+				});
+			}
+
+			// Return all unparsable errors,.
+			Err(SmtpError::AsyncSmtpError(err))
+		}
+	}
+}
+
+/// Checks if the domain has a catch-all email setup.
+async fn smtp_is_catch_all<S: AsyncBufRead + AsyncWrite + Unpin + Send>(
+	smtp_transport: &mut SmtpTransport<S>,
+	domain: &str,
+	host: &str,
+	to_email: &EmailAddress,
+) -> Result<bool, SmtpError> {
+	if has_rule(domain, host, &Rule::SkipCatchAll) {
+		tracing::debug!(
+			target: LOG_TARGET,
+			email=to_email.to_string(),
+			domain=domain,
+			"Skipping catch-all check"
+		);
+		return Ok(false);
+	}
+
+	// Create a random 15-char alphanumerical string.
+	let mut rng = SmallRng::from_entropy();
+	let random_email: String = iter::repeat_with(|| rng.sample(Alphanumeric))
+		.map(char::from)
+		.take(15)
+		.collect();
+	let random_email = EmailAddress::new(format!("{}@{}", random_email, domain))?;
+
+	check_email_deliverability(smtp_transport, &random_email)
+		.await
+		.map(|result| result.is_deliverable)
+}
+
+/// Creates an SMTP future for email verification.
+async fn create_smtp_future(
+	to_email: &EmailAddress,
+	mx_host: &str,
+	domain: &str,
+	verif_method: &VerifMethodSmtp,
+) -> Result<(bool, Deliverability), SmtpError> {
+	// FIXME If the SMTP is not connectable, we should actually return an
+	// Ok(SmtpDetails { can_connect_smtp: false, ... }).
+	let mut smtp_transport = connect_to_smtp_host(to_email, mx_host, verif_method).await?;
+
+	let is_catch_all = smtp_is_catch_all(&mut smtp_transport, domain, mx_host, to_email)
+		.await
+		.unwrap_or(false);
+	let deliverability = if is_catch_all {
+		Deliverability {
+			has_full_inbox: false,
+			is_deliverable: true,
+			is_disabled: false,
+		}
+	} else {
+		let mut result = check_email_deliverability(&mut smtp_transport, to_email).await;
+
+		// Some SMTP servers automatically close the connection after an error,
+		// so we should reconnect to perform a next command.
+		//
+		// Unfortunately `smtp_transport.is_connected()` doesn't report about this,
+		// so we can only check for "io: incomplete" SMTP error being returned.
+		// https://github.com/async-email/async-smtp/issues/37
+		if let Err(e) = &result {
+			if parser::is_err_io_errors(e) {
+				tracing::debug!(
+					target: LOG_TARGET,
+					email=to_email.to_string(),
+					error=?e,
+					"Got `io: incomplete` error, reconnecting"
+				);
+
+				let _ = smtp_transport.quit().await;
+				smtp_transport = connect_to_smtp_host(to_email, mx_host, verif_method).await?;
+				result = check_email_deliverability(&mut smtp_transport, to_email).await;
+			}
+		}
+
+		result?
+	};
+
+	smtp_transport
+		.quit()
+		.await
+		.map_err(SmtpError::AsyncSmtpError)?;
+
+	Ok((is_catch_all, deliverability))
+}
+
+/// Get all email details we can from one single `EmailAddress`, without
+/// retries.
+async fn check_smtp_without_retry(
+	to_email: &EmailAddress,
+	mx_host: &str,
+	domain: &str,
+	verif_method: &VerifMethodSmtp,
+) -> Result<SmtpDetails, SmtpError> {
+	let fut = create_smtp_future(to_email, mx_host, domain, verif_method);
+
+	let (is_catch_all, deliverability) = match verif_method.config.smtp_timeout {
+		Some(smtp_timeout) => {
+			let timeout = tokio::time::timeout(smtp_timeout, fut);
+
+			match timeout.await {
+				Ok(result) => result?,
+				Err(_) => return Err(SmtpError::Timeout(smtp_timeout)),
+			}
+		}
+		None => fut.await?,
+	};
+
+	Ok(SmtpDetails {
+		can_connect_smtp: true,
+		has_full_inbox: deliverability.has_full_inbox,
+		is_catch_all,
+		is_deliverable: deliverability.is_deliverable,
+		is_disabled: deliverability.is_disabled,
+	})
+}
+
+/// Get all email details we can from one single `EmailAddress`.
+/// Retry the SMTP connection on error, in particular to avoid greylisting.
+#[async_recursion]
+pub async fn check_smtp_with_retry(
+	to_email: &EmailAddress,
+	mx_host: &str,
+	domain: &str,
+	verif_method: &VerifMethodSmtp,
+	// Number of remaining retries.
+	count: usize,
+) -> Result<SmtpDetails, SmtpError> {
+	tracing::debug!(
+		target: LOG_TARGET,
+		email=to_email.to_string(),
+		attempt=verif_method.config.retries - count + 1,
+		mx_host=mx_host,
+		port=verif_method.config.smtp_port,
+		using_proxy=verif_method.proxy.is_some(),
+		"Check SMTP"
+	);
+
+	let result = check_smtp_without_retry(to_email, mx_host, domain, verif_method).await;
+
+	tracing::debug!(
+		target: LOG_TARGET,
+		email=to_email.to_string(),
+		attempt=verif_method.config.retries - count + 1,
+		mx_host=mx_host,
+		port=verif_method.config.smtp_port,
+		result=?result,
+		"Got SMTP check result"
+	);
+
+	match &result {
+		// Don't retry if we used Hotmail or Yahoo API. This two options should
+		// be non-callable, as this function only deals with actual SMTP
+		// connection errors.
+		Err(SmtpError::HeadlessError(_)) => result,
+		Err(SmtpError::YahooError(_)) => result,
+		Err(SmtpError::GmailError(_)) => result,
+		// Only retry if the SMTP error was unknown.
+		Err(err) if err.get_description().is_none() => {
+			if count <= 1 {
+				result
+			} else {
+				tracing::debug!(
+					target: LOG_TARGET,
+					email=to_email.to_string(),
+					"Potential greylisting detected, retrying"
+				);
+				check_smtp_with_retry(to_email, mx_host, domain, verif_method, count - 1).await
+			}
+		}
+		_ => result,
+	}
+}