ffi work

veilid-core/src/crypto/byte_array_types.rs

@@ -9,18 +9,24 @@ use data_encoding::BASE64URL_NOPAD;
 
 //////////////////////////////////////////////////////////////////////
 
-/// Length of a public key in bytes
+/// Length of a crypto key in bytes
 #[allow(dead_code)]
-pub const PUBLIC_KEY_LENGTH: usize = 32;
-/// Length of a public key in bytes after encoding to base64url
+pub const CRYPTO_KEY_LENGTH: usize = 32;
+/// Length of a crypto key in bytes after encoding to base64url
 #[allow(dead_code)]
-pub const PUBLIC_KEY_LENGTH_ENCODED: usize = 43;
+pub const CRYPTO_KEY_LENGTH_ENCODED: usize = 43;
+/// Length of a crypto key in bytes
+#[allow(dead_code)]
+pub const PUBLIC_KEY_LENGTH: usize = CRYPTO_KEY_LENGTH;
+/// Length of a crypto key in bytes after encoding to base64url
+#[allow(dead_code)]
+pub const PUBLIC_KEY_LENGTH_ENCODED: usize = CRYPTO_KEY_LENGTH_ENCODED;
 /// Length of a secret key in bytes
 #[allow(dead_code)]
-pub const SECRET_KEY_LENGTH: usize = 32;
+pub const SECRET_KEY_LENGTH: usize = CRYPTO_KEY_LENGTH;
 /// Length of a secret key in bytes after encoding to base64url
 #[allow(dead_code)]
-pub const SECRET_KEY_LENGTH_ENCODED: usize = 43;
+pub const SECRET_KEY_LENGTH_ENCODED: usize = CRYPTO_KEY_LENGTH_ENCODED;
 /// Length of a signature in bytes
 #[allow(dead_code)]
 pub const SIGNATURE_LENGTH: usize = 64;
@@ -35,22 +41,22 @@ pub const NONCE_LENGTH: usize = 24;
 pub const NONCE_LENGTH_ENCODED: usize = 32;
 /// Length of a shared secret in bytes
 #[allow(dead_code)]
-pub const SHARED_SECRET_LENGTH: usize = 32;
+pub const SHARED_SECRET_LENGTH: usize = CRYPTO_KEY_LENGTH;
 /// Length of a shared secret in bytes after encoding to base64url
 #[allow(dead_code)]
-pub const SHARED_SECRET_LENGTH_ENCODED: usize = 43;
+pub const SHARED_SECRET_LENGTH_ENCODED: usize = CRYPTO_KEY_LENGTH_ENCODED;
 /// Length of a route id in bytes
 #[allow(dead_code)]
-pub const ROUTE_ID_LENGTH: usize = 32;
+pub const ROUTE_ID_LENGTH: usize = CRYPTO_KEY_LENGTH;
 /// Length of a route id in bytes afer encoding to base64url
 #[allow(dead_code)]
-pub const ROUTE_ID_LENGTH_ENCODED: usize = 43;
+pub const ROUTE_ID_LENGTH_ENCODED: usize = CRYPTO_KEY_LENGTH_ENCODED;
 /// Length of a hash digest in bytes
 #[allow(dead_code)]
-pub const HASH_DIGEST_LENGTH: usize = 32;
+pub const HASH_DIGEST_LENGTH: usize = CRYPTO_KEY_LENGTH;
 /// Length of a hash digest in bytes after encoding to base64url
 #[allow(dead_code)]
-pub const HASH_DIGEST_LENGTH_ENCODED: usize = 43;
+pub const HASH_DIGEST_LENGTH_ENCODED: usize = CRYPTO_KEY_LENGTH_ENCODED;
 
 //////////////////////////////////////////////////////////////////////
 
