feat: add log-server (ring buffer) and permission-manager (grant/revoke/check) system servers

crates/servers/permission-manager/src/protocol.rs

@@ -0,0 +1,127 @@
+use server_framework::{Decode, Encode};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CapabilityKind {
+    Display,
+    Input,
+    AudioPlayback,
+    AudioCapture,
+    Camera,
+    Storage,
+    Network,
+    Gps,
+    Bluetooth,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum PermissionRequest {
+    RequestCapability { process: u16, kind: CapabilityKind },
+    RevokeCapability { process: u16, kind: CapabilityKind },
+    CheckCapability { process: u16, kind: CapabilityKind },
+    ListGranted { process: u16 },
+}
+
+#[derive(Debug, PartialEq)]
+pub enum PermissionResponse {
+    Granted,
+    Denied,
+    Revoked,
+    HasCapability(bool),
+    GrantedList(u16),
+}
+
+fn encode_kind(kind: CapabilityKind) -> usize {
+    match kind {
+        CapabilityKind::Display => 0,
+        CapabilityKind::Input => 1,
+        CapabilityKind::AudioPlayback => 2,
+        CapabilityKind::AudioCapture => 3,
+        CapabilityKind::Camera => 4,
+        CapabilityKind::Storage => 5,
+        CapabilityKind::Network => 6,
+        CapabilityKind::Gps => 7,
+        CapabilityKind::Bluetooth => 8,
+    }
+}
+
+fn decode_kind(v: usize) -> Option<CapabilityKind> {
+    match v {
+        0 => Some(CapabilityKind::Display),
+        1 => Some(CapabilityKind::Input),
+        2 => Some(CapabilityKind::AudioPlayback),
+        3 => Some(CapabilityKind::AudioCapture),
+        4 => Some(CapabilityKind::Camera),
+        5 => Some(CapabilityKind::Storage),
+        6 => Some(CapabilityKind::Network),
+        7 => Some(CapabilityKind::Gps),
+        8 => Some(CapabilityKind::Bluetooth),
+        _ => None,
+    }
+}
+
+impl Encode for PermissionRequest {
+    fn encode(&self) -> [usize; 4] {
+        match self {
+            PermissionRequest::RequestCapability { process, kind } => {
+                [0, *process as usize, encode_kind(*kind), 0]
+            }
+            PermissionRequest::RevokeCapability { process, kind } => {
+                [1, *process as usize, encode_kind(*kind), 0]
+            }
+            PermissionRequest::CheckCapability { process, kind } => {
+                [2, *process as usize, encode_kind(*kind), 0]
+            }
+            PermissionRequest::ListGranted { process } => {
+                [3, *process as usize, 0, 0]
+            }
+        }
+    }
+}
+
+impl Decode for PermissionRequest {
+    fn decode(words: [usize; 4]) -> Option<Self> {
+        match words[0] {
+            0 => Some(PermissionRequest::RequestCapability {
+                process: words[1] as u16,
+                kind: decode_kind(words[2])?,
+            }),
+            1 => Some(PermissionRequest::RevokeCapability {
+                process: words[1] as u16,
+                kind: decode_kind(words[2])?,
+            }),
+            2 => Some(PermissionRequest::CheckCapability {
+                process: words[1] as u16,
+                kind: decode_kind(words[2])?,
+            }),
+            3 => Some(PermissionRequest::ListGranted {
+                process: words[1] as u16,
+            }),
+            _ => None,
+        }
+    }
+}
+
+impl Encode for PermissionResponse {
+    fn encode(&self) -> [usize; 4] {
+        match self {
+            PermissionResponse::Granted => [0, 0, 0, 0],
+            PermissionResponse::Denied => [1, 0, 0, 0],
+            PermissionResponse::Revoked => [2, 0, 0, 0],
+            PermissionResponse::HasCapability(has) => [3, *has as usize, 0, 0],
+            PermissionResponse::GrantedList(bits) => [4, *bits as usize, 0, 0],
+        }
+    }
+}
+
+impl Decode for PermissionResponse {
+    fn decode(words: [usize; 4]) -> Option<Self> {
+        match words[0] {
+            0 => Some(PermissionResponse::Granted),
+            1 => Some(PermissionResponse::Denied),
+            2 => Some(PermissionResponse::Revoked),
+            3 => Some(PermissionResponse::HasCapability(words[1] != 0)),
+            4 => Some(PermissionResponse::GrantedList(words[1] as u16)),
+            _ => None,
+        }
+    }
+}