Update

Author: luozijun

system-configuration/examples/set_dns.rs

@@ -1,10 +1,17 @@
+extern crate core_foundation;
 extern crate system_configuration;
 
+use core_foundation::base::kCFAllocatorDefault;
+
+
 use system_configuration::dynamic_store::SCDynamicStoreBuilder;
 use system_configuration::network_configuration::SCNetworkService;
+use system_configuration::preferences::SCPreferences;
+
 
 use std::net::{IpAddr, Ipv4Addr};
 
+
 // This example will change the DNS settings on the primary
 // network interface to 8.8.8.8 and 8.8.4.4
 
@@ -19,9 +26,12 @@ fn main() {
         IpAddr::V4(Ipv4Addr::new(8, 8, 4, 4)),
     ];
 
-    let store = SCDynamicStoreBuilder::new("session_name").build();
+    let session_name = "session_name";
+    let store = SCDynamicStoreBuilder::new(session_name).build();
+    let prefs = SCPreferences::new(unsafe { kCFAllocatorDefault }, session_name, None);
 
-    let global_service = SCNetworkService::global(&store).expect("No PrimaryService active");
+    let global_service =
+        SCNetworkService::global(&prefs, &store).expect("No PrimaryService active");
     let global_interface = global_service
         .interface()
         .expect("No PrimaryInterface active");
@@ -46,9 +56,7 @@ fn main() {
     );
 
     // Check
-    // networksetup -getdnsservers "Wi-Fi"
-    // scutil --dns
-    // dig
+    // `networksetup -getdnsservers "Wi-Fi"` Or `scutil --dns` Or `dig`
     println!("{:?}", global_service.dns(&store));
 
     println!(

system-configuration/src/lib.rs

@@ -24,4 +24,5 @@ extern crate core_foundation;
 extern crate system_configuration_sys;
 
 pub mod dynamic_store;
+pub mod preferences;
 pub mod network_configuration;

system-configuration/src/network_configuration.rs

@@ -12,17 +12,18 @@
 //!
 //! [`SCNetworkConfiguration`]: https://developer.apple.com/documentation/systemconfiguration/scnetworkconfiguration
 
+
 use core_foundation::array::CFArray;
 use core_foundation::base::{CFType, TCFType};
-use core_foundation::base::kCFAllocatorDefault;
 use core_foundation::dictionary::CFDictionary;
 use core_foundation::string::CFString;
 
 use dynamic_store::SCDynamicStore;
+use preferences::SCPreferences;
+
 pub use system_configuration_sys::network_configuration::*;
-use system_configuration_sys::preferences::SCPreferencesCreate;
 
-use std::{fmt, ptr};
+use std::fmt;
 use std::net::IpAddr;
 
 /// MTU
@@ -100,48 +101,45 @@ impl_TCFType!(
 
 impl SCNetworkService {
     /// Returns primary network service
-    pub fn global(store: &SCDynamicStore) -> Option<Self> {
-        if let Some(service_id) = global_query(store, "PrimaryService") {
-            for service in SCNetworkService::list() {
-                if service.id() == service_id {
-                    return Some(service);
-                }
-            }
+    pub fn global(prefs: &SCPreferences, store: &SCDynamicStore) -> Option<Self> {
+        match global_query(store, "PrimaryService") {
+            Some(service_id) => SCNetworkService::from_id(prefs, &service_id),
+            None => None,
         }
-
-        return None;
     }
 
-    /// Returns all available network services for the specified preferences.
-    pub fn list() -> Vec<SCNetworkService> {
-        let prefs = unsafe {
-            SCPreferencesCreate(
-                kCFAllocatorDefault,
-                CFString::from_static_string("ns_list").as_concrete_TypeRef(),
-                ptr::null(),
+    /// Returns network service for the specified preferences session and service ID.
+    pub fn from_id(prefs: &SCPreferences, service_id: &str) -> Option<SCNetworkService> {
+        let network_service_ref = unsafe {
+            SCNetworkServiceCopy(
+                prefs.as_concrete_TypeRef(),
+                CFString::new(service_id).as_concrete_TypeRef(),
             )
         };
 
-        let array: CFArray<CFType> =
-            unsafe { CFArray::wrap_under_get_rule(SCNetworkServiceCopyAll(prefs)) };
+        if network_service_ref.is_null() {
+            None
+        } else {
+            Some(unsafe { SCNetworkService::wrap_under_get_rule(network_service_ref) })
+        }
+    }
+
+    /// Returns all available network services for the specified preferences.
+    pub fn list(prefs: &SCPreferences) -> Vec<SCNetworkService> {
+        let array: CFArray<CFType> = unsafe {
+            CFArray::wrap_under_get_rule(SCNetworkServiceCopyAll(prefs.as_concrete_TypeRef()))
+        };
 
         array
             .iter()
             .map(|item| item.downcast::<SCNetworkService>().unwrap())
             .collect::<Vec<SCNetworkService>>()
     }
 
-    /// Returns the user-specified ordering of network services within the specified set.
-    pub fn list_order() -> Vec<SCNetworkService> {
-        let prefs = unsafe {
-            SCPreferencesCreate(
-                kCFAllocatorDefault,
-                CFString::from_static_string("ns_list_order").as_concrete_TypeRef(),
-                ptr::null(),
-            )
-        };
-
-        let netset = unsafe { SCNetworkSetCopyCurrent(prefs) };
+    /// Returns the user-specified ordering of network services within the specified
+    /// preferences.
+    pub fn list_order(prefs: &SCPreferences) -> Vec<SCNetworkService> {
+        let netset = unsafe { SCNetworkSetCopyCurrent(prefs.as_concrete_TypeRef()) };
 
         let array: CFArray<CFType> =
             unsafe { CFArray::wrap_under_get_rule(SCNetworkSetGetServiceOrder(netset)) };
@@ -150,13 +148,8 @@ impl SCNetworkService {
 
         for item in array.iter() {
             if let Some(id) = item.downcast::<CFString>() {
-                let service_ref = unsafe {
-                    CFType::wrap_under_get_rule(SCNetworkServiceCopy(
-                        prefs,
-                        id.as_concrete_TypeRef(),
-                    ))
-                };
-                if let Some(serv) = service_ref.downcast::<SCNetworkService>() {
+                println!("id: {:?}", id);
+                if let Some(serv) = SCNetworkService::from_id(prefs, id.to_string().as_str()) {
                     services.push(serv);
                 }
             }

system-configuration/src/preferences.rs

@@ -0,0 +1,49 @@
+// Copyright 2017 Amagicom AB.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Bindings to [`SCPreferences`].
+//!
+//! See the examples directory for examples how to use this module.
+//!
+//! [`SCPreferences`]: https://developer.apple.com/documentation/systemconfiguration/scpreferences
+
+
+use core_foundation::base::CFAllocatorRef;
+use core_foundation::base::TCFType;
+use core_foundation::string::CFString;
+
+pub use system_configuration_sys::preferences::*;
+
+use std::ptr;
+
+
+declare_TCFType!{
+    /// The handle to an open preferences session for accessing system configuration preferences.
+    SCPreferences, SCPreferencesRef
+}
+
+impl_TCFType!(SCPreferences, SCPreferencesRef, SCPreferencesGetTypeID);
+
+
+impl SCPreferences {
+    /// Initiates access to the per-system set of configuration preferences.
+    pub fn new(allocator: CFAllocatorRef, name: &str, prefs_id: Option<&str>) -> Self {
+        let prefs_id = match prefs_id {
+            Some(prefs_id) => CFString::new(prefs_id).as_concrete_TypeRef(),
+            None => ptr::null(),
+        };
+
+        unsafe {
+            SCPreferences::wrap_under_get_rule(SCPreferencesCreate(
+                allocator,
+                CFString::new(name).as_concrete_TypeRef(),
+                prefs_id,
+            ))
+        }
+    }
+}