replace CString::new with CString::from_vec_unchecked in dav-rs code, to avoid unwrap

diff --git a/dav-rs/src/dav/context.rs b/dav-rs/src/dav/context.rs
index 0e00bde46e17899a0d3c1637aead48e5d0284f7d..7db4b9842aa7d06d070409a839f3dcccb1b9b449 100644 (file)
--- a/dav-rs/src/dav/context.rs
+++ b/dav-rs/src/dav/context.rs
@@ -42,9 +42,9 @@ impl DavContext {
     }
 
     pub fn add_namespace(&self, prefix: &str, namespace: &str) {
-        let prefix_cstr = CString::new(prefix).unwrap();
-        let ns_cstr = CString::new(namespace).unwrap();
         unsafe {
+            let prefix_cstr = CString::from_vec_unchecked(prefix.into());
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
             dav_add_namespace(self.ptr, prefix_cstr.as_ptr(), ns_cstr.as_ptr());
         }
     }

diff --git a/dav-rs/src/dav/resource.rs b/dav-rs/src/dav/resource.rs
index c0e01f7a8c2a3b52ba8c481e54a08bb649ffb47e..36466833568c3ae2fc6431fec4e5e1cea7a42e53 100644 (file)
--- a/dav-rs/src/dav/resource.rs
+++ b/dav-rs/src/dav/resource.rs
@@ -53,8 +53,8 @@ impl Resource<'_> {
     }
     
     pub fn new<'a>(sn: &Session, path: &str) -> Resource<'a> {
-        let path = CString::new(path).unwrap();
         unsafe {
+            let path = CString::from_vec_unchecked(path.into());
             let res = dav_resource_new(sn.ptr, path.as_ptr());
             Resource::from_ptr(res)
         }
@@ -315,84 +315,84 @@ impl<'a> ResourceRef<'a> {
     }
 
     pub fn get_property(&self, namespace: &str, name: &str) -> XmlNodeRef<'_> {
-        let ns_cstr = CString::new(namespace).unwrap();
-        let name_cstr = CString::new(name).unwrap();
         unsafe {
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
             let node_ptr = dav_get_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr());
             XmlNodeRef::from_ptr(node_ptr)
         }
     }
 
     pub fn get_prefixed_property(&self, prefixed_name: &str) -> XmlNodeRef<'_> {
