switch out capabilities

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

@@ -4,7 +4,7 @@ use data_encoding::BASE64URL_NOPAD;
 use digest::Digest;
 use rand::RngCore;
 const AEAD_OVERHEAD: usize = PUBLIC_KEY_LENGTH;
-pub const CRYPTO_KIND_NONE: CryptoKind = FourCC([b'N', b'O', b'N', b'E']);
+pub const CRYPTO_KIND_NONE: CryptoKind = FourCC(*b"NONE");
 
 pub fn none_generate_keypair() -> KeyPair {
     let mut csprng = VeilidRng {};

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

@@ -15,7 +15,7 @@ use ed25519_dalek as ed;
 use x25519_dalek as xd;
 
 const AEAD_OVERHEAD: usize = 16;
-pub const CRYPTO_KIND_VLD0: CryptoKind = FourCC([b'V', b'L', b'D', b'0']);
+pub const CRYPTO_KIND_VLD0: CryptoKind = FourCC(*b"VLD0");
 
 fn ed25519_to_x25519_pk(key: &ed::PublicKey) -> VeilidAPIResult<xd::PublicKey> {
     let bytes = key.to_bytes();

veilid-core/src/network_manager/mod.rs

@@ -495,31 +495,42 @@ impl NetworkManager {
 
     /// Get our node's capabilities in the PublicInternet routing domain
     fn generate_public_internet_node_status(&self) -> PublicInternetNodeStatus {
+
         let Some(own_peer_info) = self
             .routing_table()
             .get_own_peer_info(RoutingDomain::PublicInternet) else {
-                return PublicInternetNodeStatus {
-                    will_route: false,
-                    will_tunnel: false,
-                    will_signal: false,
-                    will_relay: false,
-                    will_validate_dial_info: false,
-                };  
+                return PublicInternetNodeStatus::default();  
             };
         let own_node_info = own_peer_info.signed_node_info().node_info();
 
+        let config = self.config();
+        let c = config.get(); 
+
         let will_route = own_node_info.can_inbound_relay(); // xxx: eventually this may have more criteria added
         let will_tunnel = own_node_info.can_inbound_relay(); // xxx: we may want to restrict by battery life and network bandwidth at some point
         let will_signal = own_node_info.can_signal();
         let will_relay = own_node_info.can_inbound_relay();
         let will_validate_dial_info = own_node_info.can_validate_dial_info();
 
+        let mut capabilities = Vec::new();
+        if will_route && !c.capabilities.disable.contains(&CAP_WILL_ROUTE) {
+            capabilities.push(CAP_WILL_ROUTE);
+        }
+        if will_tunnel && !c.capabilities.disable.contains(&CAP_WILL_TUNNEL) {
+            capabilities.push(CAP_WILL_TUNNEL);
+        }
+        if will_signal && !c.capabilities.disable.contains(&CAP_WILL_SIGNAL) {
+            capabilities.push(CAP_WILL_SIGNAL);
+        }
+        if will_relay && !c.capabilities.disable.contains(&CAP_WILL_RELAY){
+            capabilities.push(CAP_WILL_RELAY);
+        }
+        if will_validate_dial_info && !c.capabilities.disable.contains(&CAP_WILL_VALIDATE_DIAL_INFO) {
+            capabilities.push(CAP_WILL_VALIDATE_DIAL_INFO);
+        }
+
         PublicInternetNodeStatus {
-            will_route,
-            will_tunnel,
-            will_signal,
-            will_relay,
-            will_validate_dial_info,
+            capabilities
         }
     }
     /// Get our node's capabilities in the LocalNetwork routing domain
@@ -527,20 +538,26 @@ impl NetworkManager {
         let Some(own_peer_info) = self
             .routing_table()
             .get_own_peer_info(RoutingDomain::LocalNetwork) else {
-                return LocalNetworkNodeStatus {
-                    will_relay: false,
-                    will_validate_dial_info: false,
-                };  
+                return LocalNetworkNodeStatus::default();  
             };
 
         let own_node_info = own_peer_info.signed_node_info().node_info();
+        
+        let config = self.config();
+        let c = config.get(); 
 
         let will_relay = own_node_info.can_inbound_relay();
         let will_validate_dial_info = own_node_info.can_validate_dial_info();
 
+        let mut capabilities = Vec::new();
+        if will_relay && !c.capabilities.disable.contains(&CAP_WILL_RELAY) {
+            capabilities.push(CAP_WILL_RELAY);
+        }
+        if will_validate_dial_info && !c.capabilities.disable.contains(&CAP_WILL_VALIDATE_DIAL_INFO)  {
+            capabilities.push(CAP_WILL_VALIDATE_DIAL_INFO);
+        }
         LocalNetworkNodeStatus {
-            will_relay,
-            will_validate_dial_info,
+            capabilities
         }
     }
 

veilid-core/src/network_manager/native/mod.rs

@@ -686,30 +686,30 @@ impl Network {
                 let c = self.config.get();
                 let mut inbound = ProtocolTypeSet::new();
 
-                if c.network.protocol.udp.enabled && c.capabilities.protocol_udp {
+                if c.network.protocol.udp.enabled {
                     inbound.insert(ProtocolType::UDP);
                 }
-                if c.network.protocol.tcp.listen && c.capabilities.protocol_accept_tcp {
+                if c.network.protocol.tcp.listen {
                     inbound.insert(ProtocolType::TCP);
                 }
-                if c.network.protocol.ws.listen && c.capabilities.protocol_accept_ws {
+                if c.network.protocol.ws.listen {
                     inbound.insert(ProtocolType::WS);
                 }
-                if c.network.protocol.wss.listen && c.capabilities.protocol_accept_wss {
+                if c.network.protocol.wss.listen {
                     inbound.insert(ProtocolType::WSS);
                 }
 
                 let mut outbound = ProtocolTypeSet::new();
-                if c.network.protocol.udp.enabled && c.capabilities.protocol_udp {
+                if c.network.protocol.udp.enabled {
                     outbound.insert(ProtocolType::UDP);
                 }
-                if c.network.protocol.tcp.connect && c.capabilities.protocol_connect_tcp {
+                if c.network.protocol.tcp.connect {
                     outbound.insert(ProtocolType::TCP);
                 }
-                if c.network.protocol.ws.connect && c.capabilities.protocol_connect_ws {
+                if c.network.protocol.ws.connect {
                     outbound.insert(ProtocolType::WS);
                 }
-                if c.network.protocol.wss.connect && c.capabilities.protocol_connect_wss {
+                if c.network.protocol.wss.connect {
                     outbound.insert(ProtocolType::WSS);
                 }
 

veilid-core/src/routing_table/route_spec_store/route_spec_store.rs

@@ -265,7 +265,7 @@ impl RouteSpecStore {
                         };
                     let node_status_ok =
                         if let Some(ns) = e.node_status(RoutingDomain::PublicInternet) {
-                            ns.will_route()
+                            ns.has_capability(CAP_WILL_ROUTE)
                         } else {
                             false
                         };

veilid-core/src/routing_table/tasks/relay_management.rs

@@ -148,7 +148,7 @@ impl RoutingTable {
                 // Ensure we have the node's status
                 if let Some(node_status) = e.node_status(routing_domain) {
                     // Ensure the node will relay
-                    if node_status.will_relay() {
+                    if node_status.has_capability(CAP_WILL_RELAY) {
                         // Compare against previous candidate
                         if let Some(best_inbound_relay) = best_inbound_relay.as_mut() {
                             // Less is faster

veilid-core/src/routing_table/types/node_status.rs

@@ -3,17 +3,21 @@ use super::*;
 /// RoutingDomain-specific status for each node
 /// is returned by the StatusA call
 
+pub type Capability = FourCC;
+pub const CAP_WILL_ROUTE: Capability = FourCC(*b"ROUT");
+pub const CAP_WILL_TUNNEL: Capability = FourCC(*b"TUNL");
+pub const CAP_WILL_SIGNAL: Capability = FourCC(*b"SGNL");
+pub const CAP_WILL_RELAY: Capability = FourCC(*b"RLAY");
+pub const CAP_WILL_VALIDATE_DIAL_INFO: Capability = FourCC(*b"DIAL");
+pub const MAX_CAPABILITIES: usize = 64;
+
 /// PublicInternet RoutingDomain Status
 #[derive(
     Clone, Debug, Default, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct PublicInternetNodeStatus {
-    pub will_route: bool,
-    pub will_tunnel: bool,
-    pub will_signal: bool,
-    pub will_relay: bool,
-    pub will_validate_dial_info: bool,
+    pub capabilities: Vec<Capability>,
 }
 
 #[derive(
@@ -21,8 +25,7 @@ pub struct PublicInternetNodeStatus {
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct LocalNetworkNodeStatus {
-    pub will_relay: bool,
-    pub will_validate_dial_info: bool,
+    pub capabilities: Vec<Capability>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize)]
@@ -33,34 +36,10 @@ pub enum NodeStatus {
 }
 
 impl NodeStatus {
-    pub fn will_route(&self) -> bool {
+    pub fn has_capability(&self, cap: Capability) -> bool {
         match self {
-            NodeStatus::PublicInternet(pi) => pi.will_route,
-            NodeStatus::LocalNetwork(_) => false,
-        }
-    }
-    pub fn will_tunnel(&self) -> bool {
-        match self {
-            NodeStatus::PublicInternet(pi) => pi.will_tunnel,
-            NodeStatus::LocalNetwork(_) => false,
-        }
-    }
-    pub fn will_signal(&self) -> bool {
-        match self {
-            NodeStatus::PublicInternet(pi) => pi.will_signal,
-            NodeStatus::LocalNetwork(_) => false,
-        }
-    }
-    pub fn will_relay(&self) -> bool {
-        match self {
-            NodeStatus::PublicInternet(pi) => pi.will_relay,
-            NodeStatus::LocalNetwork(ln) => ln.will_relay,
-        }
-    }
-    pub fn will_validate_dial_info(&self) -> bool {
-        match self {
-            NodeStatus::PublicInternet(pi) => pi.will_validate_dial_info,
-            NodeStatus::LocalNetwork(ln) => ln.will_validate_dial_info,
+            NodeStatus::PublicInternet(pi) => pi.capabilities.contains(&cap),
+            NodeStatus::LocalNetwork(ln) => ln.capabilities.contains(&cap),
         }
     }
 }

veilid-core/src/rpc_processor/coders/node_info.rs

@@ -71,13 +71,11 @@ pub fn decode_node_info(reader: &veilid_capnp::node_info::Reader) -> Result<Node
             .map_err(RPCError::protocol)?,
     )?;
 
-    let envelope_support = reader
+    let es_reader = reader
         .reborrow()
         .get_envelope_support()
-        .map_err(RPCError::protocol)?
-        .as_slice()
-        .map(|s| s.to_vec())
-        .unwrap_or_default();
+        .map_err(RPCError::protocol)?;
+    let envelope_support = es_reader.as_slice().map(|s| s.to_vec()).unwrap_or_default();
 
     // Ensure envelope versions are not duplicated
     // Unsorted is okay, some nodes may have a different envelope order preference
@@ -94,10 +92,16 @@ pub fn decode_node_info(reader: &veilid_capnp::node_info::Reader) -> Result<Node
         return Err(RPCError::protocol("no envelope versions"));
     }
 
-    let crypto_support: Vec<CryptoKind> = reader
+    let cs_reader = reader
         .reborrow()
         .get_crypto_support()
-        .map_err(RPCError::protocol)?
+        .map_err(RPCError::protocol)?;
+
+    if cs_reader.len() as usize > MAX_CRYPTO_KINDS {
+        return Err(RPCError::protocol("too many crypto kinds"));
+    }
+
+    let crypto_support: Vec<CryptoKind> = cs_reader
         .as_slice()
         .map(|s| s.iter().map(|x| FourCC::from(x.to_be_bytes())).collect())
         .unwrap_or_default();

veilid-core/src/rpc_processor/coders/node_status.rs

@@ -4,44 +4,74 @@ pub fn encode_public_internet_node_status(
     public_internet_node_status: &PublicInternetNodeStatus,
     builder: &mut veilid_capnp::public_internet_node_status::Builder,
 ) -> Result<(), RPCError> {
-    builder.set_will_route(public_internet_node_status.will_route);
-    builder.set_will_tunnel(public_internet_node_status.will_tunnel);
-    builder.set_will_signal(public_internet_node_status.will_signal);
-    builder.set_will_relay(public_internet_node_status.will_relay);
-    builder.set_will_validate_dial_info(public_internet_node_status.will_validate_dial_info);
+    let mut cap_builder = builder
+        .reborrow()
+        .init_capabilities(public_internet_node_status.capabilities.len() as u32);
+    if let Some(s) = cap_builder.as_slice() {
+        let capvec: Vec<u32> = public_internet_node_status
+            .capabilities
+            .iter()
+            .map(|x| u32::from_be_bytes(x.0))
+            .collect();
 
+        s.clone_from_slice(&capvec);
+    }
     Ok(())
 }
 
 pub fn decode_public_internet_node_status(
     reader: &veilid_capnp::public_internet_node_status::Reader,
 ) -> Result<PublicInternetNodeStatus, RPCError> {
-    Ok(PublicInternetNodeStatus {
-        will_route: reader.reborrow().get_will_route(),
-        will_tunnel: reader.reborrow().get_will_tunnel(),
-        will_signal: reader.reborrow().get_will_signal(),
-        will_relay: reader.reborrow().get_will_relay(),
-        will_validate_dial_info: reader.reborrow().get_will_validate_dial_info(),
-    })
+    let cap_reader = reader
+        .reborrow()
+        .get_capabilities()
+        .map_err(RPCError::protocol)?;
+    if cap_reader.len() as usize > MAX_CAPABILITIES {
+        return Err(RPCError::protocol("too many capabilities"));
+    }
+    let capabilities = cap_reader
+        .as_slice()
+        .map(|s| s.iter().map(|x| FourCC::from(x.to_be_bytes())).collect())
+        .unwrap_or_default();
+
+    Ok(PublicInternetNodeStatus { capabilities })
 }
 
 pub fn encode_local_network_node_status(
     local_network_node_status: &LocalNetworkNodeStatus,
     builder: &mut veilid_capnp::local_network_node_status::Builder,
 ) -> Result<(), RPCError> {
-    builder.set_will_relay(local_network_node_status.will_relay);
-    builder.set_will_validate_dial_info(local_network_node_status.will_validate_dial_info);
+    let mut cap_builder = builder
+        .reborrow()
+        .init_capabilities(local_network_node_status.capabilities.len() as u32);
+    if let Some(s) = cap_builder.as_slice() {
+        let capvec: Vec<u32> = local_network_node_status
+            .capabilities
+            .iter()
+            .map(|x| u32::from_be_bytes(x.0))
+            .collect();
 
+        s.clone_from_slice(&capvec);
+    }
     Ok(())
 }
 
 pub fn decode_local_network_node_status(
     reader: &veilid_capnp::local_network_node_status::Reader,
 ) -> Result<LocalNetworkNodeStatus, RPCError> {
-    Ok(LocalNetworkNodeStatus {
-        will_relay: reader.reborrow().get_will_relay(),
-        will_validate_dial_info: reader.reborrow().get_will_validate_dial_info(),
-    })
+    let cap_reader = reader
+        .reborrow()
+        .get_capabilities()
+        .map_err(RPCError::protocol)?;
+    if cap_reader.len() as usize > MAX_CAPABILITIES {
+        return Err(RPCError::protocol("too many capabilities"));
+    }
+    let capabilities = cap_reader
+        .as_slice()
+        .map(|s| s.iter().map(|x| FourCC::from(x.to_be_bytes())).collect())
+        .unwrap_or_default();
+
+    Ok(LocalNetworkNodeStatus { capabilities })
 }
 
 pub fn encode_node_status(

veilid-core/src/rpc_processor/rpc_validate_dial_info.rs

@@ -105,7 +105,7 @@ impl RPCProcessor {
                     let entry = v.unwrap();
                     entry.with(rti, move |_rti, e| {
                         if let Some(status) = &e.node_status(routing_domain) {
-                            status.will_validate_dial_info()
+                            status.has_capability(CAP_WILL_VALIDATE_DIAL_INFO)
                         } else {
                             true
                         }

veilid-core/src/tests/common/test_veilid_config.rs

@@ -168,13 +168,7 @@ fn config_callback(key: String) -> ConfigCallbackReturn {
     match key.as_str() {
         "program_name" => Ok(Box::new(String::from("VeilidCoreTests"))),
         "namespace" => Ok(Box::new(String::from(""))),
-        "capabilities.protocol_udp" => Ok(Box::new(true)),
-        "capabilities.protocol_connect_tcp" => Ok(Box::new(true)),
-        "capabilities.protocol_accept_tcp" => Ok(Box::new(true)),
-        "capabilities.protocol_connect_ws" => Ok(Box::new(true)),
-        "capabilities.protocol_accept_ws" => Ok(Box::new(true)),
-        "capabilities.protocol_connect_wss" => Ok(Box::new(true)),
-        "capabilities.protocol_accept_wss" => Ok(Box::new(true)),
+        "capabilities.disable" => Ok(Box::new(Vec::<FourCC>::new())),
         "table_store.directory" => Ok(Box::new(get_table_store_path())),
         "table_store.delete" => Ok(Box::new(true)),
         "block_store.directory" => Ok(Box::new(get_block_store_path())),
@@ -299,13 +293,7 @@ pub async fn test_config() {
     let inner = vc.get();
     assert_eq!(inner.program_name, String::from("VeilidCoreTests"));
     assert_eq!(inner.namespace, String::from(""));
-    assert_eq!(inner.capabilities.protocol_udp, true);
-    assert_eq!(inner.capabilities.protocol_connect_tcp, true);
-    assert_eq!(inner.capabilities.protocol_accept_tcp, true);
-    assert_eq!(inner.capabilities.protocol_connect_ws, true);
-    assert_eq!(inner.capabilities.protocol_accept_ws, true);
-    assert_eq!(inner.capabilities.protocol_connect_wss, true);
-    assert_eq!(inner.capabilities.protocol_accept_wss, true);
+    assert_eq!(inner.capabilities.disable, Vec::<FourCC>::new());
     assert_eq!(inner.table_store.directory, get_table_store_path());
     assert_eq!(inner.table_store.delete, true);
     assert_eq!(inner.block_store.directory, get_block_store_path());

veilid-core/src/veilid_api/tests/fixtures.rs

@@ -76,13 +76,7 @@ pub fn fix_veilidconfiginner() -> VeilidConfigInner {
         program_name: "Bob".to_string(),
         namespace: "Internets".to_string(),
         capabilities: VeilidConfigCapabilities {
-            protocol_udp: false,
-            protocol_connect_tcp: true,
-            protocol_accept_tcp: false,
-            protocol_connect_ws: true,
-            protocol_accept_ws: false,
-            protocol_connect_wss: true,
-            protocol_accept_wss: false,
+            disable: Vec::new(),
         },
         protected_store: VeilidConfigProtectedStore {
             allow_insecure_fallback: true,

veilid-core/src/veilid_config.rs

@@ -468,13 +468,7 @@ pub struct VeilidConfigProtectedStore {
     JsonSchema,
 )]
 pub struct VeilidConfigCapabilities {
-    pub protocol_udp: bool,
-    pub protocol_connect_tcp: bool,
-    pub protocol_accept_tcp: bool,
-    pub protocol_connect_ws: bool,
-    pub protocol_accept_ws: bool,
-    pub protocol_connect_wss: bool,
-    pub protocol_accept_wss: bool,
+    pub disable: Vec<FourCC>,
 }
 
 #[derive(
@@ -670,13 +664,7 @@ impl VeilidConfig {
 
             get_config!(inner.program_name);
             get_config!(inner.namespace);
-            get_config!(inner.capabilities.protocol_udp);
-            get_config!(inner.capabilities.protocol_connect_tcp);
-            get_config!(inner.capabilities.protocol_accept_tcp);
-            get_config!(inner.capabilities.protocol_connect_ws);
-            get_config!(inner.capabilities.protocol_accept_ws);
-            get_config!(inner.capabilities.protocol_connect_wss);
-            get_config!(inner.capabilities.protocol_accept_wss);
+            get_config!(inner.capabilities.disable);
             get_config!(inner.table_store.directory);
             get_config!(inner.table_store.delete);
             get_config!(inner.block_store.directory);