Merge pull request #45 from ustulation/MAID-1319

Maid 1319

.gitignore

@@ -1,20 +1,34 @@
-# Compiled files
+# Executables
+*.exe
+*.out
+
+# Libraires and Objects
 *.o
+*.a
 *.so
-*.rlib
+*.lo
+*.lib
 *.dll
-
-# Executables
-*.exe
+*.rlib
+*.dylib
 
 # Generated by Cargo
-*.lock
-*.swp
+bin/
 tags*
+*.lock
 build/
-build-tests/
 target/
-/bin
+build-tests/
+
+# Generated by Editors
+~*
+*.swp
+*.sublime-*
 
 # Manual
-.cargo/*
+.cargo/
+
+# Misc
+packages/
+.DS_Store
+*.bootstrap.cache

examples/simulate_browser.rs

@@ -259,10 +259,15 @@ fn parse_url_and_get_home_page(client        : std::sync::Arc<std::sync::Mutex<s
 
 fn main() {
     let client = handle_login();
+    let unregistered_client = ::std::sync::Arc::new(::std::sync::Mutex::new(eval_result!(::safe_client
+                                                                                         ::client
+                                                                                         ::Client
+                                                                                         ::create_unregistered_client())));
     println!("Account Login Successful !!");
 
     println!("Initialising Dns...");
     let dns_operations = eval_result!(safe_dns::dns_operations::DnsOperations::new(client.clone()));
+    let dns_operations_unregistered = safe_dns::dns_operations::DnsOperations::new_unregistered(unregistered_client.clone());
 
     let mut user_option = String::new();
 
@@ -299,10 +304,11 @@ fn main() {
                 5 => if let Err(err) = remove_service(client.clone(), &dns_operations) {
                     error = Some(err);
                 },
-                6 => if let Err(err) = display_services(&dns_operations) {
+                6 => if let Err(err) = display_services(&dns_operations_unregistered) {
                     error = Some(err);
                 },
-                7 => if let Err(err) = parse_url_and_get_home_page(client.clone(), &dns_operations) {
+                7 => if let Err(err) = parse_url_and_get_home_page(unregistered_client.clone(),
+                                                                   &dns_operations_unregistered) {
                     error = Some(err);
                 },
                 8 => break,

src/dns_operations/dns_configuration.rs

@@ -35,7 +35,7 @@ pub fn initialise_dns_configuaration(client: ::std::sync::Arc<::std::sync::Mutex
             let _ = try!(writer.close());
             Ok(())
         },
-        Err(::safe_nfs::errors::NfsError::AlreadyExists) => Ok(()),
+        Err(::safe_nfs::errors::NfsError::FileAlreadyExistsWithSameName) => Ok(()),
         Err(error) => Err(::errors::DnsError::from(error)),
     }
 }
@@ -61,7 +61,7 @@ pub fn write_dns_configuaration_data(client: ::std::sync::Arc<::std::sync::Mutex
     let dir_listing = try!(dir_helper.get_configuration_directory_listing(DNS_CONFIG_DIR_NAME.to_string()));
     let file = try!(dir_listing.get_files().iter().find(|file| file.get_name() == DNS_CONFIG_FILE_NAME).ok_or(::errors::DnsError::DnsConfigFileNotFoundOrCorrupted)).clone();
     let file_helper = ::safe_nfs::helper::file_helper::FileHelper::new(client.clone());
-    let mut writer = try!(file_helper.update(file, ::safe_nfs::helper::writer::Mode::Overwrite, dir_listing));
+    let mut writer = try!(file_helper.update_content(file, ::safe_nfs::helper::writer::Mode::Overwrite, dir_listing));
     debug!("Writing dns configuration data ...");
     writer.write(&try!(::safe_client::utility::serialise(&config)), 0);
     let _ = try!(writer.close());

src/dns_operations/mod.rs

@@ -17,7 +17,7 @@
 
 mod dns_configuration;
 
-const DNS_TAG: u64 = 5; // TODO Get from routing
+const DNS_TAG: u64 = 5;
 
 /// This is a representational structure for all safe-dns operations
 pub struct DnsOperations {
@@ -66,8 +66,8 @@ impl DnsOperations {
 
             let dns_record = Dns {
                 long_name     : long_name.clone(),
-                encryption_key: public_messaging_encryption_key.clone(),
                 services      : services.iter().map(|a| a.clone()).collect(),
+                encryption_key: public_messaging_encryption_key.clone(),
             };
 
             debug!("Adding encryption key pair to saved dns configuration ...");
@@ -134,7 +134,13 @@ impl DnsOperations {
                             data_decryption_keys: Option<(&::sodiumoxide::crypto::box_::PublicKey,
                                                           &::sodiumoxide::crypto::box_::SecretKey,
                                                           &::sodiumoxide::crypto::box_::Nonce)>) -> Result<Vec<String>, ::errors::DnsError> {
-        let _ = try!(self.find_dns_record(long_name));
+        // Allow unregistered clients to access this function
+        match self.find_dns_record(long_name) {
+            Ok(_) => (),
+            Err(::errors::DnsError::ClientError(::safe_client::errors::ClientError::OperationForbiddenForClient)) => (),
+            Err(::errors::DnsError::NfsError(::safe_nfs::errors::NfsError::ClientError(::safe_client::errors::ClientError::OperationForbiddenForClient))) => (),
+            Err(error) => return Err(error),
+        };
 
         let (_, dns_record) = try!(self.get_housing_sturctured_data_and_dns_record(long_name, data_decryption_keys));
         Ok(dns_record.services.keys().map(|a| a.clone()).collect())
@@ -147,6 +153,14 @@ impl DnsOperations {
                                           data_decryption_keys: Option<(&::sodiumoxide::crypto::box_::PublicKey,
                                                                         &::sodiumoxide::crypto::box_::SecretKey,
                                                                         &::sodiumoxide::crypto::box_::Nonce)>) -> Result<::safe_nfs::metadata::directory_key::DirectoryKey, ::errors::DnsError> {
+        // Allow unregistered clients to access this function
+        match self.find_dns_record(long_name) {
+            Ok(_) => (),
+            Err(::errors::DnsError::ClientError(::safe_client::errors::ClientError::OperationForbiddenForClient)) => (),
+            Err(::errors::DnsError::NfsError(::safe_nfs::errors::NfsError::ClientError(::safe_client::errors::ClientError::OperationForbiddenForClient))) => (),
+            Err(error) => return Err(error),
+        };
+
         let (_, dns_record) = try!(self.get_housing_sturctured_data_and_dns_record(long_name, data_decryption_keys));
         dns_record.services.get(service_name).map(|v| v.clone()).ok_or(::errors::DnsError::ServiceNotFound)
     }
@@ -245,8 +259,8 @@ impl DnsOperations {
 #[derive(Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable)]
 struct Dns {
     long_name     : String,
-    encryption_key: ::sodiumoxide::crypto::box_::PublicKey,
     services      : ::std::collections::HashMap<String, ::safe_nfs::metadata::directory_key::DirectoryKey>,
+    encryption_key: ::sodiumoxide::crypto::box_::PublicKey,
 }
 
 #[cfg(test)]
@@ -349,8 +363,12 @@ mod test {
         let dns_records_vec = eval_result!(dns_operations.get_all_registered_names());
         assert_eq!(dns_records_vec.len(), 1);
 
+        // Gets should be possible with unregistered clients
+        let unregistered_client = ::std::sync::Arc::new(::std::sync::Mutex::new(eval_result!(::safe_client::client::Client::create_unregistered_client())));
+        let dns_operations_unregistered = DnsOperations::new_unregistered(unregistered_client);
+
         // Get all services for a dns-name
-        let services_vec = eval_result!(dns_operations.get_all_services(&dns_name, None));
+        let services_vec = eval_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
         assert_eq!(services.len(), services_vec.len());
         assert!(services.iter().all(|&(ref a, _)| services_vec.iter().find(|b| *a == **b).is_some()));
 
@@ -362,7 +380,7 @@ mod test {
         // }
 
         // Get information about a service - the home-directory and its type
-        let home_dir_key = eval_result!(dns_operations.get_service_home_directory_key(&dns_name, &services[1].0, None));
+        let home_dir_key = eval_result!(dns_operations_unregistered.get_service_home_directory_key(&dns_name, &services[1].0, None));
         assert_eq!(home_dir_key, services[1].1);
 
         // Remove a service
@@ -371,7 +389,7 @@ mod test {
         eval_result!(client.lock()).post(::routing::data::Data::StructuredData(struct_data), None);
 
         // Get all services
-        let services_vec = eval_result!(dns_operations.get_all_services(&dns_name, None));
+        let services_vec = eval_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
         assert_eq!(services.len(), services_vec.len());
         assert!(services.iter().all(|&(ref a, _)| services_vec.iter().find(|b| *a == **b).is_some()));
 
@@ -384,13 +402,17 @@ mod test {
         // }
 
         // Add a service
-        services.push(("added-service".to_string(), ::safe_nfs::metadata::directory_key::DirectoryKey::new(::routing::NameType::new([126; 64]), 15000, false, ::safe_nfs::AccessLevel::Private)));
+        services.push(("added-service".to_string(),
+                       ::safe_nfs::metadata::directory_key::DirectoryKey::new(::routing::NameType::new([126; 64]),
+                                                                              15000,
+                                                                              false,
+                                                                              ::safe_nfs::AccessLevel::Public)));
         let services_size = services.len();
         struct_data = eval_result!(dns_operations.add_service(&dns_name, services[services_size - 1].clone(), &secret_signing_key, None));
         eval_result!(client.lock()).post(::routing::data::Data::StructuredData(struct_data), None);
 
         // Get all services
-        let services_vec = eval_result!(dns_operations.get_all_services(&dns_name, None));
+        let services_vec = eval_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
         assert_eq!(services.len(), services_vec.len());
         assert!(services.iter().all(|&(ref a, _)| services_vec.iter().find(|b| *a == **b).is_some()));
     }

src/lib.rs

@@ -30,7 +30,7 @@
 #![deny(deprecated, improper_ctypes, missing_docs, non_shorthand_field_patterns,
 overflowing_literals, plugin_as_library, private_no_mangle_fns, private_no_mangle_statics,
 raw_pointer_derive, stable_features, unconditional_recursion, unknown_lints, unsafe_code,
-unused, unused_allocation, unused_attributes, unused_comparisons,
+unused, unused_mut, unused_allocation, unused_attributes, unused_comparisons,
 unused_features, unused_parens, while_true)]
 
 #![warn(trivial_casts, trivial_numeric_casts, unused_extern_crates, unused_import_braces,
@@ -39,6 +39,11 @@ unused_qualifications, variant_size_differences)]
 ///////////////////////////////////////////////////
 
 //! #Safe-Dns Library
+//! This crate allows registered clients to create, delete and manipulate their DNS records in the
+//! SAFE-Network while allowing unregistered clients (like browers designed for SAFE-Network) to
+//! access and display the contents of such records, if it were created with Public Accessibility,
+//! ie., non-encrypted content.
+//!
 //! [Project github page](https://github.com/maidsafe/safe_dns)
 
 extern crate routing;