Skip to main content

systemconfiguration/
network_services.rs

1use crate::{
2    bridge,
3    error::Result,
4    ffi,
5    network_interface::NetworkInterface,
6    network_protocol::NetworkProtocol,
7    preferences::Preferences,
8};
9
10#[derive(Clone, Debug)]
11pub struct NetworkService {
12    raw: bridge::OwnedHandle,
13}
14
15impl NetworkService {
16    pub fn copy_all(preferences: &Preferences) -> Vec<Self> {
17        let raw = unsafe { ffi::network_services::sc_network_service_copy_all(preferences.as_ptr()) };
18        bridge::take_handle_array(raw, Self::from_owned_handle)
19    }
20
21    pub fn copy_protocols(&self) -> Vec<NetworkProtocol> {
22        let raw = unsafe { ffi::network_services::sc_network_service_copy_protocols(self.raw.as_ptr()) };
23        bridge::take_handle_array(raw, NetworkProtocol::from_owned_handle)
24    }
25
26    pub fn copy_protocol(&self, protocol_type: &str) -> Result<Option<NetworkProtocol>> {
27        let protocol_type = bridge::cstring(protocol_type, "sc_network_service_copy_protocol")?;
28        let raw = unsafe {
29            ffi::network_services::sc_network_service_copy_protocol(self.raw.as_ptr(), protocol_type.as_ptr())
30        };
31        Ok(unsafe { bridge::OwnedHandle::from_raw(raw) }.map(NetworkProtocol::from_owned_handle))
32    }
33
34    pub fn add_protocol_type(&self, protocol_type: &str) -> Result<()> {
35        let protocol_type = bridge::cstring(protocol_type, "sc_network_service_add_protocol_type")?;
36        let ok = unsafe {
37            ffi::network_services::sc_network_service_add_protocol_type(self.raw.as_ptr(), protocol_type.as_ptr())
38        };
39        bridge::bool_result("sc_network_service_add_protocol_type", ok)
40    }
41
42    pub fn establish_default_configuration(&self) -> Result<()> {
43        let ok = unsafe {
44            ffi::network_services::sc_network_service_establish_default_configuration(self.raw.as_ptr())
45        };
46        bridge::bool_result("sc_network_service_establish_default_configuration", ok)
47    }
48
49    pub fn is_enabled(&self) -> bool {
50        unsafe { ffi::network_services::sc_network_service_get_enabled(self.raw.as_ptr()) != 0 }
51    }
52
53    pub fn interface(&self) -> Option<NetworkInterface> {
54        unsafe {
55            bridge::OwnedHandle::from_raw(ffi::network_services::sc_network_service_copy_interface(
56                self.raw.as_ptr(),
57            ))
58        }
59        .map(NetworkInterface::from_owned_handle)
60    }
61
62    pub fn name(&self) -> Result<Option<String>> {
63        Ok(bridge::take_optional_string(unsafe {
64            ffi::network_services::sc_network_service_copy_name(self.raw.as_ptr())
65        }))
66    }
67
68    pub fn service_id(&self) -> Result<Option<String>> {
69        Ok(bridge::take_optional_string(unsafe {
70            ffi::network_services::sc_network_service_copy_service_id(self.raw.as_ptr())
71        }))
72    }
73
74    pub fn remove(&self) -> Result<()> {
75        let ok = unsafe { ffi::network_services::sc_network_service_remove(self.raw.as_ptr()) };
76        bridge::bool_result("sc_network_service_remove", ok)
77    }
78
79    pub fn remove_protocol_type(&self, protocol_type: &str) -> Result<()> {
80        let protocol_type = bridge::cstring(protocol_type, "sc_network_service_remove_protocol_type")?;
81        let ok = unsafe {
82            ffi::network_services::sc_network_service_remove_protocol_type(
83                self.raw.as_ptr(),
84                protocol_type.as_ptr(),
85            )
86        };
87        bridge::bool_result("sc_network_service_remove_protocol_type", ok)
88    }
89
90    pub fn set_enabled(&self, enabled: bool) -> Result<()> {
91        let ok = unsafe {
92            ffi::network_services::sc_network_service_set_enabled(self.raw.as_ptr(), u8::from(enabled))
93        };
94        bridge::bool_result("sc_network_service_set_enabled", ok)
95    }
96
97    pub fn set_name(&self, name: Option<&str>) -> Result<()> {
98        let name = bridge::optional_cstring(name, "sc_network_service_set_name")?;
99        let ok = unsafe {
100            ffi::network_services::sc_network_service_set_name(
101                self.raw.as_ptr(),
102                name.as_ref().map_or(std::ptr::null(), |value| value.as_ptr()),
103            )
104        };
105        bridge::bool_result("sc_network_service_set_name", ok)
106    }
107
108    pub(crate) fn from_owned_handle(raw: bridge::OwnedHandle) -> Self {
109        Self { raw }
110    }
111
112    pub(crate) fn as_ptr(&self) -> bridge::RawHandle {
113        self.raw.as_ptr()
114    }
115}