|
|
|
@ -49,6 +49,12 @@ use std::{
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
use futures::{lock::Mutex as FutureMutex, stream::Stream};
|
|
|
|
use futures::{lock::Mutex as FutureMutex, stream::Stream};
|
|
|
|
|
|
|
|
use imap_codec::{
|
|
|
|
|
|
|
|
command::CommandBody,
|
|
|
|
|
|
|
|
core::Literal,
|
|
|
|
|
|
|
|
flag::{Flag as ImapCodecFlag, StoreResponse, StoreType},
|
|
|
|
|
|
|
|
sequence::{SequenceSet, ONE},
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
use crate::{
|
|
|
|
use crate::{
|
|
|
|
backends::{
|
|
|
|
backends::{
|
|
|
|
@ -584,32 +590,18 @@ impl MailBackend for ImapType {
|
|
|
|
.unwrap()
|
|
|
|
.unwrap()
|
|
|
|
.iter()
|
|
|
|
.iter()
|
|
|
|
.any(|cap| cap.eq_ignore_ascii_case(b"LITERAL+"));
|
|
|
|
.any(|cap| cap.eq_ignore_ascii_case(b"LITERAL+"));
|
|
|
|
if has_literal_plus {
|
|
|
|
let data = if has_literal_plus {
|
|
|
|
conn.send_command(
|
|
|
|
Literal::try_from(bytes)?.into_non_sync()
|
|
|
|
format!(
|
|
|
|
|
|
|
|
"APPEND \"{}\" ({}) {{{}+}}",
|
|
|
|
|
|
|
|
&path,
|
|
|
|
|
|
|
|
flags_to_imap_list!(flags),
|
|
|
|
|
|
|
|
bytes.len()
|
|
|
|
|
|
|
|
)
|
|
|
|
|
|
|
|
.as_bytes(),
|
|
|
|
|
|
|
|
)
|
|
|
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
conn.send_command(
|
|
|
|
Literal::try_from(bytes)?
|
|
|
|
format!(
|
|
|
|
};
|
|
|
|
"APPEND \"{}\" ({}) {{{}}}",
|
|
|
|
conn.send_command(CommandBody::append(
|
|
|
|
&path,
|
|
|
|
path,
|
|
|
|
flags_to_imap_list!(flags),
|
|
|
|
flags.derive_imap_codec_flags(),
|
|
|
|
bytes.len()
|
|
|
|
None,
|
|
|
|
)
|
|
|
|
data,
|
|
|
|
.as_bytes(),
|
|
|
|
)?)
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
// wait for "+ Ready for literal data" reply
|
|
|
|
|
|
|
|
conn.wait_for_continuation_request().await?;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
conn.send_literal(&bytes).await?;
|
|
|
|
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
@ -658,36 +650,24 @@ impl MailBackend for ImapType {
|
|
|
|
conn.select_mailbox(source_mailbox_hash, &mut response, false)
|
|
|
|
conn.select_mailbox(source_mailbox_hash, &mut response, false)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
if has_move {
|
|
|
|
if has_move {
|
|
|
|
let command = {
|
|
|
|
conn.send_command(CommandBody::r#move(uids.as_slice(), dest_path, true)?)
|
|
|
|
let mut cmd = format!("UID MOVE {}", uids[0]);
|
|
|
|
.await?;
|
|
|
|
for uid in uids.iter().skip(1) {
|
|
|
|
|
|
|
|
cmd = format!("{},{}", cmd, uid);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
format!("{} \"{}\"", cmd, dest_path)
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
conn.send_command(command.as_bytes()).await?;
|
|
|
|
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
let command = {
|
|
|
|
conn.send_command(CommandBody::copy(uids.as_slice(), dest_path, true)?)
|
|
|
|
let mut cmd = format!("UID COPY {}", uids[0]);
|
|
|
|
.await?;
|
|
|
|
for uid in uids.iter().skip(1) {
|
|
|
|
|
|
|
|
cmd = format!("{},{}", cmd, uid);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
format!("{} \"{}\"", cmd, dest_path)
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
conn.send_command(command.as_bytes()).await?;
|
|
|
|
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
if move_ {
|
|
|
|
if move_ {
|
|
|
|
let command = {
|
|
|
|
conn.send_command(CommandBody::store(
|
|
|
|
let mut cmd = format!("UID STORE {}", uids[0]);
|
|
|
|
uids.as_slice(),
|
|
|
|
for uid in uids.iter().skip(1) {
|
|
|
|
StoreType::Add,
|
|
|
|
cmd = format!("{},{}", cmd, uid);
|
|
|
|
StoreResponse::Answer,
|
|
|
|
}
|
|
|
|
vec![ImapCodecFlag::Deleted],
|
|
|
|
format!("{} +FLAGS (\\Deleted)", cmd)
|
|
|
|
true,
|
|
|
|
};
|
|
|
|
)?)
|
|
|
|
conn.send_command(command.as_bytes()).await?;
|
|
|
|
.await?;
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -782,7 +762,7 @@ impl MailBackend for ImapType {
|
|
|
|
cmd.push(')');
|
|
|
|
cmd.push(')');
|
|
|
|
cmd
|
|
|
|
cmd
|
|
|
|
};
|
|
|
|
};
|
|
|
|
conn.send_command(command.as_bytes()).await?;
|
|
|
|
conn.send_command_raw(command.as_bytes()).await?;
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
if set_seen {
|
|
|
|
if set_seen {
|
|
|
|
@ -847,7 +827,7 @@ impl MailBackend for ImapType {
|
|
|
|
cmd.push(')');
|
|
|
|
cmd.push(')');
|
|
|
|
cmd
|
|
|
|
cmd
|
|
|
|
};
|
|
|
|
};
|
|
|
|
conn.send_command(command.as_bytes()).await?;
|
|
|
|
conn.send_command_raw(command.as_bytes()).await?;
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
if set_unseen {
|
|
|
|
if set_unseen {
|
|
|
|
@ -878,7 +858,7 @@ impl MailBackend for ImapType {
|
|
|
|
flag_future.await?;
|
|
|
|
flag_future.await?;
|
|
|
|
let mut response = Vec::with_capacity(8 * 1024);
|
|
|
|
let mut response = Vec::with_capacity(8 * 1024);
|
|
|
|
let mut conn = connection.lock().await;
|
|
|
|
let mut conn = connection.lock().await;
|
|
|
|
conn.send_command("EXPUNGE".as_bytes()).await?;
|
|
|
|
conn.send_command(CommandBody::Expunge).await?;
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
conn.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
debug!("EXPUNGE response: {}", &String::from_utf8_lossy(&response));
|
|
|
|
debug!("EXPUNGE response: {}", &String::from_utf8_lossy(&response));
|
|
|
|
@ -951,13 +931,13 @@ impl MailBackend for ImapType {
|
|
|
|
conn_lck.unselect().await?;
|
|
|
|
conn_lck.unselect().await?;
|
|
|
|
|
|
|
|
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.send_command(format!("CREATE \"{}\"", path,).as_bytes())
|
|
|
|
.send_command(CommandBody::create(path.as_str())?)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.send_command(format!("SUBSCRIBE \"{}\"", path,).as_bytes())
|
|
|
|
.send_command(CommandBody::subscribe(path.as_str())?)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
@ -1013,7 +993,7 @@ impl MailBackend for ImapType {
|
|
|
|
conn_lck.unselect().await?;
|
|
|
|
conn_lck.unselect().await?;
|
|
|
|
if is_subscribed {
|
|
|
|
if is_subscribed {
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.send_command(format!("UNSUBSCRIBE \"{}\"", &imap_path).as_bytes())
|
|
|
|
.send_command(CommandBody::unsubscribe(imap_path.as_str())?)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
@ -1021,7 +1001,7 @@ impl MailBackend for ImapType {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.send_command(debug!(format!("DELETE \"{}\"", &imap_path,)).as_bytes())
|
|
|
|
.send_command(debug!(CommandBody::delete(imap_path.as_str())?))
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
@ -1050,23 +1030,24 @@ impl MailBackend for ImapType {
|
|
|
|
let uid_store = self.uid_store.clone();
|
|
|
|
let uid_store = self.uid_store.clone();
|
|
|
|
let connection = self.connection.clone();
|
|
|
|
let connection = self.connection.clone();
|
|
|
|
Ok(Box::pin(async move {
|
|
|
|
Ok(Box::pin(async move {
|
|
|
|
let command: String;
|
|
|
|
let imap_path = {
|
|
|
|
{
|
|
|
|
|
|
|
|
let mailboxes = uid_store.mailboxes.lock().await;
|
|
|
|
let mailboxes = uid_store.mailboxes.lock().await;
|
|
|
|
if mailboxes[&mailbox_hash].is_subscribed() == new_val {
|
|
|
|
if mailboxes[&mailbox_hash].is_subscribed() == new_val {
|
|
|
|
return Ok(());
|
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
command = format!("SUBSCRIBE \"{}\"", mailboxes[&mailbox_hash].imap_path());
|
|
|
|
mailboxes[&mailbox_hash].imap_path().to_string()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
let mut response = Vec::with_capacity(8 * 1024);
|
|
|
|
let mut response = Vec::with_capacity(8 * 1024);
|
|
|
|
{
|
|
|
|
{
|
|
|
|
let mut conn_lck = connection.lock().await;
|
|
|
|
let mut conn_lck = connection.lock().await;
|
|
|
|
if new_val {
|
|
|
|
if new_val {
|
|
|
|
conn_lck.send_command(command.as_bytes()).await?;
|
|
|
|
conn_lck
|
|
|
|
|
|
|
|
.send_command(CommandBody::subscribe(imap_path.as_str())?)
|
|
|
|
|
|
|
|
.await?;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.send_command(format!("UN{}", command).as_bytes())
|
|
|
|
.send_command(CommandBody::unsubscribe(imap_path.as_str())?)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
@ -1125,7 +1106,9 @@ impl MailBackend for ImapType {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
{
|
|
|
|
{
|
|
|
|
let mut conn_lck = connection.lock().await;
|
|
|
|
let mut conn_lck = connection.lock().await;
|
|
|
|
conn_lck.send_command(debug!(command).as_bytes()).await?;
|
|
|
|
conn_lck
|
|
|
|
|
|
|
|
.send_command_raw(debug!(command).as_bytes())
|
|
|
|
|
|
|
|
.await?;
|
|
|
|
conn_lck
|
|
|
|
conn_lck
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.read_response(&mut response, RequiredResponses::empty())
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
@ -1191,8 +1174,10 @@ impl MailBackend for ImapType {
|
|
|
|
let mut conn = connection.lock().await;
|
|
|
|
let mut conn = connection.lock().await;
|
|
|
|
conn.examine_mailbox(mailbox_hash, &mut response, false)
|
|
|
|
conn.examine_mailbox(mailbox_hash, &mut response, false)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
conn.send_command(format!("UID SEARCH CHARSET UTF-8 {}", query_str.trim()).as_bytes())
|
|
|
|
conn.send_command_raw(
|
|
|
|
.await?;
|
|
|
|
format!("UID SEARCH CHARSET UTF-8 {}", query_str.trim()).as_bytes(),
|
|
|
|
|
|
|
|
)
|
|
|
|
|
|
|
|
.await?;
|
|
|
|
conn.read_response(&mut response, RequiredResponses::SEARCH)
|
|
|
|
conn.read_response(&mut response, RequiredResponses::SEARCH)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
debug!(
|
|
|
|
debug!(
|
|
|
|
@ -1310,7 +1295,7 @@ impl ImapType {
|
|
|
|
let mut res = Vec::with_capacity(8 * 1024);
|
|
|
|
let mut res = Vec::with_capacity(8 * 1024);
|
|
|
|
futures::executor::block_on(timeout(
|
|
|
|
futures::executor::block_on(timeout(
|
|
|
|
self.server_conf.timeout,
|
|
|
|
self.server_conf.timeout,
|
|
|
|
conn.send_command(b"NOOP"),
|
|
|
|
conn.send_command(CommandBody::Noop),
|
|
|
|
))
|
|
|
|
))
|
|
|
|
.unwrap()
|
|
|
|
.unwrap()
|
|
|
|
.unwrap();
|
|
|
|
.unwrap();
|
|
|
|
@ -1330,7 +1315,7 @@ impl ImapType {
|
|
|
|
Ok(_) => {
|
|
|
|
Ok(_) => {
|
|
|
|
futures::executor::block_on(timeout(
|
|
|
|
futures::executor::block_on(timeout(
|
|
|
|
self.server_conf.timeout,
|
|
|
|
self.server_conf.timeout,
|
|
|
|
conn.send_command(input.as_bytes()),
|
|
|
|
conn.send_command_raw(input.as_bytes()),
|
|
|
|
))
|
|
|
|
))
|
|
|
|
.unwrap()
|
|
|
|
.unwrap()
|
|
|
|
.unwrap();
|
|
|
|
.unwrap();
|
|
|
|
@ -1373,7 +1358,7 @@ impl ImapType {
|
|
|
|
.iter()
|
|
|
|
.iter()
|
|
|
|
.any(|cap| cap.eq_ignore_ascii_case(b"LIST-STATUS"));
|
|
|
|
.any(|cap| cap.eq_ignore_ascii_case(b"LIST-STATUS"));
|
|
|
|
if has_list_status {
|
|
|
|
if has_list_status {
|
|
|
|
conn.send_command(b"LIST \"\" \"*\" RETURN (STATUS (MESSAGES UNSEEN))")
|
|
|
|
conn.send_command_raw(b"LIST \"\" \"*\" RETURN (STATUS (MESSAGES UNSEEN))")
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
conn.read_response(
|
|
|
|
conn.read_response(
|
|
|
|
&mut res,
|
|
|
|
&mut res,
|
|
|
|
@ -1381,7 +1366,7 @@ impl ImapType {
|
|
|
|
)
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
conn.send_command(b"LIST \"\" \"*\"").await?;
|
|
|
|
conn.send_command(CommandBody::list("", "*")?).await?;
|
|
|
|
conn.read_response(&mut res, RequiredResponses::LIST_REQUIRED)
|
|
|
|
conn.read_response(&mut res, RequiredResponses::LIST_REQUIRED)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1433,7 +1418,7 @@ impl ImapType {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mailboxes.retain(|_, v| !v.hash.is_null());
|
|
|
|
mailboxes.retain(|_, v| !v.hash.is_null());
|
|
|
|
conn.send_command(b"LSUB \"\" \"*\"").await?;
|
|
|
|
conn.send_command(CommandBody::lsub("", "*")?).await?;
|
|
|
|
conn.read_response(&mut res, RequiredResponses::LSUB_REQUIRED)
|
|
|
|
conn.read_response(&mut res, RequiredResponses::LSUB_REQUIRED)
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
debug!("LSUB reply: {}", String::from_utf8_lossy(&res));
|
|
|
|
debug!("LSUB reply: {}", String::from_utf8_lossy(&res));
|
|
|
|
@ -1721,20 +1706,20 @@ async fn fetch_hlpr(state: &mut FetchState) -> Result<Vec<Envelope>> {
|
|
|
|
.await?;
|
|
|
|
.await?;
|
|
|
|
if max_uid_left > 0 {
|
|
|
|
if max_uid_left > 0 {
|
|
|
|
debug!("{} max_uid_left= {}", mailbox_hash, max_uid_left);
|
|
|
|
debug!("{} max_uid_left= {}", mailbox_hash, max_uid_left);
|
|
|
|
let command = if max_uid_left == 1 {
|
|
|
|
let sequence_set = if max_uid_left == 1 {
|
|
|
|
"UID FETCH 1 (UID FLAGS ENVELOPE BODY.PEEK[HEADER.FIELDS (REFERENCES)] \
|
|
|
|
SequenceSet::from(ONE)
|
|
|
|
BODYSTRUCTURE)"
|
|
|
|
|
|
|
|
.to_string()
|
|
|
|
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
format!(
|
|
|
|
let min = std::cmp::max(max_uid_left.saturating_sub(chunk_size), 1);
|
|
|
|
"UID FETCH {}:{} (UID FLAGS ENVELOPE BODY.PEEK[HEADER.FIELDS \
|
|
|
|
let max = max_uid_left;
|
|
|
|
(REFERENCES)] BODYSTRUCTURE)",
|
|
|
|
|
|
|
|
std::cmp::max(max_uid_left.saturating_sub(chunk_size), 1),
|
|
|
|
SequenceSet::try_from(min..=max)?
|
|
|
|
max_uid_left
|
|
|
|
|
|
|
|
)
|
|
|
|
|
|
|
|
};
|
|
|
|
};
|
|
|
|
debug!("sending {:?}", &command);
|
|
|
|
conn.send_command(CommandBody::Fetch {
|
|
|
|
conn.send_command(command.as_bytes()).await?;
|
|
|
|
sequence_set,
|
|
|
|
|
|
|
|
attributes: common_attributes(),
|
|
|
|
|
|
|
|
uid: true,
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
.await?;
|
|
|
|
conn.read_response(&mut response, RequiredResponses::FETCH_REQUIRED)
|
|
|
|
conn.read_response(&mut response, RequiredResponses::FETCH_REQUIRED)
|
|
|
|
.await
|
|
|
|
.await
|
|
|
|
.chain_err_summary(|| {
|
|
|
|
.chain_err_summary(|| {
|
|
|
|
|
Damian Poddebniak
1 year ago
committed by
Manos Pitsidianakis