@@ -255,18 +261,14 @@ macro_rules! byte_array_type {
 
 /////////////////////////////////////////
 
-byte_array_type!(PublicKey, PUBLIC_KEY_LENGTH, PUBLIC_KEY_LENGTH_ENCODED);
-byte_array_type!(SecretKey, SECRET_KEY_LENGTH, SECRET_KEY_LENGTH_ENCODED);
+byte_array_type!(CryptoKey, CRYPTO_KEY_LENGTH, CRYPTO_KEY_LENGTH_ENCODED);
+
+pub type PublicKey = CryptoKey;
+pub type SecretKey = CryptoKey;
+pub type HashDigest = CryptoKey;
+pub type SharedSecret = CryptoKey;
+pub type RouteId = CryptoKey;
+pub type CryptoKeyDistance = CryptoKey;
+
 byte_array_type!(Signature, SIGNATURE_LENGTH, SIGNATURE_LENGTH_ENCODED);
-byte_array_type!(
-    PublicKeyDistance,
-    PUBLIC_KEY_LENGTH,
-    PUBLIC_KEY_LENGTH_ENCODED
-);
 byte_array_type!(Nonce, NONCE_LENGTH, NONCE_LENGTH_ENCODED);
-byte_array_type!(
-    SharedSecret,
-    SHARED_SECRET_LENGTH,
-    SHARED_SECRET_LENGTH_ENCODED
-);
-byte_array_type!(RouteId, ROUTE_ID_LENGTH, ROUTE_ID_LENGTH_ENCODED);

veilid-core/src/crypto/crypto_system.rs

@@ -21,23 +21,23 @@ pub trait CryptoSystem {
         secret: &SecretKey,
     ) -> Result<SharedSecret, VeilidAPIError>;
     fn generate_keypair(&self) -> KeyPair;
-    fn generate_hash(&self, data: &[u8]) -> PublicKey;
+    fn generate_hash(&self, data: &[u8]) -> HashDigest;
     fn generate_hash_reader(
         &self,
         reader: &mut dyn std::io::Read,
-    ) -> Result<PublicKey, VeilidAPIError>;
+    ) -> Result<HashDigest, VeilidAPIError>;
 
     // Validation
-    fn validate_keypair(&self, dht_key: &PublicKey, dht_key_secret: &SecretKey) -> bool;
-    fn validate_hash(&self, data: &[u8], dht_key: &PublicKey) -> bool;
+    fn validate_keypair(&self, key: &PublicKey, secret: &SecretKey) -> bool;
+    fn validate_hash(&self, data: &[u8], hash: &HashDigest) -> bool;
     fn validate_hash_reader(
         &self,
         reader: &mut dyn std::io::Read,
-        key: &PublicKey,
+        hash: &HashDigest,
     ) -> Result<bool, VeilidAPIError>;
 
     // Distance Metric
