128 lines
3.8 KiB
Rust
128 lines
3.8 KiB
Rust
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,
|
|
}
|
|
}
|
|
}
|