rustfmt / changed message packet byte to 0xfc

README.md

@@ -20,8 +20,8 @@ packet kind has defined values for packets but leaves many open for user defined
 
 | byte        | packet kind                                          |
 | ----------- | ---------------------------------------------------- |
-| `0x00`      | message - a simple text packet                       |
-| `0x01-0xfc` | valid for custom packet usage                        |
+| `0x00-0xfb` | valid for custom packet usage                        |
+| `0xfc`      | message - a simple text packet                       |
 | `0xfd`      | leave - announces a disconnect                       |
 | `0xfe`      | join - announces a new connection                    |
 | `0xff`      | agreement - used to help generate an agreed upon key |

src/agreement.rs

@@ -18,11 +18,7 @@ impl Agreement {
     pub fn new(public_key: Vec<u8>) -> Agreement {
         let timestamp = Utc::now().timestamp();
         let message_id = Uuid::new_v4().as_u128();
-        Agreement {
-            timestamp,
-            message_id,
-            public_key,
-        }
+        Agreement { timestamp, message_id, public_key }
     }
 }
 

src/encrypt.rs

@@ -31,9 +31,7 @@ impl Encryption for SymmetricEncrypt {
 
     fn encrypt(&self, packet: &mut Packet) -> Result<()> {
         packet.contents = aead::seal(self.key().unwrap(), &packet.contents)?;
-        packet.integrity_hash = digest::digest(&digest::SHA256, &packet.contents)
-            .as_ref()
-            .to_vec();
+        packet.integrity_hash = digest::digest(&digest::SHA256, &packet.contents).as_ref().to_vec();
         Ok(())
     }
 
@@ -52,9 +50,7 @@ impl SymmetricEncrypt {
     #[doc(hidden)]
     /// dear future izzy, this is a really bad idea
     pub fn clone(&self) -> Result<SymmetricEncrypt> {
-        Ok(SymmetricEncrypt::new(aead::SecretKey::from_slice(
-            self.0.unprotected_as_bytes(),
-        )?))
+        Ok(SymmetricEncrypt::new(aead::SecretKey::from_slice(self.0.unprotected_as_bytes())?))
     }
 }
 

src/join.rs

@@ -16,11 +16,7 @@ impl Join {
         let timestamp = Utc::now().timestamp();
         let message_id = Uuid::new_v4().as_u128();
 
-        Join {
-            timestamp,
-            message_id,
-            username,
-        }
+        Join { timestamp, message_id, username }
     }
 }
 

src/leave.rs

@@ -16,11 +16,7 @@ impl Leave {
         let timestamp = Utc::now().timestamp();
         let message_id = Uuid::new_v4().as_u128();
 
-        Leave {
-            timestamp,
-            message_id,
-            username,
-        }
+        Leave { timestamp, message_id, username }
     }
 }
 

src/lib.rs

@@ -65,12 +65,7 @@ impl Packet {
     /// create a new `Packet`
     pub fn new(kind: u8, contents: Vec<u8>, encrypt_flag: EncryptFlag) -> Packet {
         let integrity_hash = digest::digest(&digest::SHA256, &contents).as_ref().to_vec();
-        Packet {
-            kind,
-            integrity_hash,
-            contents,
-            encrypt_flag,
-        }
+        Packet { kind, integrity_hash, contents, encrypt_flag }
     }
 
     // generate a checksum from the packet
@@ -112,18 +107,12 @@ impl Packet {
 
     /// verifies SHA256 integrity
     pub fn verify_integrity(&self) -> Result<()> {
-        let expected = digest::digest(&digest::SHA256, &self.contents)
-            .as_ref()
-            .to_vec();
+        let expected = digest::digest(&digest::SHA256, &self.contents).as_ref().to_vec();
 
         if expected == self.integrity_hash {
             Ok(())
         } else {
-            Err(IlmpError::BadHashIntegrity {
-                found: self.integrity_hash.clone(),
-                expected,
-            }
-            .into())
+            Err(IlmpError::BadHashIntegrity { found: self.integrity_hash.clone(), expected }.into())
         }
     }
 
@@ -184,12 +173,7 @@ where
     let mut contents: Vec<u8> = vec![0; length];
     stream.read(&mut contents).await?;
 
-    let mut packet = Packet {
-        kind,
-        contents,
-        integrity_hash,
-        encrypt_flag,
-    };
+    let mut packet = Packet { kind, contents, integrity_hash, encrypt_flag };
 
     packet.verify_checksum(checksum)?;
     packet.verify_integrity()?;
@@ -259,9 +243,7 @@ where
     crate::write(write, agree_packet, &encrypt::NoEncrypt::new()).await?;
 
     // receive peer's pub key
-    let packet = crate::read(read, &encrypt::NoEncrypt::new())
-        .await?
-        .unwrap();
+    let packet = crate::read(read, &encrypt::NoEncrypt::new()).await?.unwrap();
     let agree_packet = Agreement::from_packet(packet)?;
     let peer_pub_key = agree::UnparsedPublicKey::new(&agree::X25519, agree_packet.public_key);
 
@@ -271,9 +253,8 @@ where
         &peer_pub_key,
         IlmpError::Ring(ring::error::Unspecified),
         |key_material| {
-            let key_material = digest::digest(&digest::SHA256, key_material.as_ref().into())
-                .as_ref()
-                .to_vec();
+            let key_material =
+                digest::digest(&digest::SHA256, key_material.as_ref().into()).as_ref().to_vec();
             Ok(aead::SecretKey::from_slice(&key_material)?)
         },
     )

src/message.rs

@@ -18,19 +18,14 @@ impl Message {
         let timestamp = Utc::now().timestamp();
         let message_id = Uuid::new_v4().as_u128();
 
-        Message {
-            username,
-            message_id,
-            timestamp,
-            contents,
-        }
+        Message { username, message_id, timestamp, contents }
     }
 }
 
 impl crate::Sendable for Message {
     fn to_packet(&self, encrypt_flag: crate::EncryptFlag) -> Result<Packet> {
         let contents: Vec<u8> = serde_json::to_string(&self)?.into_bytes();
-        let kind = 0x00;
+        let kind = 0xfc;
         Ok(Packet::new(kind, contents, encrypt_flag))
     }
 
@@ -41,6 +36,6 @@ impl crate::Sendable for Message {
     }
 
     fn packet_kind(&self) -> u8 {
-        0x00
+        0xfc
     }
 }