-    fn distance(&self, key1: &PublicKey, key2: &PublicKey) -> PublicKeyDistance;
+    fn distance(&self, key1: &CryptoKey, key2: &CryptoKey) -> CryptoKeyDistance;
 
     // Authentication
     fn sign(

veilid-core/src/crypto/none/mod.rs

@@ -139,14 +139,14 @@ impl CryptoSystem for CryptoSystemNONE {
         Ok(bytes == dht_key.bytes)
     }
     // Distance Metric
-    fn distance(&self, key1: &PublicKey, key2: &PublicKey) -> PublicKeyDistance {
+    fn distance(&self, key1: &PublicKey, key2: &PublicKey) -> CryptoKeyDistance {
         let mut bytes = [0u8; PUBLIC_KEY_LENGTH];
 
         for (n, byte) in bytes.iter_mut().enumerate() {
             *byte = key1.bytes[n] ^ key2.bytes[n];
         }
 
-        PublicKeyDistance::new(bytes)
+        CryptoKeyDistance::new(bytes)
     }
 
     // Authentication

veilid-core/src/crypto/vld0/mod.rs

@@ -134,14 +134,14 @@ impl CryptoSystem for CryptoSystemVLD0 {
         Ok(bytes == dht_key.bytes)
     }
     // Distance Metric
-    fn distance(&self, key1: &PublicKey, key2: &PublicKey) -> PublicKeyDistance {
+    fn distance(&self, key1: &PublicKey, key2: &PublicKey) -> CryptoKeyDistance {
         let mut bytes = [0u8; PUBLIC_KEY_LENGTH];
 
         for (n, byte) in bytes.iter_mut().enumerate() {
             *byte = key1.bytes[n] ^ key2.bytes[n];
         }
 
-        PublicKeyDistance::new(bytes)
+        CryptoKeyDistance::new(bytes)
     }
 
     // Authentication

veilid-core/src/rpc_processor/rpc_app_call.rs

@@ -61,7 +61,7 @@ impl RPCProcessor {
         let sender = msg
             .opt_sender_nr
             .as_ref()
-            .map(|nr| nr.node_ids().get(crypto_kind).unwrap().value);
+            .map(|nr| nr.node_ids().get(crypto_kind).unwrap());
 
         // Register a waiter for this app call
         let handle = self

veilid-core/src/rpc_processor/rpc_app_message.rs

@@ -38,7 +38,7 @@ impl RPCProcessor {
         let sender = msg
             .opt_sender_nr
             .as_ref()
-            .map(|nr| nr.node_ids().get(crypto_kind).unwrap().value);
+            .map(|nr| nr.node_ids().get(crypto_kind).unwrap());
 
         // Pass the message up through the update callback
         let message = app_message.destructure();

veilid-core/src/storage_manager/mod.rs

@@ -392,7 +392,7 @@ impl StorageManager {
     pub async fn watch_values(
         &self,
         key: TypedKey,
-        subkeys: &[ValueSubkeyRange],
+        subkeys: ValueSubkeyRangeSet,
         expiration: Timestamp,
         count: u32,
     ) -> Result<Timestamp, VeilidAPIError> {
@@ -403,7 +403,7 @@ impl StorageManager {
     pub async fn cancel_watch_values(
         &self,
         key: TypedKey,
-        subkeys: &[ValueSubkeyRange],
+        subkeys: ValueSubkeyRangeSet,
     ) -> Result<bool, VeilidAPIError> {
         let inner = self.lock().await?;
         unimplemented!();

veilid-core/src/veilid_api/routing_context.rs

@@ -277,7 +277,7 @@ impl RoutingContext {
     pub async fn watch_dht_values(
         &self,
         key: TypedKey,
-        subkeys: &[ValueSubkeyRange],
+        subkeys: ValueSubkeyRangeSet,
         expiration: Timestamp,
         count: u32,
     ) -> Result<Timestamp, VeilidAPIError> {
@@ -292,7 +292,7 @@ impl RoutingContext {
     pub async fn cancel_dht_watch(
         &self,
         key: TypedKey,
-        subkeys: &[ValueSubkeyRange],
+        subkeys: ValueSubkeyRangeSet,
     ) -> Result<bool, VeilidAPIError> {
         let storage_manager = self.api.storage_manager()?;
         storage_manager.cancel_watch_values(key, subkeys).await

veilid-core/src/veilid_api/types/app_message_call.rs

@@ -8,7 +8,7 @@ use super::*;
 pub struct VeilidAppMessage {
     /// Some(sender) if the message was sent directly, None if received via a private/safety route
     #[serde(with = "opt_json_as_string")]
-    sender: Option<TypedKey>, xxx continue propagating this publickey->typedkey and get all the FFI done
+    sender: Option<TypedKey>,
     /// The content of the message to deliver to the application
     #[serde(with = "json_as_base64")]
     message: Vec<u8>,

veilid-core/src/veilid_api/types/fourcc.rs

@@ -24,6 +24,19 @@ impl From<[u8; 4]> for FourCC {
         Self(b)
     }
 }
+
+impl From<u32> for FourCC {
+    fn from(u: u32) -> Self {
+        Self(u.to_be_bytes())
+    }
+}
+
+impl From<FourCC> for u32 {
+    fn from(u: FourCC) -> Self {
+        u32::from_be_bytes(u.0)
+    }
+}
+
 impl TryFrom<&[u8]> for FourCC {
     type Error = VeilidAPIError;
     fn try_from(b: &[u8]) -> Result<Self, Self::Error> {