rb_mumble_protocol 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cb4a478bc0cc5d8928902a1d4905d59182051d8c5666f70b6ae31f393b06d91
-  data.tar.gz: 26b9deba5193c57621d82665857702b15c19ba61fa4960983dddecd04cca2b94
+  metadata.gz: 7389a940b90f092d9f0b0450ed5ae3237e93f3c6d9400a799e6f6221a63e330a
+  data.tar.gz: 7332e0fec01c75d7845ac315d05a0b018fbadbb248b3553aa1b12ff2cf3a70eb
 SHA512:
-  metadata.gz: 397a5909f8ab0cca9fd0c303dc832e8888850811df1228eb0330c0430da1c568367da96d470271b36b243e82b5801ef2aa44e9f4e6b2cdf808659822bda8ccaf
-  data.tar.gz: 030e4c96656cbb4ac7f4401275dde69633ac0d0ff648478b62b7409b84f1b957ec37259d4db79f25073d75dc9bd808d96de96bf3d800e536f29fc7cc2185c9f4
+  metadata.gz: '09a342f7767ac3e1410bbb05c4bf38b6450052d6656c64697d49e1b1b980e426263c899247c3c6364a60ce4bdd61e758a290fa3d640c7c39a6b95a724ac0488d'
+  data.tar.gz: 43b4a05ac99e5ef55db0c7c53e723fe40ee22ba2a7e69b86cf373435b6785cf30a089e17a33ebcecde6eac314448b0ae84b4161eba1a9cb219533da6b2f32461

data/Cargo.toml

@@ -4,4 +4,4 @@
 
 [workspace]
 members = ["./ext/rb_mumble_protocol"]
-# resolver = "2"
+resolver = "1"

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.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: rb_mumble_protocol
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Mikhail Odebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-09 00:00:00.000000000 Z
-dependencies: []
+date: 2024-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Gem that providing classes for implementing Mumble-related projects.
 email:
 - derpiranha@gmail.com