rb_mumble_protocol 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6cca0049d733675e76feeb5e9b480a5659167d2f474f199b21084f98528ab14
-  data.tar.gz: 7e4dba7a96babe8076628d53a30890629862c305630e16d02670b307cf110afb
+  metadata.gz: 7389a940b90f092d9f0b0450ed5ae3237e93f3c6d9400a799e6f6221a63e330a
+  data.tar.gz: 7332e0fec01c75d7845ac315d05a0b018fbadbb248b3553aa1b12ff2cf3a70eb
 SHA512:
-  metadata.gz: 28ee61c56fc114226de2f8aca41b8b8ad75fdd9d3c6bd4c2fea94e235dbc8f5d83f8dde716b113a12b5b307401d7a750c2afc3e7b0f22a834b7d347cb89a4cbb
-  data.tar.gz: b28c087c5ed16fe69d5e6b07d24bd3d0f95e7b8224974ef3c0d346ff90c9fcb8d10c8a2b53cb9559d4ce52f03a585ccc7db21183e506d660e6b0678c36597df4
+  metadata.gz: '09a342f7767ac3e1410bbb05c4bf38b6450052d6656c64697d49e1b1b980e426263c899247c3c6364a60ce4bdd61e758a290fa3d640c7c39a6b95a724ac0488d'
+  data.tar.gz: 43b4a05ac99e5ef55db0c7c53e723fe40ee22ba2a7e69b86cf373435b6785cf30a089e17a33ebcecde6eac314448b0ae84b4161eba1a9cb219533da6b2f32461

data/ext/rb_mumble_protocol/src/lib.rs

@@ -27,9 +27,55 @@ static BASE_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
 
 pub mod crypt_state;
 
-#[magnus::wrap(class = "RbMumbleProtocol::CryptState")]
+use crypt_state::{DecryptError};
+
+impl Into<u8> for DecryptError {
+    fn into(self: DecryptError) -> u8 {
+        match self {
+            DecryptError::Repeat => 1,
+            DecryptError::Late => 2,
+            DecryptError::Mac => 3,
+            DecryptError::Eof => 4
+        }
+    }
+}
+
+#[magnus::wrap(class = "RbMumbleProtocol::CryptState", size)]
 struct CryptStateRef(RefCell<crypt_state::CryptState>);
 
+#[magnus::wrap(class = "RbMumbleProtocol::DecryptResult", free_immediately, size)]
+struct DecryptResult {
+    buffer: RefCell<Vec<u8>>,
+    reason_raw: u8
+}
+
+impl DecryptResult {
+    pub fn new(buffer: Vec<u8>, result: Result<(), DecryptError>) -> Self {
+        let reason_raw =
+            match result {
+                Ok(()) => 0,
+                Err(e) => e.into()
+            };
+
+        Self {
+            buffer: RefCell::new(buffer),
+            reason_raw: reason_raw.into()
+        }
+    }
+
+    pub fn is_success(&self) -> bool {
+        self.reason_raw == 0
+    }
+
+    pub fn data(&self) -> Vec<u8> {
+        self.buffer.borrow().to_vec()
+    }
+
+    pub fn reason_raw_value(&self) -> u8 {
+        self.reason_raw
+    }
+}
+
 impl CryptStateRef {
     pub fn new() -> Self {
         Self(RefCell::new(crypt_state::CryptState::generate_new()))
@@ -114,27 +160,14 @@ impl CryptStateRef {
         }
     }
 
-    pub fn decrypt(&self, encrypted: Vec<u8>) -> Result<Vec<u8>, Error> {
+    pub fn decrypt(&self, encrypted: Vec<u8>) -> Result<DecryptResult, Error> {
         match self.0.try_borrow_mut() {
             Ok(mut state) => {
                 let mut buffer = BytesMut::new();
                 buffer.extend_from_slice(&encrypted);
+                let result = state.decrypt(&mut buffer);
 
-                match state.decrypt(&mut buffer) {
-                    Ok(_) => Ok(buffer.to_vec()),
-                    Err(crypt_state::DecryptError::Repeat) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Repeat"))
-                    },
-                    Err(crypt_state::DecryptError::Late) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Late"))
-                    },
-                    Err(crypt_state::DecryptError::Mac) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Mac"))
-                    },
-                    Err(crypt_state::DecryptError::Eof) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Eof"))
-                    }
-                }
+                Ok(DecryptResult::new(buffer.to_vec(), result))
             },
             Err(_e) => { Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "borrow error")) }
         }
@@ -149,18 +182,23 @@ fn get_ruby() -> Ruby {
 #[magnus::init]
 fn init() -> Result<(), Error> {
     let module = define_module("RbMumbleProtocol")?;
-    let class = module.define_class("CryptState", class::object())?;
+    let class1 = module.define_class("CryptState", class::object())?;
+
+    class1.define_singleton_method("new", function!(CryptStateRef::new, 0))?;
+    class1.define_singleton_method("new_from", function!(CryptStateRef::new_from, 3))?;
 
-    class.define_singleton_method("new", function!(CryptStateRef::new, 0))?;
-    class.define_singleton_method("new_from", function!(CryptStateRef::new_from, 3))?;
+    class1.define_method("key", method!(CryptStateRef::key, 0))?;
+    class1.define_method("encrypt_nonce", method!(CryptStateRef::encrypt_nonce, 0))?;
+    class1.define_method("decrypt_nonce", method!(CryptStateRef::decrypt_nonce, 0))?;
+    class1.define_method("stats", method!(CryptStateRef::stats, 0))?;
 
-    class.define_method("key", method!(CryptStateRef::key, 0))?;
-    class.define_method("encrypt_nonce", method!(CryptStateRef::encrypt_nonce, 0))?;
-    class.define_method("decrypt_nonce", method!(CryptStateRef::decrypt_nonce, 0))?;
-    class.define_method("stats", method!(CryptStateRef::stats, 0))?;
+    class1.define_method("encrypt", method!(CryptStateRef::encrypt, 1))?;
+    class1.define_method("decrypt", method!(CryptStateRef::decrypt, 1))?;
 
-    class.define_method("encrypt", method!(CryptStateRef::encrypt, 1))?;
-    class.define_method("decrypt", method!(CryptStateRef::decrypt, 1))?;
+    let class2 = module.define_class("DecryptResult", class::object())?;
+    class2.define_method("success?", method!(DecryptResult::is_success, 0))?;
+    class2.define_method("data", method!(DecryptResult::data, 0))?;
+    class2.define_method("reason_raw_value", method!(DecryptResult::reason_raw_value, 0))?;
 
     Ok(())
 }

data/lib/rb_mumble_protocol/crypt_state.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
 module RbMumbleProtocol
-  class Error < StandardError
+  class CryptState
   end
 
-  class CryptState
+  class DecryptResult
+    REASONS = {
+      0 => :ok,
+      1 => :repeat,
+      2 => :late,
+      3 => :mac,
+      4 => :eof
+    }.freeze
+
+    def reason
+      REASONS[reason_raw_value]
+    end
   end
 end

data/lib/rb_mumble_protocol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RbMumbleProtocol
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rb_mumble_protocol
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Mikhail Odebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-09 00:00:00.000000000 Z
+date: 2024-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec