1use std::collections::BTreeSet;
4use std::collections::HashSet;
5use std::path::{Path, PathBuf};
6use std::str;
7
8use anyhow::{Context as _, Result, ensure, format_err};
9use deltachat_contact_tools::{VcardContact, parse_vcard};
10use deltachat_derive::{FromSql, ToSql};
11use serde::{Deserialize, Serialize};
12use tokio::{fs, io};
13
14use crate::blob::BlobObject;
15use crate::chat::{Chat, ChatId, ChatIdBlocked, ChatVisibility, send_msg};
16use crate::chatlist_events;
17use crate::config::Config;
18use crate::constants::{
19 Blocked, Chattype, DC_CHAT_ID_TRASH, DC_MSG_ID_LAST_SPECIAL, VideochatType,
20};
21use crate::contact::{self, Contact, ContactId};
22use crate::context::Context;
23use crate::debug_logging::set_debug_logging_xdc;
24use crate::download::DownloadState;
25use crate::ephemeral::{Timer as EphemeralTimer, start_ephemeral_timers_msgids};
26use crate::events::EventType;
27use crate::imap::markseen_on_imap_table;
28use crate::location::delete_poi_location;
29use crate::log::{error, info, warn};
30use crate::mimeparser::{SystemMessage, parse_message_id};
31use crate::param::{Param, Params};
32use crate::pgp::split_armored_data;
33use crate::reaction::get_msg_reactions;
34use crate::sql;
35use crate::summary::Summary;
36use crate::sync::SyncData;
37use crate::tools::create_outgoing_rfc724_mid;
38use crate::tools::{
39 buf_compress, buf_decompress, get_filebytes, get_filemeta, gm2local_offset, read_file,
40 sanitize_filename, time, timestamp_to_str,
41};
42
43#[derive(
49 Debug, Copy, Clone, Default, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize,
50)]
51pub struct MsgId(u32);
52
53impl MsgId {
54 pub fn new(id: u32) -> MsgId {
56 MsgId(id)
57 }
58
59 pub fn new_unset() -> MsgId {
61 MsgId(0)
62 }
63
64 pub fn is_special(self) -> bool {
68 self.0 <= DC_MSG_ID_LAST_SPECIAL
69 }
70
71 pub fn is_unset(self) -> bool {
81 self.0 == 0
82 }
83
84 pub async fn get_state(self, context: &Context) -> Result<MessageState> {
86 let result = context
87 .sql
88 .query_row_optional(
89 concat!(
90 "SELECT m.state, mdns.msg_id",
91 " FROM msgs m LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id",
92 " WHERE id=?",
93 " LIMIT 1",
94 ),
95 (self,),
96 |row| {
97 let state: MessageState = row.get(0)?;
98 let mdn_msg_id: Option<MsgId> = row.get(1)?;
99 Ok(state.with_mdns(mdn_msg_id.is_some()))
100 },
101 )
102 .await?
103 .unwrap_or_default();
104 Ok(result)
105 }
106
107 pub(crate) async fn get_param(self, context: &Context) -> Result<Params> {
108 let res: Option<String> = context
109 .sql
110 .query_get_value("SELECT param FROM msgs WHERE id=?", (self,))
111 .await?;
112 Ok(res
113 .map(|s| s.parse().unwrap_or_default())
114 .unwrap_or_default())
115 }
116
117 pub(crate) async fn trash(self, context: &Context, on_server: bool) -> Result<()> {
129 context
130 .sql
131 .execute(
132 "INSERT OR REPLACE INTO msgs (id, rfc724_mid, timestamp, chat_id, deleted)
136 SELECT ?1, rfc724_mid, timestamp, ?, ? FROM msgs WHERE id=?1",
137 (self, DC_CHAT_ID_TRASH, on_server),
138 )
139 .await?;
140
141 Ok(())
142 }
143
144 pub(crate) async fn set_delivered(self, context: &Context) -> Result<()> {
145 update_msg_state(context, self, MessageState::OutDelivered).await?;
146 let chat_id: Option<ChatId> = context
147 .sql
148 .query_get_value("SELECT chat_id FROM msgs WHERE id=?", (self,))
149 .await?;
150 context.emit_event(EventType::MsgDelivered {
151 chat_id: chat_id.unwrap_or_default(),
152 msg_id: self,
153 });
154 if let Some(chat_id) = chat_id {
155 chatlist_events::emit_chatlist_item_changed(context, chat_id);
156 }
157 Ok(())
158 }
159
160 pub fn to_u32(self) -> u32 {
165 self.0
166 }
167
168 pub async fn get_info_server_urls(
170 context: &Context,
171 rfc724_mid: String,
172 ) -> Result<Vec<String>> {
173 context
174 .sql
175 .query_map(
176 "SELECT folder, uid FROM imap WHERE rfc724_mid=?",
177 (rfc724_mid,),
178 |row| {
179 let folder: String = row.get("folder")?;
180 let uid: u32 = row.get("uid")?;
181 Ok(format!("</{folder}/;UID={uid}>"))
182 },
183 |rows| {
184 rows.collect::<std::result::Result<Vec<_>, _>>()
185 .map_err(Into::into)
186 },
187 )
188 .await
189 }
190
191 pub async fn hop_info(self, context: &Context) -> Result<String> {
193 let hop_info = context
194 .sql
195 .query_get_value("SELECT IFNULL(hop_info, '') FROM msgs WHERE id=?", (self,))
196 .await?
197 .with_context(|| format!("Message {self} not found"))?;
198 Ok(hop_info)
199 }
200
201 pub async fn get_info(self, context: &Context) -> Result<String> {
203 let msg = Message::load_from_db(context, self).await?;
204
205 let mut ret = String::new();
206
207 let fts = timestamp_to_str(msg.get_timestamp());
208 ret += &format!("Sent: {fts}");
209
210 let from_contact = Contact::get_by_id(context, msg.from_id).await?;
211 let name = from_contact.get_name_n_addr();
212 if let Some(override_sender_name) = msg.get_override_sender_name() {
213 let addr = from_contact.get_addr();
214 ret += &format!(" by ~{override_sender_name} ({addr})");
215 } else {
216 ret += &format!(" by {name}");
217 }
218 ret += "\n";
219
220 if msg.from_id != ContactId::SELF {
221 let s = timestamp_to_str(if 0 != msg.timestamp_rcvd {
222 msg.timestamp_rcvd
223 } else {
224 msg.timestamp_sort
225 });
226 ret += &format!("Received: {}", &s);
227 ret += "\n";
228 }
229
230 if let EphemeralTimer::Enabled { duration } = msg.ephemeral_timer {
231 ret += &format!("Ephemeral timer: {duration}\n");
232 }
233
234 if msg.ephemeral_timestamp != 0 {
235 ret += &format!("Expires: {}\n", timestamp_to_str(msg.ephemeral_timestamp));
236 }
237
238 if msg.from_id == ContactId::INFO || msg.to_id == ContactId::INFO {
239 return Ok(ret);
241 }
242
243 if let Ok(rows) = context
244 .sql
245 .query_map(
246 "SELECT contact_id, timestamp_sent FROM msgs_mdns WHERE msg_id=?",
247 (self,),
248 |row| {
249 let contact_id: ContactId = row.get(0)?;
250 let ts: i64 = row.get(1)?;
251 Ok((contact_id, ts))
252 },
253 |rows| rows.collect::<Result<Vec<_>, _>>().map_err(Into::into),
254 )
255 .await
256 {
257 for (contact_id, ts) in rows {
258 let fts = timestamp_to_str(ts);
259 ret += &format!("Read: {fts}");
260
261 let name = Contact::get_by_id(context, contact_id)
262 .await
263 .map(|contact| contact.get_name_n_addr())
264 .unwrap_or_default();
265
266 ret += &format!(" by {name}");
267 ret += "\n";
268 }
269 }
270
271 ret += &format!("State: {}", msg.state);
272
273 if msg.has_location() {
274 ret += ", Location sent";
275 }
276
277 if 0 != msg.param.get_int(Param::GuaranteeE2ee).unwrap_or_default() {
278 ret += ", Encrypted";
279 }
280
281 ret += "\n";
282
283 let reactions = get_msg_reactions(context, self).await?;
284 if !reactions.is_empty() {
285 ret += &format!("Reactions: {reactions}\n");
286 }
287
288 if let Some(error) = msg.error.as_ref() {
289 ret += &format!("Error: {error}");
290 }
291
292 if let Some(path) = msg.get_file(context) {
293 let bytes = get_filebytes(context, &path).await?;
294 ret += &format!(
295 "\nFile: {}, name: {}, {} bytes\n",
296 path.display(),
297 msg.get_filename().unwrap_or_default(),
298 bytes
299 );
300 }
301
302 if msg.viewtype != Viewtype::Text {
303 ret += "Type: ";
304 ret += &format!("{}", msg.viewtype);
305 ret += "\n";
306 ret += &format!("Mimetype: {}\n", &msg.get_filemime().unwrap_or_default());
307 }
308 let w = msg.param.get_int(Param::Width).unwrap_or_default();
309 let h = msg.param.get_int(Param::Height).unwrap_or_default();
310 if w != 0 || h != 0 {
311 ret += &format!("Dimension: {w} x {h}\n",);
312 }
313 let duration = msg.param.get_int(Param::Duration).unwrap_or_default();
314 if duration != 0 {
315 ret += &format!("Duration: {duration} ms\n",);
316 }
317 if !msg.rfc724_mid.is_empty() {
318 ret += &format!("\nMessage-ID: {}", msg.rfc724_mid);
319
320 let server_urls = Self::get_info_server_urls(context, msg.rfc724_mid).await?;
321 for server_url in server_urls {
322 ret += &format!("\nServer-URL: {server_url}");
324 }
325 }
326 let hop_info = self.hop_info(context).await?;
327
328 ret += "\n\n";
329 if hop_info.is_empty() {
330 ret += "No Hop Info";
331 } else {
332 ret += &hop_info;
333 }
334
335 Ok(ret)
336 }
337}
338
339impl std::fmt::Display for MsgId {
340 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
341 write!(f, "Msg#{}", self.0)
342 }
343}
344
345impl rusqlite::types::ToSql for MsgId {
354 fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>> {
355 if self.0 <= DC_MSG_ID_LAST_SPECIAL {
356 return Err(rusqlite::Error::ToSqlConversionFailure(
357 format_err!("Invalid MsgId {}", self.0).into(),
358 ));
359 }
360 let val = rusqlite::types::Value::Integer(i64::from(self.0));
361 let out = rusqlite::types::ToSqlOutput::Owned(val);
362 Ok(out)
363 }
364}
365
366impl rusqlite::types::FromSql for MsgId {
368 fn column_result(value: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
369 i64::column_result(value).and_then(|val| {
371 if 0 <= val && val <= i64::from(u32::MAX) {
372 Ok(MsgId::new(val as u32))
373 } else {
374 Err(rusqlite::types::FromSqlError::OutOfRange(val))
375 }
376 })
377 }
378}
379
380#[derive(
381 Debug,
382 Copy,
383 Clone,
384 PartialEq,
385 FromPrimitive,
386 ToPrimitive,
387 FromSql,
388 ToSql,
389 Serialize,
390 Deserialize,
391)]
392#[repr(u8)]
393pub(crate) enum MessengerMessage {
394 No = 0,
395 Yes = 1,
396
397 Reply = 2,
399}
400
401impl Default for MessengerMessage {
402 fn default() -> Self {
403 Self::No
404 }
405}
406
407#[derive(Debug, Clone, Default, Serialize, Deserialize)]
411pub struct Message {
412 pub(crate) id: MsgId,
414
415 pub(crate) from_id: ContactId,
417
418 pub(crate) to_id: ContactId,
420
421 pub(crate) chat_id: ChatId,
423
424 pub(crate) viewtype: Viewtype,
426
427 pub(crate) state: MessageState,
429 pub(crate) download_state: DownloadState,
430
431 pub(crate) hidden: bool,
433 pub(crate) timestamp_sort: i64,
434 pub(crate) timestamp_sent: i64,
435 pub(crate) timestamp_rcvd: i64,
436 pub(crate) ephemeral_timer: EphemeralTimer,
437 pub(crate) ephemeral_timestamp: i64,
438 pub(crate) text: String,
439
440 pub(crate) subject: String,
444
445 pub(crate) rfc724_mid: String,
447
448 pub(crate) in_reply_to: Option<String>,
450 pub(crate) is_dc_message: MessengerMessage,
451 pub(crate) original_msg_id: MsgId,
452 pub(crate) mime_modified: bool,
453 pub(crate) chat_blocked: Blocked,
454 pub(crate) location_id: u32,
455 pub(crate) error: Option<String>,
456 pub(crate) param: Params,
457}
458
459impl Message {
460 pub fn new(viewtype: Viewtype) -> Self {
462 Message {
463 viewtype,
464 rfc724_mid: create_outgoing_rfc724_mid(),
465 ..Default::default()
466 }
467 }
468
469 pub fn new_text(text: String) -> Self {
471 Message {
472 viewtype: Viewtype::Text,
473 text,
474 rfc724_mid: create_outgoing_rfc724_mid(),
475 ..Default::default()
476 }
477 }
478
479 pub async fn load_from_db(context: &Context, id: MsgId) -> Result<Message> {
483 let message = Self::load_from_db_optional(context, id)
484 .await?
485 .with_context(|| format!("Message {id} does not exist"))?;
486 Ok(message)
487 }
488
489 pub async fn load_from_db_optional(context: &Context, id: MsgId) -> Result<Option<Message>> {
493 ensure!(
494 !id.is_special(),
495 "Can not load special message ID {} from DB",
496 id
497 );
498 let msg = context
499 .sql
500 .query_row_optional(
501 concat!(
502 "SELECT",
503 " m.id AS id,",
504 " rfc724_mid AS rfc724mid,",
505 " m.mime_in_reply_to AS mime_in_reply_to,",
506 " m.chat_id AS chat_id,",
507 " m.from_id AS from_id,",
508 " m.to_id AS to_id,",
509 " m.timestamp AS timestamp,",
510 " m.timestamp_sent AS timestamp_sent,",
511 " m.timestamp_rcvd AS timestamp_rcvd,",
512 " m.ephemeral_timer AS ephemeral_timer,",
513 " m.ephemeral_timestamp AS ephemeral_timestamp,",
514 " m.type AS type,",
515 " m.state AS state,",
516 " mdns.msg_id AS mdn_msg_id,",
517 " m.download_state AS download_state,",
518 " m.error AS error,",
519 " m.msgrmsg AS msgrmsg,",
520 " m.starred AS original_msg_id,",
521 " m.mime_modified AS mime_modified,",
522 " m.txt AS txt,",
523 " m.subject AS subject,",
524 " m.param AS param,",
525 " m.hidden AS hidden,",
526 " m.location_id AS location,",
527 " c.blocked AS blocked",
528 " FROM msgs m",
529 " LEFT JOIN chats c ON c.id=m.chat_id",
530 " LEFT JOIN msgs_mdns mdns ON mdns.msg_id=m.id",
531 " WHERE m.id=? AND chat_id!=3",
532 " LIMIT 1",
533 ),
534 (id,),
535 |row| {
536 let state: MessageState = row.get("state")?;
537 let mdn_msg_id: Option<MsgId> = row.get("mdn_msg_id")?;
538 let text = match row.get_ref("txt")? {
539 rusqlite::types::ValueRef::Text(buf) => {
540 match String::from_utf8(buf.to_vec()) {
541 Ok(t) => t,
542 Err(_) => {
543 warn!(
544 context,
545 concat!(
546 "dc_msg_load_from_db: could not get ",
547 "text column as non-lossy utf8 id {}"
548 ),
549 id
550 );
551 String::from_utf8_lossy(buf).into_owned()
552 }
553 }
554 }
555 _ => String::new(),
556 };
557 let msg = Message {
558 id: row.get("id")?,
559 rfc724_mid: row.get::<_, String>("rfc724mid")?,
560 in_reply_to: row
561 .get::<_, Option<String>>("mime_in_reply_to")?
562 .and_then(|in_reply_to| parse_message_id(&in_reply_to).ok()),
563 chat_id: row.get("chat_id")?,
564 from_id: row.get("from_id")?,
565 to_id: row.get("to_id")?,
566 timestamp_sort: row.get("timestamp")?,
567 timestamp_sent: row.get("timestamp_sent")?,
568 timestamp_rcvd: row.get("timestamp_rcvd")?,
569 ephemeral_timer: row.get("ephemeral_timer")?,
570 ephemeral_timestamp: row.get("ephemeral_timestamp")?,
571 viewtype: row.get("type")?,
572 state: state.with_mdns(mdn_msg_id.is_some()),
573 download_state: row.get("download_state")?,
574 error: Some(row.get::<_, String>("error")?)
575 .filter(|error| !error.is_empty()),
576 is_dc_message: row.get("msgrmsg")?,
577 original_msg_id: row.get("original_msg_id")?,
578 mime_modified: row.get("mime_modified")?,
579 text,
580 subject: row.get("subject")?,
581 param: row.get::<_, String>("param")?.parse().unwrap_or_default(),
582 hidden: row.get("hidden")?,
583 location_id: row.get("location")?,
584 chat_blocked: row
585 .get::<_, Option<Blocked>>("blocked")?
586 .unwrap_or_default(),
587 };
588 Ok(msg)
589 },
590 )
591 .await
592 .with_context(|| format!("failed to load message {id} from the database"))?;
593
594 Ok(msg)
595 }
596
597 pub fn get_filemime(&self) -> Option<String> {
604 if let Some(m) = self.param.get(Param::MimeType) {
605 return Some(m.to_string());
606 } else if self.param.exists(Param::File) {
607 if let Some((_, mime)) = guess_msgtype_from_suffix(self) {
608 return Some(mime.to_string());
609 }
610 return Some("application/octet-stream".to_string());
612 }
613 None
615 }
616
617 pub fn get_file(&self, context: &Context) -> Option<PathBuf> {
619 self.param.get_file_path(context).unwrap_or(None)
620 }
621
622 pub async fn vcard_contacts(&self, context: &Context) -> Result<Vec<VcardContact>> {
624 if self.viewtype != Viewtype::Vcard {
625 return Ok(Vec::new());
626 }
627
628 let path = self
629 .get_file(context)
630 .context("vCard message does not have an attachment")?;
631 let bytes = tokio::fs::read(path).await?;
632 let vcard_contents = std::str::from_utf8(&bytes).context("vCard is not a valid UTF-8")?;
633 Ok(parse_vcard(vcard_contents))
634 }
635
636 pub async fn save_file(&self, context: &Context, path: &Path) -> Result<()> {
638 let path_src = self.get_file(context).context("No file")?;
639 let mut src = fs::OpenOptions::new().read(true).open(path_src).await?;
640 let mut dst = fs::OpenOptions::new()
641 .write(true)
642 .create_new(true)
643 .open(path)
644 .await?;
645 io::copy(&mut src, &mut dst).await?;
646 Ok(())
647 }
648
649 pub(crate) async fn try_calc_and_set_dimensions(&mut self, context: &Context) -> Result<()> {
651 if self.viewtype.has_file() {
652 let file_param = self.param.get_file_path(context)?;
653 if let Some(path_and_filename) = file_param {
654 if (self.viewtype == Viewtype::Image || self.viewtype == Viewtype::Gif)
655 && !self.param.exists(Param::Width)
656 {
657 let buf = read_file(context, &path_and_filename).await?;
658
659 match get_filemeta(&buf) {
660 Ok((width, height)) => {
661 self.param.set_int(Param::Width, width as i32);
662 self.param.set_int(Param::Height, height as i32);
663 }
664 Err(err) => {
665 self.param.set_int(Param::Width, 0);
666 self.param.set_int(Param::Height, 0);
667 warn!(
668 context,
669 "Failed to get width and height for {}: {err:#}.",
670 path_and_filename.display()
671 );
672 }
673 }
674
675 if !self.id.is_unset() {
676 self.update_param(context).await?;
677 }
678 }
679 }
680 }
681 Ok(())
682 }
683
684 pub fn has_location(&self) -> bool {
690 self.location_id != 0
691 }
692
693 pub fn set_location(&mut self, latitude: f64, longitude: f64) {
710 if latitude == 0.0 && longitude == 0.0 {
711 return;
712 }
713
714 self.param.set_float(Param::SetLatitude, latitude);
715 self.param.set_float(Param::SetLongitude, longitude);
716 }
717
718 pub fn get_timestamp(&self) -> i64 {
721 if 0 != self.timestamp_sent {
722 self.timestamp_sent
723 } else {
724 self.timestamp_sort
725 }
726 }
727
728 pub fn get_id(&self) -> MsgId {
730 self.id
731 }
732
733 pub fn rfc724_mid(&self) -> &str {
736 &self.rfc724_mid
737 }
738
739 pub fn get_from_id(&self) -> ContactId {
741 self.from_id
742 }
743
744 pub fn get_chat_id(&self) -> ChatId {
746 self.chat_id
747 }
748
749 pub fn get_viewtype(&self) -> Viewtype {
751 self.viewtype
752 }
753
754 pub fn force_sticker(&mut self) {
757 self.param.set_int(Param::ForceSticker, 1);
758 }
759
760 pub fn get_state(&self) -> MessageState {
762 self.state
763 }
764
765 pub fn get_received_timestamp(&self) -> i64 {
767 self.timestamp_rcvd
768 }
769
770 pub fn get_sort_timestamp(&self) -> i64 {
772 self.timestamp_sort
773 }
774
775 pub fn get_text(&self) -> String {
777 self.text.clone()
778 }
779
780 pub fn get_subject(&self) -> &str {
782 &self.subject
783 }
784
785 pub fn get_filename(&self) -> Option<String> {
789 if let Some(name) = self.param.get(Param::Filename) {
790 return Some(sanitize_filename(name));
791 }
792 self.param
793 .get(Param::File)
794 .and_then(|file| Path::new(file).file_name())
795 .map(|name| sanitize_filename(&name.to_string_lossy()))
796 }
797
798 pub async fn get_filebytes(&self, context: &Context) -> Result<Option<u64>> {
800 if let Some(path) = self.param.get_file_path(context)? {
801 Ok(Some(get_filebytes(context, &path).await.with_context(
802 || format!("failed to get {} size in bytes", path.display()),
803 )?))
804 } else {
805 Ok(None)
806 }
807 }
808
809 pub fn get_width(&self) -> i32 {
811 self.param.get_int(Param::Width).unwrap_or_default()
812 }
813
814 pub fn get_height(&self) -> i32 {
816 self.param.get_int(Param::Height).unwrap_or_default()
817 }
818
819 pub fn get_duration(&self) -> i32 {
821 self.param.get_int(Param::Duration).unwrap_or_default()
822 }
823
824 pub fn get_showpadlock(&self) -> bool {
826 self.param.get_int(Param::GuaranteeE2ee).unwrap_or_default() != 0
827 || self.from_id == ContactId::DEVICE
828 }
829
830 pub fn is_bot(&self) -> bool {
832 self.param.get_bool(Param::Bot).unwrap_or_default()
833 }
834
835 pub fn get_ephemeral_timer(&self) -> EphemeralTimer {
837 self.ephemeral_timer
838 }
839
840 pub fn get_ephemeral_timestamp(&self) -> i64 {
842 self.ephemeral_timestamp
843 }
844
845 pub async fn get_summary(&self, context: &Context, chat: Option<&Chat>) -> Result<Summary> {
847 let chat_loaded: Chat;
848 let chat = if let Some(chat) = chat {
849 chat
850 } else {
851 let chat = Chat::load_from_db(context, self.chat_id).await?;
852 chat_loaded = chat;
853 &chat_loaded
854 };
855
856 let contact = if self.from_id != ContactId::SELF {
857 match chat.typ {
858 Chattype::Group
859 | Chattype::OutBroadcast
860 | Chattype::InBroadcast
861 | Chattype::Mailinglist => Some(Contact::get_by_id(context, self.from_id).await?),
862 Chattype::Single => None,
863 }
864 } else {
865 None
866 };
867
868 Summary::new(context, self, chat, contact.as_ref()).await
869 }
870
871 pub fn get_override_sender_name(&self) -> Option<String> {
881 self.param
882 .get(Param::OverrideSenderDisplayname)
883 .map(|name| name.to_string())
884 }
885
886 pub(crate) fn get_sender_name(&self, contact: &Contact) -> String {
889 self.get_override_sender_name()
890 .unwrap_or_else(|| contact.get_display_name().to_string())
891 }
892
893 pub fn has_deviating_timestamp(&self) -> bool {
898 let cnv_to_local = gm2local_offset();
899 let sort_timestamp = self.get_sort_timestamp() + cnv_to_local;
900 let send_timestamp = self.get_timestamp() + cnv_to_local;
901
902 sort_timestamp / 86400 != send_timestamp / 86400
903 }
904
905 pub fn is_sent(&self) -> bool {
908 self.state >= MessageState::OutDelivered
909 }
910
911 pub fn is_forwarded(&self) -> bool {
913 0 != self.param.get_int(Param::Forwarded).unwrap_or_default()
914 }
915
916 pub fn is_edited(&self) -> bool {
918 self.param.get_bool(Param::IsEdited).unwrap_or_default()
919 }
920
921 pub fn is_info(&self) -> bool {
923 let cmd = self.param.get_cmd();
924 self.from_id == ContactId::INFO
925 || self.to_id == ContactId::INFO
926 || cmd != SystemMessage::Unknown && cmd != SystemMessage::AutocryptSetupMessage
927 }
928
929 pub fn get_info_type(&self) -> SystemMessage {
931 self.param.get_cmd()
932 }
933
934 pub async fn get_info_contact_id(&self, context: &Context) -> Result<Option<ContactId>> {
936 match self.param.get_cmd() {
937 SystemMessage::GroupNameChanged
938 | SystemMessage::GroupImageChanged
939 | SystemMessage::EphemeralTimerChanged => {
940 if self.from_id != ContactId::INFO {
941 Ok(Some(self.from_id))
942 } else {
943 Ok(None)
944 }
945 }
946
947 SystemMessage::MemberAddedToGroup | SystemMessage::MemberRemovedFromGroup => {
948 if let Some(contact_i32) = self.param.get_int(Param::ContactAddedRemoved) {
949 let contact_id = ContactId::new(contact_i32.try_into()?);
950 if contact_id == ContactId::SELF
951 || Contact::real_exists_by_id(context, contact_id).await?
952 {
953 Ok(Some(contact_id))
954 } else {
955 Ok(None)
956 }
957 } else {
958 Ok(None)
959 }
960 }
961
962 SystemMessage::AutocryptSetupMessage
963 | SystemMessage::SecurejoinMessage
964 | SystemMessage::LocationStreamingEnabled
965 | SystemMessage::LocationOnly
966 | SystemMessage::ChatE2ee
967 | SystemMessage::ChatProtectionEnabled
968 | SystemMessage::ChatProtectionDisabled
969 | SystemMessage::InvalidUnencryptedMail
970 | SystemMessage::SecurejoinWait
971 | SystemMessage::SecurejoinWaitTimeout
972 | SystemMessage::MultiDeviceSync
973 | SystemMessage::WebxdcStatusUpdate
974 | SystemMessage::WebxdcInfoMessage
975 | SystemMessage::IrohNodeAddr
976 | SystemMessage::CallAccepted
977 | SystemMessage::CallEnded
978 | SystemMessage::Unknown => Ok(None),
979 }
980 }
981
982 pub fn is_system_message(&self) -> bool {
984 let cmd = self.param.get_cmd();
985 cmd != SystemMessage::Unknown
986 }
987
988 pub fn is_setupmessage(&self) -> bool {
990 if self.viewtype != Viewtype::File {
991 return false;
992 }
993
994 self.param.get_cmd() == SystemMessage::AutocryptSetupMessage
995 }
996
997 pub async fn get_setupcodebegin(&self, context: &Context) -> Option<String> {
1001 if !self.is_setupmessage() {
1002 return None;
1003 }
1004
1005 if let Some(filename) = self.get_file(context) {
1006 if let Ok(ref buf) = read_file(context, &filename).await {
1007 if let Ok((typ, headers, _)) = split_armored_data(buf) {
1008 if typ == pgp::armor::BlockType::Message {
1009 return headers.get(crate::pgp::HEADER_SETUPCODE).cloned();
1010 }
1011 }
1012 }
1013 }
1014
1015 None
1016 }
1017
1018 pub(crate) fn create_webrtc_instance(instance: &str, room: &str) -> String {
1021 let (videochat_type, mut url) = Message::parse_webrtc_instance(instance);
1022
1023 if !url.contains(':') {
1025 url = format!("https://{url}");
1026 }
1027
1028 let url = if url.contains("$ROOM") {
1030 url.replace("$ROOM", room)
1031 } else if url.contains("$NOROOM") {
1032 url.replace("$NOROOM", "")
1038 } else {
1039 let maybe_slash = if url.ends_with('/')
1042 || url.ends_with('?')
1043 || url.ends_with('#')
1044 || url.ends_with('=')
1045 {
1046 ""
1047 } else {
1048 "/"
1049 };
1050 format!("{url}{maybe_slash}{room}")
1051 };
1052
1053 match videochat_type {
1055 VideochatType::BasicWebrtc => format!("basicwebrtc:{url}"),
1056 VideochatType::Jitsi => format!("jitsi:{url}"),
1057 VideochatType::Unknown => url,
1058 }
1059 }
1060
1061 pub fn parse_webrtc_instance(instance: &str) -> (VideochatType, String) {
1063 let instance: String = instance.split_whitespace().collect();
1064 let mut split = instance.splitn(2, ':');
1065 let type_str = split.next().unwrap_or_default().to_lowercase();
1066 let url = split.next();
1067 match type_str.as_str() {
1068 "basicwebrtc" => (
1069 VideochatType::BasicWebrtc,
1070 url.unwrap_or_default().to_string(),
1071 ),
1072 "jitsi" => (VideochatType::Jitsi, url.unwrap_or_default().to_string()),
1073 _ => (VideochatType::Unknown, instance.to_string()),
1074 }
1075 }
1076
1077 pub fn get_videochat_url(&self) -> Option<String> {
1079 if self.viewtype == Viewtype::VideochatInvitation {
1080 if let Some(instance) = self.param.get(Param::WebrtcRoom) {
1081 return Some(Message::parse_webrtc_instance(instance).1);
1082 }
1083 }
1084 None
1085 }
1086
1087 pub fn get_videochat_type(&self) -> Option<VideochatType> {
1089 if self.viewtype == Viewtype::VideochatInvitation {
1090 if let Some(instance) = self.param.get(Param::WebrtcRoom) {
1091 return Some(Message::parse_webrtc_instance(instance).0);
1092 }
1093 }
1094 None
1095 }
1096
1097 pub fn set_text(&mut self, text: String) {
1099 self.text = text;
1100 }
1101
1102 pub fn set_subject(&mut self, subject: String) {
1105 self.subject = subject;
1106 }
1107
1108 pub fn set_file_and_deduplicate(
1123 &mut self,
1124 context: &Context,
1125 file: &Path,
1126 name: Option<&str>,
1127 filemime: Option<&str>,
1128 ) -> Result<()> {
1129 let name = if let Some(name) = name {
1130 name.to_string()
1131 } else {
1132 file.file_name()
1133 .map(|s| s.to_string_lossy().to_string())
1134 .unwrap_or_else(|| "unknown_file".to_string())
1135 };
1136
1137 let blob = BlobObject::create_and_deduplicate(context, file, Path::new(&name))?;
1138 self.param.set(Param::File, blob.as_name());
1139
1140 self.param.set(Param::Filename, name);
1141 self.param.set_optional(Param::MimeType, filemime);
1142
1143 Ok(())
1144 }
1145
1146 pub fn set_file_from_bytes(
1153 &mut self,
1154 context: &Context,
1155 name: &str,
1156 data: &[u8],
1157 filemime: Option<&str>,
1158 ) -> Result<()> {
1159 let blob = BlobObject::create_and_deduplicate_from_bytes(context, data, name)?;
1160 self.param.set(Param::Filename, name);
1161 self.param.set(Param::File, blob.as_name());
1162 self.param.set_optional(Param::MimeType, filemime);
1163
1164 Ok(())
1165 }
1166
1167 pub async fn make_vcard(&mut self, context: &Context, contacts: &[ContactId]) -> Result<()> {
1169 ensure!(
1170 matches!(self.viewtype, Viewtype::File | Viewtype::Vcard),
1171 "Wrong viewtype for vCard: {}",
1172 self.viewtype,
1173 );
1174 let vcard = contact::make_vcard(context, contacts).await?;
1175 self.set_file_from_bytes(context, "vcard.vcf", vcard.as_bytes(), None)
1176 }
1177
1178 pub(crate) async fn try_set_vcard(&mut self, context: &Context, path: &Path) -> Result<()> {
1180 let vcard = fs::read(path)
1181 .await
1182 .with_context(|| format!("Could not read {path:?}"))?;
1183 if let Some(summary) = get_vcard_summary(&vcard) {
1184 self.param.set(Param::Summary1, summary);
1185 } else {
1186 warn!(context, "try_set_vcard: Not a valid DeltaChat vCard.");
1187 self.viewtype = Viewtype::File;
1188 }
1189 Ok(())
1190 }
1191
1192 pub fn set_override_sender_name(&mut self, name: Option<String>) {
1195 self.param
1196 .set_optional(Param::OverrideSenderDisplayname, name);
1197 }
1198
1199 pub fn set_dimension(&mut self, width: i32, height: i32) {
1201 self.param.set_int(Param::Width, width);
1202 self.param.set_int(Param::Height, height);
1203 }
1204
1205 pub fn set_duration(&mut self, duration: i32) {
1207 self.param.set_int(Param::Duration, duration);
1208 }
1209
1210 pub(crate) fn set_reaction(&mut self) {
1212 self.param.set_int(Param::Reaction, 1);
1213 }
1214
1215 pub async fn latefiling_mediasize(
1218 &mut self,
1219 context: &Context,
1220 width: i32,
1221 height: i32,
1222 duration: i32,
1223 ) -> Result<()> {
1224 if width > 0 && height > 0 {
1225 self.param.set_int(Param::Width, width);
1226 self.param.set_int(Param::Height, height);
1227 }
1228 if duration > 0 {
1229 self.param.set_int(Param::Duration, duration);
1230 }
1231 self.update_param(context).await?;
1232 Ok(())
1233 }
1234
1235 pub fn set_quote_text(&mut self, text: Option<(String, bool)>) {
1241 let Some((text, protect)) = text else {
1242 self.param.remove(Param::Quote);
1243 self.param.remove(Param::ProtectQuote);
1244 return;
1245 };
1246 self.param.set(Param::Quote, text);
1247 self.param.set_optional(
1248 Param::ProtectQuote,
1249 match protect {
1250 true => Some("1"),
1251 false => None,
1252 },
1253 );
1254 }
1255
1256 pub async fn set_quote(&mut self, context: &Context, quote: Option<&Message>) -> Result<()> {
1265 if let Some(quote) = quote {
1266 ensure!(
1267 !quote.rfc724_mid.is_empty(),
1268 "Message without Message-Id cannot be quoted"
1269 );
1270 self.in_reply_to = Some(quote.rfc724_mid.clone());
1271
1272 let text = quote.get_text();
1273 let text = if text.is_empty() {
1274 quote
1276 .get_summary(context, None)
1277 .await?
1278 .truncated_text(500)
1279 .to_string()
1280 } else {
1281 text
1282 };
1283 self.set_quote_text(Some((
1284 text,
1285 quote
1286 .param
1287 .get_bool(Param::GuaranteeE2ee)
1288 .unwrap_or_default(),
1289 )));
1290 } else {
1291 self.in_reply_to = None;
1292 self.set_quote_text(None);
1293 }
1294
1295 Ok(())
1296 }
1297
1298 pub fn quoted_text(&self) -> Option<String> {
1300 self.param.get(Param::Quote).map(|s| s.to_string())
1301 }
1302
1303 pub async fn quoted_message(&self, context: &Context) -> Result<Option<Message>> {
1305 if self.param.get(Param::Quote).is_some() && !self.is_forwarded() {
1306 return self.parent(context).await;
1307 }
1308 Ok(None)
1309 }
1310
1311 pub async fn parent(&self, context: &Context) -> Result<Option<Message>> {
1316 if let Some(in_reply_to) = &self.in_reply_to {
1317 if let Some((msg_id, _ts_sent)) = rfc724_mid_exists(context, in_reply_to).await? {
1318 let msg = Message::load_from_db_optional(context, msg_id).await?;
1319 return Ok(msg);
1320 }
1321 }
1322 Ok(None)
1323 }
1324
1325 pub async fn get_original_msg_id(&self, context: &Context) -> Result<Option<MsgId>> {
1327 if !self.original_msg_id.is_special() {
1328 if let Some(msg) = Message::load_from_db_optional(context, self.original_msg_id).await?
1329 {
1330 return if msg.chat_id.is_trash() {
1331 Ok(None)
1332 } else {
1333 Ok(Some(msg.id))
1334 };
1335 }
1336 }
1337 Ok(None)
1338 }
1339
1340 pub async fn get_saved_msg_id(&self, context: &Context) -> Result<Option<MsgId>> {
1344 let res: Option<MsgId> = context
1345 .sql
1346 .query_get_value(
1347 "SELECT id FROM msgs WHERE starred=? AND chat_id!=?",
1348 (self.id, DC_CHAT_ID_TRASH),
1349 )
1350 .await?;
1351 Ok(res)
1352 }
1353
1354 pub fn force_plaintext(&mut self) {
1356 self.param.set_int(Param::ForcePlaintext, 1);
1357 }
1358
1359 pub async fn update_param(&self, context: &Context) -> Result<()> {
1361 context
1362 .sql
1363 .execute(
1364 "UPDATE msgs SET param=? WHERE id=?;",
1365 (self.param.to_string(), self.id),
1366 )
1367 .await?;
1368 Ok(())
1369 }
1370
1371 pub fn error(&self) -> Option<String> {
1384 self.error.clone()
1385 }
1386}
1387
1388#[derive(
1392 Debug,
1393 Default,
1394 Clone,
1395 Copy,
1396 PartialEq,
1397 Eq,
1398 PartialOrd,
1399 Ord,
1400 FromPrimitive,
1401 ToPrimitive,
1402 ToSql,
1403 FromSql,
1404 Serialize,
1405 Deserialize,
1406)]
1407#[repr(u32)]
1408pub enum MessageState {
1409 #[default]
1411 Undefined = 0,
1412
1413 InFresh = 10,
1416
1417 InNoticed = 13,
1421
1422 InSeen = 16,
1425
1426 OutPreparing = 18,
1430
1431 OutDraft = 19,
1433
1434 OutPending = 20,
1438
1439 OutFailed = 24,
1442
1443 OutDelivered = 26,
1447
1448 OutMdnRcvd = 28,
1451}
1452
1453impl std::fmt::Display for MessageState {
1454 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1455 write!(
1456 f,
1457 "{}",
1458 match self {
1459 Self::Undefined => "Undefined",
1460 Self::InFresh => "Fresh",
1461 Self::InNoticed => "Noticed",
1462 Self::InSeen => "Seen",
1463 Self::OutPreparing => "Preparing",
1464 Self::OutDraft => "Draft",
1465 Self::OutPending => "Pending",
1466 Self::OutFailed => "Failed",
1467 Self::OutDelivered => "Delivered",
1468 Self::OutMdnRcvd => "Read",
1469 }
1470 )
1471 }
1472}
1473
1474impl MessageState {
1475 pub fn can_fail(self) -> bool {
1477 use MessageState::*;
1478 matches!(
1479 self,
1480 OutPreparing | OutPending | OutDelivered | OutMdnRcvd )
1482 }
1483
1484 pub fn is_outgoing(self) -> bool {
1486 use MessageState::*;
1487 matches!(
1488 self,
1489 OutPreparing | OutDraft | OutPending | OutFailed | OutDelivered | OutMdnRcvd
1490 )
1491 }
1492
1493 pub(crate) fn with_mdns(self, has_mdns: bool) -> Self {
1495 if self == MessageState::OutDelivered && has_mdns {
1496 return MessageState::OutMdnRcvd;
1497 }
1498 self
1499 }
1500}
1501
1502pub async fn get_msg_read_receipts(
1504 context: &Context,
1505 msg_id: MsgId,
1506) -> Result<Vec<(ContactId, i64)>> {
1507 context
1508 .sql
1509 .query_map(
1510 "SELECT contact_id, timestamp_sent FROM msgs_mdns WHERE msg_id=?",
1511 (msg_id,),
1512 |row| {
1513 let contact_id: ContactId = row.get(0)?;
1514 let ts: i64 = row.get(1)?;
1515 Ok((contact_id, ts))
1516 },
1517 |rows| rows.collect::<Result<Vec<_>, _>>().map_err(Into::into),
1518 )
1519 .await
1520}
1521
1522pub(crate) fn guess_msgtype_from_suffix(msg: &Message) -> Option<(Viewtype, &'static str)> {
1523 msg.param
1524 .get(Param::Filename)
1525 .or_else(|| msg.param.get(Param::File))
1526 .and_then(|file| guess_msgtype_from_path_suffix(Path::new(file)))
1527}
1528
1529pub(crate) fn guess_msgtype_from_path_suffix(path: &Path) -> Option<(Viewtype, &'static str)> {
1530 let extension: &str = &path.extension()?.to_str()?.to_lowercase();
1531 let info = match extension {
1532 "3gp" => (Viewtype::Video, "video/3gpp"),
1537 "aac" => (Viewtype::Audio, "audio/aac"),
1538 "avi" => (Viewtype::Video, "video/x-msvideo"),
1539 "avif" => (Viewtype::File, "image/avif"), "doc" => (Viewtype::File, "application/msword"),
1541 "docx" => (
1542 Viewtype::File,
1543 "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
1544 ),
1545 "epub" => (Viewtype::File, "application/epub+zip"),
1546 "flac" => (Viewtype::Audio, "audio/flac"),
1547 "gif" => (Viewtype::Gif, "image/gif"),
1548 "heic" => (Viewtype::File, "image/heic"), "heif" => (Viewtype::File, "image/heif"), "html" => (Viewtype::File, "text/html"),
1551 "htm" => (Viewtype::File, "text/html"),
1552 "ico" => (Viewtype::File, "image/vnd.microsoft.icon"),
1553 "jar" => (Viewtype::File, "application/java-archive"),
1554 "jpeg" => (Viewtype::Image, "image/jpeg"),
1555 "jpe" => (Viewtype::Image, "image/jpeg"),
1556 "jpg" => (Viewtype::Image, "image/jpeg"),
1557 "json" => (Viewtype::File, "application/json"),
1558 "mov" => (Viewtype::Video, "video/quicktime"),
1559 "m4a" => (Viewtype::Audio, "audio/m4a"),
1560 "mp3" => (Viewtype::Audio, "audio/mpeg"),
1561 "mp4" => (Viewtype::Video, "video/mp4"),
1562 "odp" => (
1563 Viewtype::File,
1564 "application/vnd.oasis.opendocument.presentation",
1565 ),
1566 "ods" => (
1567 Viewtype::File,
1568 "application/vnd.oasis.opendocument.spreadsheet",
1569 ),
1570 "odt" => (Viewtype::File, "application/vnd.oasis.opendocument.text"),
1571 "oga" => (Viewtype::Audio, "audio/ogg"),
1572 "ogg" => (Viewtype::Audio, "audio/ogg"),
1573 "ogv" => (Viewtype::File, "video/ogg"),
1574 "opus" => (Viewtype::File, "audio/ogg"), "otf" => (Viewtype::File, "font/otf"),
1576 "pdf" => (Viewtype::File, "application/pdf"),
1577 "png" => (Viewtype::Image, "image/png"),
1578 "ppt" => (Viewtype::File, "application/vnd.ms-powerpoint"),
1579 "pptx" => (
1580 Viewtype::File,
1581 "application/vnd.openxmlformats-officedocument.presentationml.presentation",
1582 ),
1583 "rar" => (Viewtype::File, "application/vnd.rar"),
1584 "rtf" => (Viewtype::File, "application/rtf"),
1585 "spx" => (Viewtype::File, "audio/ogg"), "svg" => (Viewtype::File, "image/svg+xml"),
1587 "tgs" => (Viewtype::File, "application/x-tgsticker"),
1588 "tiff" => (Viewtype::File, "image/tiff"),
1589 "tif" => (Viewtype::File, "image/tiff"),
1590 "ttf" => (Viewtype::File, "font/ttf"),
1591 "txt" => (Viewtype::File, "text/plain"),
1592 "vcard" => (Viewtype::Vcard, "text/vcard"),
1593 "vcf" => (Viewtype::Vcard, "text/vcard"),
1594 "wav" => (Viewtype::Audio, "audio/wav"),
1595 "weba" => (Viewtype::File, "audio/webm"),
1596 "webm" => (Viewtype::Video, "video/webm"),
1597 "webp" => (Viewtype::Image, "image/webp"), "wmv" => (Viewtype::Video, "video/x-ms-wmv"),
1599 "xdc" => (Viewtype::Webxdc, "application/webxdc+zip"),
1600 "xhtml" => (Viewtype::File, "application/xhtml+xml"),
1601 "xls" => (Viewtype::File, "application/vnd.ms-excel"),
1602 "xlsx" => (
1603 Viewtype::File,
1604 "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
1605 ),
1606 "xml" => (Viewtype::File, "application/xml"),
1607 "zip" => (Viewtype::File, "application/zip"),
1608 _ => {
1609 return None;
1610 }
1611 };
1612 Some(info)
1613}
1614
1615pub(crate) async fn get_mime_headers(context: &Context, msg_id: MsgId) -> Result<Vec<u8>> {
1622 let (headers, compressed) = context
1623 .sql
1624 .query_row(
1625 "SELECT mime_headers, mime_compressed FROM msgs WHERE id=?",
1626 (msg_id,),
1627 |row| {
1628 let headers = sql::row_get_vec(row, 0)?;
1629 let compressed: bool = row.get(1)?;
1630 Ok((headers, compressed))
1631 },
1632 )
1633 .await?;
1634 if compressed {
1635 return buf_decompress(&headers);
1636 }
1637
1638 let headers2 = headers.clone();
1639 let compressed = match tokio::task::block_in_place(move || buf_compress(&headers2)) {
1640 Err(e) => {
1641 warn!(context, "get_mime_headers: buf_compress() failed: {}", e);
1642 return Ok(headers);
1643 }
1644 Ok(o) => o,
1645 };
1646 let update = |conn: &mut rusqlite::Connection| {
1647 match conn.execute(
1648 "\
1649 UPDATE msgs SET mime_headers=?, mime_compressed=1 \
1650 WHERE id=? AND mime_headers!='' AND mime_compressed=0",
1651 (compressed, msg_id),
1652 ) {
1653 Ok(rows_updated) => ensure!(rows_updated <= 1),
1654 Err(e) => {
1655 warn!(context, "get_mime_headers: UPDATE failed: {}", e);
1656 return Err(e.into());
1657 }
1658 }
1659 Ok(())
1660 };
1661 if let Err(e) = context.sql.call_write(update).await {
1662 warn!(
1663 context,
1664 "get_mime_headers: failed to update mime_headers: {}", e
1665 );
1666 }
1667
1668 Ok(headers)
1669}
1670
1671pub(crate) async fn delete_msg_locally(context: &Context, msg: &Message) -> Result<()> {
1674 if msg.location_id > 0 {
1675 delete_poi_location(context, msg.location_id).await?;
1676 }
1677 let on_server = true;
1678 msg.id
1679 .trash(context, on_server)
1680 .await
1681 .with_context(|| format!("Unable to trash message {}", msg.id))?;
1682
1683 context.emit_event(EventType::MsgDeleted {
1684 chat_id: msg.chat_id,
1685 msg_id: msg.id,
1686 });
1687
1688 if msg.viewtype == Viewtype::Webxdc {
1689 context.emit_event(EventType::WebxdcInstanceDeleted { msg_id: msg.id });
1690 }
1691
1692 let logging_xdc_id = context
1693 .debug_logging
1694 .read()
1695 .expect("RwLock is poisoned")
1696 .as_ref()
1697 .map(|dl| dl.msg_id);
1698 if let Some(id) = logging_xdc_id {
1699 if id == msg.id {
1700 set_debug_logging_xdc(context, None).await?;
1701 }
1702 }
1703
1704 Ok(())
1705}
1706
1707pub(crate) async fn delete_msgs_locally_done(
1710 context: &Context,
1711 msg_ids: &[MsgId],
1712 modified_chat_ids: HashSet<ChatId>,
1713) -> Result<()> {
1714 for modified_chat_id in modified_chat_ids {
1715 context.emit_msgs_changed_without_msg_id(modified_chat_id);
1716 chatlist_events::emit_chatlist_item_changed(context, modified_chat_id);
1717 }
1718 if !msg_ids.is_empty() {
1719 context.emit_msgs_changed_without_ids();
1720 chatlist_events::emit_chatlist_changed(context);
1721 context
1723 .set_config_internal(Config::LastHousekeeping, None)
1724 .await?;
1725 }
1726 Ok(())
1727}
1728
1729pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
1731 delete_msgs_ex(context, msg_ids, false).await
1732}
1733
1734pub async fn delete_msgs_ex(
1738 context: &Context,
1739 msg_ids: &[MsgId],
1740 delete_for_all: bool,
1741) -> Result<()> {
1742 let mut modified_chat_ids = HashSet::new();
1743 let mut deleted_rfc724_mid = Vec::new();
1744 let mut res = Ok(());
1745
1746 for &msg_id in msg_ids {
1747 let msg = Message::load_from_db(context, msg_id).await?;
1748 ensure!(
1749 !delete_for_all || msg.from_id == ContactId::SELF,
1750 "Can delete only own messages for others"
1751 );
1752 ensure!(
1753 !delete_for_all || msg.get_showpadlock(),
1754 "Cannot request deletion of unencrypted message for others"
1755 );
1756
1757 modified_chat_ids.insert(msg.chat_id);
1758 deleted_rfc724_mid.push(msg.rfc724_mid.clone());
1759
1760 let target = context.get_delete_msgs_target().await?;
1761 let update_db = |trans: &mut rusqlite::Transaction| {
1762 trans.execute(
1763 "UPDATE imap SET target=? WHERE rfc724_mid=?",
1764 (target, msg.rfc724_mid),
1765 )?;
1766 trans.execute("DELETE FROM smtp WHERE msg_id=?", (msg_id,))?;
1767 Ok(())
1768 };
1769 if let Err(e) = context.sql.transaction(update_db).await {
1770 error!(context, "delete_msgs: failed to update db: {e:#}.");
1771 res = Err(e);
1772 continue;
1773 }
1774 }
1775 res?;
1776
1777 if delete_for_all {
1778 ensure!(
1779 modified_chat_ids.len() == 1,
1780 "Can delete only from same chat."
1781 );
1782 if let Some(chat_id) = modified_chat_ids.iter().next() {
1783 let mut msg = Message::new_text("🚮".to_owned());
1784 msg.param.set_int(Param::GuaranteeE2ee, 1);
1789 msg.param
1790 .set(Param::DeleteRequestFor, deleted_rfc724_mid.join(" "));
1791 msg.hidden = true;
1792 send_msg(context, *chat_id, &mut msg).await?;
1793 }
1794 } else {
1795 context
1796 .add_sync_item(SyncData::DeleteMessages {
1797 msgs: deleted_rfc724_mid,
1798 })
1799 .await?;
1800 }
1801
1802 for &msg_id in msg_ids {
1803 let msg = Message::load_from_db(context, msg_id).await?;
1804 delete_msg_locally(context, &msg).await?;
1805 }
1806 delete_msgs_locally_done(context, msg_ids, modified_chat_ids).await?;
1807
1808 context.scheduler.interrupt_inbox().await;
1810
1811 Ok(())
1812}
1813
1814pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()> {
1816 if msg_ids.is_empty() {
1817 return Ok(());
1818 }
1819
1820 let old_last_msg_id = MsgId::new(context.get_config_u32(Config::LastMsgId).await?);
1821 let last_msg_id = msg_ids.iter().fold(&old_last_msg_id, std::cmp::max);
1822 context
1823 .set_config_internal(Config::LastMsgId, Some(&last_msg_id.to_u32().to_string()))
1824 .await?;
1825
1826 let mut msgs = Vec::with_capacity(msg_ids.len());
1827 for &id in &msg_ids {
1828 if let Some(msg) = context
1829 .sql
1830 .query_row_optional(
1831 "SELECT
1832 m.chat_id AS chat_id,
1833 m.state AS state,
1834 m.download_state as download_state,
1835 m.ephemeral_timer AS ephemeral_timer,
1836 m.param AS param,
1837 m.from_id AS from_id,
1838 m.rfc724_mid AS rfc724_mid,
1839 c.archived AS archived,
1840 c.blocked AS blocked
1841 FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id
1842 WHERE m.id=? AND m.chat_id>9",
1843 (id,),
1844 |row| {
1845 let chat_id: ChatId = row.get("chat_id")?;
1846 let state: MessageState = row.get("state")?;
1847 let download_state: DownloadState = row.get("download_state")?;
1848 let param: Params = row.get::<_, String>("param")?.parse().unwrap_or_default();
1849 let from_id: ContactId = row.get("from_id")?;
1850 let rfc724_mid: String = row.get("rfc724_mid")?;
1851 let visibility: ChatVisibility = row.get("archived")?;
1852 let blocked: Option<Blocked> = row.get("blocked")?;
1853 let ephemeral_timer: EphemeralTimer = row.get("ephemeral_timer")?;
1854 Ok((
1855 (
1856 id,
1857 chat_id,
1858 state,
1859 download_state,
1860 param,
1861 from_id,
1862 rfc724_mid,
1863 visibility,
1864 blocked.unwrap_or_default(),
1865 ),
1866 ephemeral_timer,
1867 ))
1868 },
1869 )
1870 .await?
1871 {
1872 msgs.push(msg);
1873 }
1874 }
1875
1876 if msgs
1877 .iter()
1878 .any(|(_, ephemeral_timer)| *ephemeral_timer != EphemeralTimer::Disabled)
1879 {
1880 start_ephemeral_timers_msgids(context, &msg_ids)
1881 .await
1882 .context("failed to start ephemeral timers")?;
1883 }
1884
1885 let mut updated_chat_ids = BTreeSet::new();
1886 let mut archived_chats_maybe_noticed = false;
1887 for (
1888 (
1889 id,
1890 curr_chat_id,
1891 curr_state,
1892 curr_download_state,
1893 curr_param,
1894 curr_from_id,
1895 curr_rfc724_mid,
1896 curr_visibility,
1897 curr_blocked,
1898 ),
1899 _curr_ephemeral_timer,
1900 ) in msgs
1901 {
1902 if curr_download_state != DownloadState::Done {
1903 if curr_state == MessageState::InFresh {
1904 update_msg_state(context, id, MessageState::InNoticed).await?;
1907 updated_chat_ids.insert(curr_chat_id);
1908 }
1909 } else if curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed {
1910 update_msg_state(context, id, MessageState::InSeen).await?;
1911 info!(context, "Seen message {}.", id);
1912
1913 markseen_on_imap_table(context, &curr_rfc724_mid).await?;
1914
1915 if curr_blocked == Blocked::Not
1925 && curr_param.get_bool(Param::WantsMdn).unwrap_or_default()
1926 && curr_param.get_cmd() == SystemMessage::Unknown
1927 && context.should_send_mdns().await?
1928 {
1929 context
1930 .sql
1931 .execute(
1932 "INSERT INTO smtp_mdns (msg_id, from_id, rfc724_mid) VALUES(?, ?, ?)",
1933 (id, curr_from_id, curr_rfc724_mid),
1934 )
1935 .await
1936 .context("failed to insert into smtp_mdns")?;
1937 context.scheduler.interrupt_smtp().await;
1938 }
1939 updated_chat_ids.insert(curr_chat_id);
1940 }
1941 archived_chats_maybe_noticed |=
1942 curr_state == MessageState::InFresh && curr_visibility == ChatVisibility::Archived;
1943 }
1944
1945 for updated_chat_id in updated_chat_ids {
1946 context.emit_event(EventType::MsgsNoticed(updated_chat_id));
1947 chatlist_events::emit_chatlist_item_changed(context, updated_chat_id);
1948 }
1949 if archived_chats_maybe_noticed {
1950 context.on_archived_chats_maybe_noticed();
1951 }
1952
1953 Ok(())
1954}
1955
1956pub(crate) async fn update_msg_state(
1957 context: &Context,
1958 msg_id: MsgId,
1959 state: MessageState,
1960) -> Result<()> {
1961 ensure!(
1962 state != MessageState::OutMdnRcvd,
1963 "Update msgs_mdns table instead!"
1964 );
1965 ensure!(state != MessageState::OutFailed, "use set_msg_failed()!");
1966 let error_subst = match state >= MessageState::OutPending {
1967 true => ", error=''",
1968 false => "",
1969 };
1970 context
1971 .sql
1972 .execute(
1973 &format!("UPDATE msgs SET state=? {error_subst} WHERE id=?"),
1974 (state, msg_id),
1975 )
1976 .await?;
1977 Ok(())
1978}
1979
1980pub(crate) async fn set_msg_failed(
1988 context: &Context,
1989 msg: &mut Message,
1990 error: &str,
1991) -> Result<()> {
1992 if msg.state.can_fail() {
1993 msg.state = MessageState::OutFailed;
1994 warn!(context, "{} failed: {}", msg.id, error);
1995 } else {
1996 warn!(
1997 context,
1998 "{} seems to have failed ({}), but state is {}", msg.id, error, msg.state
1999 )
2000 }
2001 msg.error = Some(error.to_string());
2002
2003 let exists = context
2004 .sql
2005 .execute(
2006 "UPDATE msgs SET state=?, error=? WHERE id=?;",
2007 (msg.state, error, msg.id),
2008 )
2009 .await?
2010 > 0;
2011 context.emit_event(EventType::MsgFailed {
2012 chat_id: msg.chat_id,
2013 msg_id: msg.id,
2014 });
2015 if exists {
2016 chatlist_events::emit_chatlist_item_changed(context, msg.chat_id);
2017 }
2018 Ok(())
2019}
2020
2021pub async fn get_unblocked_msg_cnt(context: &Context) -> usize {
2023 match context
2024 .sql
2025 .count(
2026 "SELECT COUNT(*) \
2027 FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \
2028 WHERE m.id>9 AND m.chat_id>9 AND c.blocked=0;",
2029 (),
2030 )
2031 .await
2032 {
2033 Ok(res) => res,
2034 Err(err) => {
2035 error!(context, "get_unblocked_msg_cnt() failed. {:#}", err);
2036 0
2037 }
2038 }
2039}
2040
2041pub async fn get_request_msg_cnt(context: &Context) -> usize {
2043 match context
2044 .sql
2045 .count(
2046 "SELECT COUNT(*) \
2047 FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \
2048 WHERE c.blocked=2;",
2049 (),
2050 )
2051 .await
2052 {
2053 Ok(res) => res,
2054 Err(err) => {
2055 error!(context, "get_request_msg_cnt() failed. {:#}", err);
2056 0
2057 }
2058 }
2059}
2060
2061pub async fn estimate_deletion_cnt(
2077 context: &Context,
2078 from_server: bool,
2079 seconds: i64,
2080) -> Result<usize> {
2081 let self_chat_id = ChatIdBlocked::lookup_by_contact(context, ContactId::SELF)
2082 .await?
2083 .map(|c| c.id)
2084 .unwrap_or_default();
2085 let threshold_timestamp = time() - seconds;
2086
2087 let cnt = if from_server {
2088 context
2089 .sql
2090 .count(
2091 "SELECT COUNT(*)
2092 FROM msgs m
2093 WHERE m.id > ?
2094 AND timestamp < ?
2095 AND chat_id != ?
2096 AND EXISTS (SELECT * FROM imap WHERE rfc724_mid=m.rfc724_mid);",
2097 (DC_MSG_ID_LAST_SPECIAL, threshold_timestamp, self_chat_id),
2098 )
2099 .await?
2100 } else {
2101 context
2102 .sql
2103 .count(
2104 "SELECT COUNT(*)
2105 FROM msgs m
2106 WHERE m.id > ?
2107 AND timestamp < ?
2108 AND chat_id != ?
2109 AND chat_id != ? AND hidden = 0;",
2110 (
2111 DC_MSG_ID_LAST_SPECIAL,
2112 threshold_timestamp,
2113 self_chat_id,
2114 DC_CHAT_ID_TRASH,
2115 ),
2116 )
2117 .await?
2118 };
2119 Ok(cnt)
2120}
2121
2122pub(crate) async fn rfc724_mid_exists(
2124 context: &Context,
2125 rfc724_mid: &str,
2126) -> Result<Option<(MsgId, i64)>> {
2127 Ok(rfc724_mid_exists_ex(context, rfc724_mid, "1")
2128 .await?
2129 .map(|(id, ts_sent, _)| (id, ts_sent)))
2130}
2131
2132pub(crate) async fn rfc724_mid_exists_ex(
2138 context: &Context,
2139 rfc724_mid: &str,
2140 expr: &str,
2141) -> Result<Option<(MsgId, i64, bool)>> {
2142 let rfc724_mid = rfc724_mid.trim_start_matches('<').trim_end_matches('>');
2143 if rfc724_mid.is_empty() {
2144 warn!(context, "Empty rfc724_mid passed to rfc724_mid_exists");
2145 return Ok(None);
2146 }
2147
2148 let res = context
2149 .sql
2150 .query_row_optional(
2151 &("SELECT id, timestamp_sent, MIN(".to_string()
2152 + expr
2153 + ") FROM msgs WHERE rfc724_mid=?
2154 HAVING COUNT(*) > 0 -- Prevent MIN(expr) from returning NULL when there are no rows.
2155 ORDER BY timestamp_sent DESC"),
2156 (rfc724_mid,),
2157 |row| {
2158 let msg_id: MsgId = row.get(0)?;
2159 let timestamp_sent: i64 = row.get(1)?;
2160 let expr_res: bool = row.get(2)?;
2161 Ok((msg_id, timestamp_sent, expr_res))
2162 },
2163 )
2164 .await?;
2165
2166 Ok(res)
2167}
2168
2169pub(crate) async fn get_by_rfc724_mids(
2176 context: &Context,
2177 mids: &[String],
2178) -> Result<Option<Message>> {
2179 let mut latest = None;
2180 for id in mids.iter().rev() {
2181 let Some((msg_id, _)) = rfc724_mid_exists(context, id).await? else {
2182 continue;
2183 };
2184 let Some(msg) = Message::load_from_db_optional(context, msg_id).await? else {
2185 continue;
2186 };
2187 if msg.download_state == DownloadState::Done {
2188 return Ok(Some(msg));
2189 }
2190 latest.get_or_insert(msg);
2191 }
2192 Ok(latest)
2193}
2194
2195pub(crate) fn get_vcard_summary(vcard: &[u8]) -> Option<String> {
2197 let vcard = str::from_utf8(vcard).ok()?;
2198 let contacts = deltachat_contact_tools::parse_vcard(vcard);
2199 let [c] = &contacts[..] else {
2200 return None;
2201 };
2202 if !deltachat_contact_tools::may_be_valid_addr(&c.addr) {
2203 return None;
2204 }
2205 Some(c.display_name().to_string())
2206}
2207
2208#[derive(
2210 Debug,
2211 Default,
2212 Display,
2213 Clone,
2214 Copy,
2215 PartialEq,
2216 Eq,
2217 FromPrimitive,
2218 ToPrimitive,
2219 FromSql,
2220 ToSql,
2221 Serialize,
2222 Deserialize,
2223)]
2224#[repr(u32)]
2225pub enum Viewtype {
2226 #[default]
2228 Unknown = 0,
2229
2230 Text = 10,
2233
2234 Image = 20,
2240
2241 Gif = 21,
2245
2246 Sticker = 23,
2253
2254 Audio = 40,
2258
2259 Voice = 41,
2264
2265 Video = 50,
2272
2273 File = 60,
2277
2278 VideochatInvitation = 70,
2280
2281 Call = 71,
2283
2284 Webxdc = 80,
2286
2287 Vcard = 90,
2291}
2292
2293impl Viewtype {
2294 pub fn has_file(&self) -> bool {
2296 match self {
2297 Viewtype::Unknown => false,
2298 Viewtype::Text => false,
2299 Viewtype::Image => true,
2300 Viewtype::Gif => true,
2301 Viewtype::Sticker => true,
2302 Viewtype::Audio => true,
2303 Viewtype::Voice => true,
2304 Viewtype::Video => true,
2305 Viewtype::File => true,
2306 Viewtype::VideochatInvitation => false,
2307 Viewtype::Call => false,
2308 Viewtype::Webxdc => true,
2309 Viewtype::Vcard => true,
2310 }
2311 }
2312}
2313
2314pub(crate) fn normalize_text(text: &str) -> Option<String> {
2317 if text.is_ascii() {
2318 return None;
2319 };
2320 Some(text.to_lowercase()).filter(|t| t != text)
2321}
2322
2323#[cfg(test)]
2324mod message_tests;