Restore peerstate constants from C core

src/contact.rs

@@ -585,7 +585,12 @@ impl Contact {
 
             let mut self_key = Key::from_self_public(context, &loginparam.addr, &context.sql);
 
-            if peerstate.is_some() && peerstate.as_ref().and_then(|p| p.peek_key(0)).is_some() {
+            if peerstate.is_some()
+                && peerstate
+                    .as_ref()
+                    .and_then(|p| p.peek_key(PeerstateVerifiedStatus::Unverified))
+                    .is_some()
+            {
                 let peerstate = peerstate.as_ref().unwrap();
                 let p =
                     context.stock_str(if peerstate.prefer_encrypt == EncryptPreference::Mutual {
@@ -605,11 +610,11 @@ impl Contact {
                     .map(|k| k.formatted_fingerprint())
                     .unwrap_or_default();
                 let fingerprint_other_verified = peerstate
-                    .peek_key(2)
+                    .peek_key(PeerstateVerifiedStatus::BidirectVerified)
                     .map(|k| k.formatted_fingerprint())
                     .unwrap_or_default();
                 let fingerprint_other_unverified = peerstate
-                    .peek_key(0)
+                    .peek_key(PeerstateVerifiedStatus::Unverified)
                     .map(|k| k.formatted_fingerprint())
                     .unwrap_or_default();
                 if peerstate.addr.is_some() && &loginparam.addr < peerstate.addr.as_ref().unwrap() {

src/dc_receive_imf.rs

@@ -1640,7 +1640,11 @@ fn check_verified_properties(
                 info!(context, "{} has verified {}.", contact.get_addr(), to_addr,);
                 let fp = peerstate.gossip_key_fingerprint.clone();
                 if let Some(fp) = fp {
-                    peerstate.set_verified(0, &fp, 2);
+                    peerstate.set_verified(
+                        DC_PS_GOSSIP_KEY,
+                        &fp,
+                        PeerstateVerifiedStatus::BidirectVerified,
+                    );
                     peerstate.save_to_db(&context.sql, false)?;
                     is_verified = true;
                 }

src/e2ee.rs

@@ -75,7 +75,7 @@ impl EncryptHelper {
         &mut self,
         factory: &mut MimeFactory,
         e2ee_guaranteed: bool,
-        min_verified: libc::c_int,
+        min_verified: PeerstateVerifiedStatus,
         do_gossip: bool,
         mut in_out_message: *mut Mailmime,
         imffields_unprotected: *mut mailimf_fields,
@@ -118,10 +118,10 @@ impl EncryptHelper {
                 return Ok(false);
             }
 
-            if let Some(key) = peerstate.peek_key(min_verified as usize) {
+            if let Some(key) = peerstate.peek_key(min_verified) {
                 keyring.add_owned(key.clone());
                 if do_gossip {
-                    if let Some(header) = peerstate.render_gossip_header(min_verified as usize) {
+                    if let Some(header) = peerstate.render_gossip_header(min_verified) {
                         gossip_headers.push(header.to_string());
                     }
                 }

src/mimefactory.rs

@@ -230,7 +230,7 @@ impl<'a> MimeFactory<'a> {
 
         // 1=add Autocrypt-header (needed eg. for handshaking), 2=no Autocrypte-header (used for MDN)
         let mut e2ee_guaranteed = false;
-        let mut min_verified: libc::c_int = 0;
+        let mut min_verified = crate::peerstate::PeerstateVerifiedStatus::Unverified;
         let mut do_gossip = false;
         let mut grpimage = None;
         let force_plaintext: libc::c_int;
@@ -246,7 +246,7 @@ impl<'a> MimeFactory<'a> {
                     wrapmime::new_custom_field(imf_fields, "Chat-Verified", "1");
                     force_plaintext = 0;
                     e2ee_guaranteed = true;
-                    min_verified = 2
+                    min_verified = crate::peerstate::PeerstateVerifiedStatus::BidirectVerified;
                 } else {
                     force_plaintext = self
                         .msg

src/peerstate.rs

@@ -12,6 +12,17 @@ use crate::error::*;
 use crate::key::*;
 use crate::sql::{self, Sql};
 
+pub const DC_PS_GOSSIP_KEY: u32 = 0;
+pub const DC_PS_PUBLIC_KEY: u32 = 1;
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, FromPrimitive)]
+#[repr(u8)]
+pub enum PeerstateVerifiedStatus {
+    Unverified = 0,
+    //Verified = 1, // not used
+    BidirectVerified = 2,
+}
+
 /// Peerstate represents the state of an Autocrypt peer.
 pub struct Peerstate<'a> {
     pub context: &'a Context,
@@ -311,7 +322,7 @@ impl<'a> Peerstate<'a> {
         };
     }
 
-    pub fn render_gossip_header(&self, min_verified: usize) -> Option<String> {
+    pub fn render_gossip_header(&self, min_verified: PeerstateVerifiedStatus) -> Option<String> {
         if let Some(ref addr) = self.addr {
             if let Some(key) = self.peek_key(min_verified) {
                 // TODO: avoid cloning
@@ -327,12 +338,12 @@ impl<'a> Peerstate<'a> {
         None
     }
 
-    pub fn peek_key(&self, min_verified: usize) -> Option<&Key> {
+    pub fn peek_key(&self, min_verified: PeerstateVerifiedStatus) -> Option<&Key> {
         if self.public_key.is_none() && self.gossip_key.is_none() && self.verified_key.is_none() {
             return None;
         }
 
-        if 0 != min_verified {
+        if min_verified != PeerstateVerifiedStatus::Unverified {
             return self.verified_key.as_ref();
         }
         if self.public_key.is_some() {
@@ -342,10 +353,17 @@ impl<'a> Peerstate<'a> {
         self.gossip_key.as_ref()
     }
 
-    pub fn set_verified(&mut self, which_key: usize, fingerprint: &str, verified: usize) -> bool {
+    pub fn set_verified(
+        &mut self,
+        which_key: u32,
+        fingerprint: &str,
+        verified: PeerstateVerifiedStatus,
+    ) -> bool {
         let mut success = false;
-        if !(which_key != 0 && which_key != 1 || verified != 2) {
+        if !(which_key != DC_PS_GOSSIP_KEY && which_key != DC_PS_PUBLIC_KEY
-            if which_key == 1
+            || verified != PeerstateVerifiedStatus::BidirectVerified)
+        {
+            if which_key == DC_PS_PUBLIC_KEY
                 && self.public_key_fingerprint.is_some()
                 && self.public_key_fingerprint.as_ref().unwrap() == fingerprint
             {
@@ -354,7 +372,7 @@ impl<'a> Peerstate<'a> {
                 self.verified_key_fingerprint = self.public_key_fingerprint.clone();
                 success = true;
             }
-            if which_key == 0
+            if which_key == DC_PS_GOSSIP_KEY
                 && self.gossip_key_fingerprint.is_some()
                 && self.gossip_key_fingerprint.as_ref().unwrap() == fingerprint
             {

src/securejoin.rs

@@ -672,7 +672,11 @@ fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Res
     if let Some(ref mut peerstate) =
         Peerstate::from_fingerprint(context, &context.sql, fingerprint.as_ref())
     {
-        if peerstate.set_verified(1, fingerprint.as_ref(), 2) {
+        if peerstate.set_verified(
+            DC_PS_PUBLIC_KEY,
+            fingerprint.as_ref(),
+            PeerstateVerifiedStatus::BidirectVerified,
+        ) {
             peerstate.prefer_encrypt = EncryptPreference::Mutual;
             peerstate.to_save = Some(ToSave::All);
             peerstate