Merge branch 'add-dynamic-store-callback-support'

faern · faern · commit ca23c24121d9 · 2017-11-29T17:50:45.000+01:00
diff --git a/system-configuration-sys/Cargo.toml b/system-configuration-sys/Cargo.toml
@@ -10,7 +10,7 @@ license = "MIT/Apache-2.0"
 build = "build.rs"
 
 [dependencies]
-core-foundation-sys = { git = "https://github.com/servo/core-foundation-rs", version = "0.4.4" }
+core-foundation-sys = "0.4.6"
 
 [build-dependencies]
 bindgen = "0.31"
diff --git a/system-configuration/Cargo.toml b/system-configuration/Cargo.toml
@@ -9,7 +9,7 @@ repository = "https://github.com/mullvad/system-configuration-rs"
 license = "MIT/Apache-2.0"
 
 [dependencies]
-core-foundation = { git = "https://github.com/servo/core-foundation-rs", version = "0.4.4" }
-core-foundation-sys = { git = "https://github.com/servo/core-foundation-rs", version = "0.4.4" }
+core-foundation = "0.4.6"
+core-foundation-sys = "0.4.6"
 
-system-configuration-sys = { path = "../system-configuration-sys" }
+system-configuration-sys = { path = "../system-configuration-sys", version = "0.1" }
diff --git a/system-configuration/src/bin/set_dns.rs b/system-configuration/src/bin/set_dns.rs
@@ -9,11 +9,11 @@ use core_foundation::base::TCFType;
 use core_foundation::dictionary::CFDictionary;
 use core_foundation::string::{CFString, CFStringRef};
 