-        let prefixed_name_cstr = CString::new(prefixed_name).unwrap();
         unsafe {
+            let prefixed_name_cstr = CString::from_vec_unchecked(prefixed_name.into());
             let node_ptr = dav_get_property(self.ptr, prefixed_name_cstr.as_ptr());
             XmlNodeRef::from_ptr(node_ptr)
         }
     }
 
     pub fn set_property(&self, namespace: &str, name: &str, value: &XmlNodeRef) {
-        let ns_cstr = CString::new(namespace).unwrap();
-        let name_cstr = CString::new(name).unwrap();
         unsafe {
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
             dav_set_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr(), value.ptr);
         }
     }
 
     pub fn set_prefixed_property(&self, prefixed_name: &str, value: &XmlNodeRef) {
-        let prefixed_name_cstr = CString::new(prefixed_name).unwrap();
         unsafe {
+            let prefixed_name_cstr = CString::from_vec_unchecked(prefixed_name.into());
             dav_set_property(self.ptr, prefixed_name_cstr.as_ptr(), value.ptr);
         }
     }
 
 
     pub fn set_string_property(&self, namespace: &str, name: &str, value: &str) {
-        let cstr_ns = CString::new(namespace).unwrap();
-        let cstr_name = CString::new(name).unwrap();
-        let cstr_value = CString::new(value).unwrap();
         unsafe {
-            dav_set_string_property_ns(self.ptr, cstr_ns.as_ptr(), cstr_name.as_ptr(), cstr_value.as_ptr());
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
+            let cstr_value = CString::from_vec_unchecked(value.into());
+            dav_set_string_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr(), cstr_value.as_ptr());
         }
     }
 
     pub fn set_string_prefixed_property(&self, prefixed_name: &str, value: &str) {
-        let cstr_name = CString::new(prefixed_name).unwrap();
-        let cstr_value = CString::new(value).unwrap();
         unsafe {
+            let cstr_name = CString::from_vec_unchecked(prefixed_name.into());
+            let cstr_value = CString::from_vec_unchecked(value.into());
             dav_set_string_property(self.ptr, cstr_name.as_ptr(), cstr_value.as_ptr());
         }
     }
 
     pub fn set_encrypted_property(&self, namespace: &str, name: &str, value: &XmlNodeRef) {
-        let ns_cstr = CString::new(namespace).unwrap();
-        let name_cstr = CString::new(name).unwrap();
         unsafe {
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
             dav_set_encrypted_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr(), value.ptr);
         }
     }
 
     pub fn set_encrypted_prefixed_property(&self, prefixed_name: &str, value: &XmlNodeRef) {
-        let prefixed_name_cstr = CString::new(prefixed_name).unwrap();
         unsafe {
+            let prefixed_name_cstr = CString::from_vec_unchecked(prefixed_name.into());
             dav_set_encrypted_property(self.ptr, prefixed_name_cstr.as_ptr(), value.ptr);
         }
     }
 
     pub fn set_encrypted_string_property(&self, namespace: &str, name: &str, value: &str) {
-        let cstr_ns = CString::new(namespace).unwrap();
-        let cstr_name = CString::new(name).unwrap();
-        let cstr_value = CString::new(value).unwrap();
         unsafe {
-            dav_set_encrypted_string_property_ns(self.ptr, cstr_ns.as_ptr(), cstr_name.as_ptr(), cstr_value.as_ptr());
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
+            let value_cstr = CString::from_vec_unchecked(value.into());
+            dav_set_encrypted_string_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr(), value_cstr.as_ptr());
         }
     }
 
     pub fn get_string_property(&self, namespace: &str, name: &str) -> Option<String> {
-        let cstr_ns = CString::new(namespace).unwrap();
-        let cstr_name = CString::new(name).unwrap();
         unsafe {
-            let value = dav_get_string_property_ns(self.ptr, cstr_ns.as_ptr(), cstr_name.as_ptr());
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
+            let value = dav_get_string_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr());
             if value.is_null() {
                 None
             } else {
@@ -402,8 +402,8 @@ impl<'a> ResourceRef<'a> {
     }
 
     pub fn get_string_prefixed_property(&self, prefixed_name: &str) -> Option<String> {
-        let cstr_name = CString::new(prefixed_name).unwrap();
         unsafe {
+            let cstr_name = CString::from_vec_unchecked(prefixed_name.into());
             let value = dav_get_string_property(self.ptr, cstr_name.as_ptr());
             if value.is_null() {
                 None
@@ -414,25 +414,25 @@ impl<'a> ResourceRef<'a> {
     }
 
     pub fn remove_property(&self, namespace: &str, name: &str) {
-        let cstr_ns = CString::new(namespace).unwrap();
-        let cstr_name = CString::new(name).unwrap();
         unsafe {
-            dav_remove_property_ns(self.ptr, cstr_ns.as_ptr(), cstr_name.as_ptr());
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
+            dav_remove_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr());
         }
     }
 
     pub fn remove_prefixed_property(&self, prefixed_name: &str) {
-        let cstr_name = CString::new(prefixed_name).unwrap();
         unsafe {
+            let cstr_name = CString::from_vec_unchecked(prefixed_name.into());
             dav_remove_property(self.ptr, cstr_name.as_ptr());
         }
     }
 
     pub fn remove_encrypted_property(&self, namespace: &str, name: &str) {
-        let cstr_ns = CString::new(namespace).unwrap();
-        let cstr_name = CString::new(name).unwrap();
         unsafe {
-            dav_remove_encrypted_property_ns(self.ptr, cstr_ns.as_ptr(), cstr_name.as_ptr());
+            let ns_cstr = CString::from_vec_unchecked(namespace.into());
+            let name_cstr = CString::from_vec_unchecked(name.into());
+            dav_remove_encrypted_property_ns(self.ptr, ns_cstr.as_ptr(), name_cstr.as_ptr());
         }
     }
 }
@@ -562,8 +562,8 @@ impl<'a> Iterator for Children<'a> {
 
 impl Session {
     pub fn new_resource<'a>(&self, path: &str) -> Resource<'a> {
-        let cstr = CString::new(path).unwrap();
         unsafe {
+            let cstr = CString::from_vec_unchecked(path.into());
             Resource {
                 base: ResourceRef {
                     ptr: dav_resource_new(self.ptr, cstr.as_ptr()),

diff --git a/dav-rs/src/dav/session.rs b/dav-rs/src/dav/session.rs
index 9e460fa617aeda3446d4aa1c1b3f63c93e4a1a25..4a5374b807ba42232927b6216b31a4d6ff145900 100644 (file)
--- a/dav-rs/src/dav/session.rs
+++ b/dav-rs/src/dav/session.rs
@@ -61,9 +61,9 @@ struct AuthCallbackWrapper {
 
 impl Session {
     pub fn set_auth(&self, user: &str, password: &str) {
-        let user_cstr = CString::new(user).unwrap();
-        let password_cstr = CString::new(password).unwrap();
         unsafe {
+            let user_cstr = CString::from_vec_unchecked(user.into());
+            let password_cstr = CString::from_vec_unchecked(password.into());
             dav_session_set_auth(self.ptr, user_cstr.as_ptr(), password_cstr.as_ptr());
         }
     }
@@ -102,8 +102,8 @@ extern "C" fn auth_callback_destructor(data: *mut c_void) {
 
 impl DavContext {
     pub fn create_session(&self, base_url: &str) -> Session {
-        let cstr = CString::new(base_url).unwrap();
         unsafe {
+            let cstr = CString::from_vec_unchecked(base_url.into());
             Session {
                 ptr: dav_session_new(self.ptr, cstr.as_ptr())
             }