-use system_configuration::dynamic_store::SCDynamicStore;
+use system_configuration::dynamic_store::SCDynamicStoreBuilder;
 
 fn main() {
     unsafe {
-        let store = SCDynamicStore::create("my-test-dyn-store");
+        let store = SCDynamicStoreBuilder::new("my-test-dyn-store").build();
         println!("Created dynamic store");
 
         let ipv4_dict = store
diff --git a/system-configuration/src/bin/watch_dns.rs b/system-configuration/src/bin/watch_dns.rs
@@ -0,0 +1,85 @@
+extern crate system_configuration;
+extern crate system_configuration_sys;
+
+extern crate core_foundation;
+extern crate core_foundation_sys;
+
+
+use core_foundation::array::CFArray;
+use core_foundation::dictionary::CFDictionary;
+use core_foundation::runloop::CFRunLoop;
+use core_foundation::string::CFString;
+use core_foundation_sys::runloop::kCFRunLoopCommonModes;
+
+use system_configuration::dynamic_store::{SCDynamicStore, SCDynamicStoreBuilder,
+                                          SCDynamicStoreCallBackContext};
+
+use std::env;
+
+#[derive(Debug)]
+struct Payload {
+    i: u64,
+    service_path: CFString,
+}
+
+impl Drop for Payload {
+    fn drop(&mut self) {
+        println!("Payload Drop");
+    }
+}
+
+fn main() {
+    let service_id = env::args()
+        .skip(1)
+        .next()
+        .expect("Give service uuid as first argument");
+    let service_path = CFString::from(&format!("State:/Network/Service/{}/DNS", service_id)[..]);
+
+    let watch_keys = CFArray::from_CFTypes(&[service_path.clone()]);
+    let watch_patterns: CFArray<CFString> = CFArray::from_CFTypes(&[]);
+
+    let callback_context = SCDynamicStoreCallBackContext {
+        callout: my_callback,
+        info: Payload {
+            i: 0,
+            service_path: service_path,
+        },
+    };
+
+    let store = SCDynamicStoreBuilder::new("my-watch-dns-store")
+        .callback_context(callback_context)
+        .build();
+    println!("Created dynamic store");
+
+    if store.set_notification_keys(&watch_keys, &watch_patterns) {
+        println!("Registered for notifications");
+    } else {
+        panic!("Unable to register notifications");
+    }
+    let run_loop_source = store.create_run_loop_source();
+
+    let run_loop = CFRunLoop::get_current();
+    run_loop.add_source(&run_loop_source, unsafe { kCFRunLoopCommonModes });
+    println!("Entering run loop");
+    CFRunLoop::run_current();
+}
+
+fn my_callback(store: SCDynamicStore, _changed_keys: CFArray<CFString>, payload: &mut Payload) {
+    println!("my_callback2 (payload: {:?})", payload);
+    payload.i += 1;
+
+    if payload.i > 1 {
+        // Only reset DNS on first callback for now. To not get stuck in infinite loop.
+        return;
+    }
+
+    let server_addresses_key = CFString::from_static_string("ServerAddresses");
+    let server_address_1 = CFString::from_static_string("192.168.1.1");
+    let server_addresses_value = CFArray::from_CFTypes(&[server_address_1]);
+
+    let dns_dictionary =
+        CFDictionary::from_CFType_pairs(&[(server_addresses_key, server_addresses_value)]);
+
+    let success = store.set(payload.service_path.clone(), &dns_dictionary);
+    println!("callback: {}", success);
+}
diff --git a/system-configuration/src/dynamic_store.rs b/system-configuration/src/dynamic_store.rs
@@ -6,18 +6,137 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use core_foundation::array::{CFArray, CFArrayRef};
 use core_foundation::base::TCFType;
 use core_foundation::boolean::CFBoolean;
 use core_foundation::dictionary::CFDictionary;
 use core_foundation::propertylist::{CFPropertyList, CFPropertyListSubClass};
+use core_foundation::runloop::CFRunLoopSource;
 use core_foundation::string::CFString;
 use core_foundation_sys::base::{CFRelease, kCFAllocatorDefault};
 
-use system_configuration_sys::dynamic_store::*;
+pub use system_configuration_sys::dynamic_store::*;
 
+use std::os::raw::c_void;
 use std::ptr;
 
+/// Struct describing the callback happening when a watched value in the dynamic store is changed.
+pub struct SCDynamicStoreCallBackContext<T> {
+    /// The callback function that will be called when a watched value in the dynamic store is
+    /// changed.
+    pub callout: SCDynamicStoreCallBackT<T>,
+
+    /// The argument passed to each `callout` call. Can be used to keep state between
+    /// callbacks.
+    pub info: T,
+}
+
+/// Signature for callback functions getting called when a watched value in the dynamic store is
+/// changed.
+///
+/// This is the safe callback definition, abstracting over the lower level `SCDynamicStoreCallBack`
+/// from the `system-configuration-sys` crate.
+pub type SCDynamicStoreCallBackT<T> = fn(
+    store: SCDynamicStore,
+    changed_keys: CFArray<CFString>,
+    info: &mut T,
+);
+
+/// Builder for [`SCDynamicStore`] sessions.
+///
+/// [`SCDynamicStore`]: struct.SCDynamicStore.html
+pub struct SCDynamicStoreBuilder<T> {
+    name: CFString,
+    session_keys: bool,
+    callback_context: Option<SCDynamicStoreCallBackContext<T>>,
+}
+
+impl SCDynamicStoreBuilder<()> {
+    /// Creates a new builder. `name` is used as the name parameter when creating the
+    /// [`SCDynamicStore`] session.
+    ///
+    /// [`SCDynamicStore`]: struct.SCDynamicStore.html
+    pub fn new<S: Into<CFString>>(name: S) -> Self {
+        SCDynamicStoreBuilder {
+            name: name.into(),
+            session_keys: false,
+            callback_context: None,
+        }
+    }
+}
+
+impl<T> SCDynamicStoreBuilder<T> {
+    /// Set wether or not the created [`SCDynamicStore`] should have session keys or not.
+    /// See [`SCDynamicStoreCreateWithOptions`] for details.
+    ///
+    /// Defaults to `false`.
+    ///
+    /// [`SCDynamicStore`]: struct.SCDynamicStore.html
+    /// [`SCDynamicStoreCreateWithOptions`]: https://developer.apple.com/documentation/systemconfiguration/1437818-scdynamicstorecreatewithoptions?language=objc
+    pub fn session_keys(mut self, session_keys: bool) -> Self {
+        self.session_keys = session_keys;
+        self
+    }
+
+    /// Set a callback context (callback function and data to pass to each callback call).
+    ///
+    /// Defaults to having callbacks disabled.
+    pub fn callback_context<T2>(
+        self,
+        callback_context: SCDynamicStoreCallBackContext<T2>,
+    ) -> SCDynamicStoreBuilder<T2> {
+        SCDynamicStoreBuilder {
+            name: self.name,
+            session_keys: self.session_keys,
+            callback_context: Some(callback_context),
+        }
+    }
+
+    /// Create the dynamic store session.
+    pub fn build(mut self) -> SCDynamicStore {
+        let store_options = self.create_store_options();
+        if let Some(callback_context) = self.callback_context.take() {
+            SCDynamicStore::create(
+                &self.name,
+                &store_options,
+                Some(convert_callback::<T>),
+                &mut self.create_context(callback_context),
+            )
+        } else {
+            SCDynamicStore::create(&self.name, &store_options, None, ptr::null_mut())
+        }
+    }
+
+    fn create_store_options(&self) -> CFDictionary {
+        let key = unsafe { CFString::wrap_under_create_rule(kSCDynamicStoreUseSessionKeys) };
+        let value = CFBoolean::from(self.session_keys);
+        CFDictionary::from_CFType_pairs(&[(key, value)])
+    }
+
+    fn create_context(
+        &self,
+        callback_context: SCDynamicStoreCallBackContext<T>,
+    ) -> SCDynamicStoreContext {
+        // move the callback context struct to the heap and "forget" it.
+        // It will later be brought back into the Rust typesystem and freed in
+        // `release_callback_context`
+        let info_ptr = Box::into_raw(Box::new(callback_context));
+
+        SCDynamicStoreContext {
+            version: 0,
+            info: info_ptr as *mut _ as *mut c_void,
+            retain: None,
+            release: Some(release_callback_context::<T>),
+            copyDescription: None,
+        }
+    }
+}
+
 /// Access to the key-value pairs in the dynamic store of a running system.
+///
+/// Use the [`SCDynamicStoreBuilder`] to create instances of this.
+///
+/// [`SCDynamicStoreBuilder`]: struct.SCDynamicStoreBuilder.html
 pub struct SCDynamicStore(SCDynamicStoreRef);
 
 impl Drop for SCDynamicStore {
@@ -31,39 +150,19 @@ impl_TCFType!(SCDynamicStore, SCDynamicStoreRef, SCDynamicStoreGetTypeID);
 impl SCDynamicStore {
     /// Creates a new session used to interact with the dynamic store maintained by the System
     /// Configuration server.
-    pub fn create<S: Into<CFString>>(name: S) -> Self {
-        let cf_name = name.into();
-        unsafe {
-            let store = SCDynamicStoreCreate(
-                kCFAllocatorDefault,
-                cf_name.as_concrete_TypeRef(),
-                None,
-                ptr::null_mut(),
-            );
-            SCDynamicStore::wrap_under_create_rule(store)
-        }
-    }
-
-    /// Creates a new session used to interact with the dynamic store maintained by the System
-    /// Configuration server. Uses [`SCDynamicStoreCreateWithOptions`] underneath and sets
-    /// `kSCDynamicStoreUseSessionKeys` to true.
-    ///
-    /// [`SCDynamicStoreCreateWithOptions`]: https://developer.apple.com/documentation/systemconfiguration/1437818-scdynamicstorecreatewithoptions?language=objc
-    pub fn create_with_session_keys<S: Into<CFString>>(name: S) -> Self {
-        let cf_name = name.into();
+    fn create(
+        name: &CFString,
+        store_options: &CFDictionary,
+        callout: SCDynamicStoreCallBack,
+        context: *mut SCDynamicStoreContext,
+    ) -> Self {
         unsafe {
-            let store_options = CFDictionary::from_CFType_pairs(&[
-                (
-                    CFString::wrap_under_create_rule(kSCDynamicStoreUseSessionKeys),
-                    CFBoolean::true_value(),
-                ),
-            ]);
             let store = SCDynamicStoreCreateWithOptions(
                 kCFAllocatorDefault,
-                cf_name.as_concrete_TypeRef(),
+                name.as_concrete_TypeRef(),
                 store_options.as_concrete_TypeRef(),
-                None,
-                ptr::null_mut(),
+                callout,
+                context,
             );
             SCDynamicStore::wrap_under_create_rule(store)
         }
@@ -108,4 +207,61 @@ impl SCDynamicStore {
         };
         success != 0
     }
+
+    pub fn remove<S: Into<CFString>>(&self, key: S) -> bool {
+        let cf_key = key.into();
+        let success = unsafe {
+            SCDynamicStoreRemoveValue(self.as_concrete_TypeRef(), cf_key.as_concrete_TypeRef())
+        };
+        success != 0
+    }
+
+    /// Specifies a set of keys and key patterns that should be monitored for changes.
+    pub fn set_notification_keys<T1, T2>(
+        &self,
+        keys: &CFArray<T1>,
+        patterns: &CFArray<T2>,
+    ) -> bool {
+        let success = unsafe {
+            SCDynamicStoreSetNotificationKeys(
+                self.as_concrete_TypeRef(),
+                keys.as_concrete_TypeRef(),
+                patterns.as_concrete_TypeRef(),
+            )
+        };
+        success != 0
+    }
+
+    /// Creates a run loop source object that can be added to the application's run loop.
+    pub fn create_run_loop_source(&self) -> CFRunLoopSource {
+        unsafe {
+            let run_loop_source_ref = SCDynamicStoreCreateRunLoopSource(
+                kCFAllocatorDefault,
+                self.as_concrete_TypeRef(),
+                0,
+            );
+            CFRunLoopSource::wrap_under_create_rule(run_loop_source_ref)
+        }
+    }
+}
+
+
+/// The raw callback used by the safe `SCDynamicStore` to convert from the `SCDynamicStoreCallBack`
+/// to the `SCDynamicStoreCallBackT`
+unsafe extern "C" fn convert_callback<T>(
+    store_ref: SCDynamicStoreRef,
+    changed_keys_ref: CFArrayRef,
+    context_ptr: *mut c_void,
+) {
+    let store = SCDynamicStore::wrap_under_get_rule(store_ref);
+    let changed_keys = CFArray::<CFString>::wrap_under_get_rule(changed_keys_ref);
+    let context = &mut *(context_ptr as *mut _ as *mut SCDynamicStoreCallBackContext<T>);
+
+    (context.callout)(store, changed_keys, &mut context.info);
+}
+
+// Release function called by core foundation on release of the dynamic store context.
+unsafe extern "C" fn release_callback_context<T>(context_ptr: *const c_void) {
+    // Bring back the context object from raw ptr so it is correctly freed.
+    let _context = Box::from_raw(context_ptr as *mut SCDynamicStoreCallBackContext<T>);
 }
