fix leak and mut modifier

Signed-off-by: tison <wander4096@gmail.com>

bindings/c/src/entry.rs

@@ -32,10 +32,10 @@ pub struct opendal_entry {
 }
 
 impl opendal_entry {
-    fn deref(&self) -> &mut core::Entry {
+    fn deref(&self) -> &core::Entry {
         // Safety: the inner should never be null once constructed
         // The use-after-free is undefined behavior
-        unsafe { &mut *(self.inner as *mut core::Entry) }
+        unsafe { &*(self.inner as *mut core::Entry) }
     }
 }
 
@@ -77,8 +77,8 @@ impl opendal_entry {
     #[no_mangle]
     pub unsafe extern "C" fn opendal_entry_free(ptr: *mut opendal_entry) {
         if !ptr.is_null() {
-            let _ = unsafe { Box::from_raw((*ptr).inner) };
-            let _ = unsafe { Box::from_raw(ptr) };
+            let _ = Box::from_raw((*ptr).inner as *mut core::Entry);
+            let _ = Box::from_raw(ptr);
         }
     }
 }

bindings/c/src/lister.rs

@@ -33,7 +33,7 @@ pub struct opendal_lister {
 }
 
 impl opendal_lister {
-    fn deref(&self) -> &mut core::BlockingLister {
+    fn deref_mut(&self) -> &mut core::BlockingLister {
         // Safety: the inner should never be null once constructed
         // The use-after-free is undefined behavior
         unsafe { &mut *(self.inner as *mut core::BlockingLister) }
@@ -56,7 +56,7 @@ impl opendal_lister {
     /// @see opendal_operator_list()
     #[no_mangle]
     pub unsafe extern "C" fn opendal_lister_next(&self) -> opendal_result_lister_next {
-        let e = self.deref().next();
+        let e = self.deref_mut().next();
         if e.is_none() {
             return opendal_result_lister_next {
                 entry: std::ptr::null_mut(),
@@ -83,8 +83,8 @@ impl opendal_lister {
     #[no_mangle]
     pub unsafe extern "C" fn opendal_lister_free(ptr: *mut opendal_lister) {
         if !ptr.is_null() {
-            let _ = unsafe { Box::from_raw((*ptr).inner) };
-            let _ = unsafe { Box::from_raw(ptr) };
+            let _ = Box::from_raw((*ptr).inner as *mut core::BlockingLister);
+            let _ = Box::from_raw(ptr);
         }
     }
 }

bindings/c/src/metadata.rs

@@ -35,10 +35,10 @@ pub struct opendal_metadata {
 }
 
 impl opendal_metadata {
-    fn deref(&self) -> &mut core::Metadata {
+    fn deref(&self) -> &core::Metadata {
         // Safety: the inner should never be null once constructed
         // The use-after-free is undefined behavior
-        unsafe { &mut *(self.inner as *mut core::Metadata) }
+        unsafe { &*(self.inner as *mut core::Metadata) }
     }
 }
 
@@ -55,8 +55,8 @@ impl opendal_metadata {
     #[no_mangle]
     pub unsafe extern "C" fn opendal_metadata_free(ptr: *mut opendal_metadata) {
         if !ptr.is_null() {
-            let _ = unsafe { Box::from_raw((*ptr).inner) };
-            let _ = unsafe { Box::from_raw(ptr) };
+            let _ = Box::from_raw((*ptr).inner as *mut core::Metadata);
+            let _ = Box::from_raw(ptr);
         }
     }
 

bindings/c/src/operator_info.rs

@@ -174,8 +174,8 @@ impl opendal_operator_info {
     #[no_mangle]
     pub unsafe extern "C" fn opendal_operator_info_free(ptr: *mut Self) {
         if !ptr.is_null() {
-            let _ = unsafe { Box::from_raw((*ptr).inner) };
-            let _ = unsafe { Box::from_raw(ptr) };
+            let _ = Box::from_raw((*ptr).inner as *mut core::OperatorInfo);
+            let _ = Box::from_raw(ptr);
         }
     }
 

bindings/c/src/reader.rs

@@ -32,7 +32,7 @@ pub struct opendal_reader {
 }
 
 impl opendal_reader {
-    fn deref(&self) -> &mut core::StdReader {
+    fn deref_mut(&self) -> &mut core::StdReader {
         // Safety: the inner should never be null once constructed
         // The use-after-free is undefined behavior
         unsafe { &mut *(self.inner as *mut core::StdReader) }
@@ -58,7 +58,7 @@ impl opendal_reader {
         }
 
         let buf = unsafe { std::slice::from_raw_parts_mut(buf, len) };
-        match self.deref().read(buf) {
+        match self.deref_mut().read(buf) {
             Ok(n) => opendal_result_reader_read {
                 size: n,
                 error: std::ptr::null_mut(),
@@ -77,8 +77,8 @@ impl opendal_reader {
     #[no_mangle]
     pub unsafe extern "C" fn opendal_reader_free(ptr: *mut opendal_reader) {
         if !ptr.is_null() {
-            let _ = unsafe { Box::from_raw((*ptr).inner) };
-            let _ = unsafe { Box::from_raw(ptr) };
+            let _ = Box::from_raw((*ptr).inner as *mut core::StdReader);
+            let _ = Box::from_raw(ptr);
         }
     }
 }

bindings/c/src/types.rs

@@ -150,8 +150,8 @@ impl opendal_operator_options {
     #[no_mangle]
     pub unsafe extern "C" fn opendal_operator_options_free(ptr: *mut opendal_operator_options) {
         if !ptr.is_null() {
-            let _ = unsafe { Box::from_raw((*ptr).inner) };
-            let _ = unsafe { Box::from_raw(ptr) };
+            let _ = Box::from_raw((*ptr).inner as *mut HashMap<String, String>);
+            let _ = Box::from_raw(ptr);
         }
     }
 }

bindings/c/src/writer.rs

@@ -29,7 +29,7 @@ pub struct opendal_writer {
 }
 
 impl opendal_writer {
-    fn deref(&self) -> &mut core::BlockingWriter {
+    fn deref_mut(&self) -> &mut core::BlockingWriter {
         // Safety: the inner should never be null once constructed
         // The use-after-free is undefined behavior
         unsafe { &mut *(self.inner as *mut core::BlockingWriter) }
@@ -50,7 +50,7 @@ impl opendal_writer {
         bytes: opendal_bytes,
     ) -> opendal_result_writer_write {
         let size = bytes.len;
-        match self.deref().write(bytes) {
+        match self.deref_mut().write(bytes) {
             Ok(()) => opendal_result_writer_write {
                 size,
                 error: std::ptr::null_mut(),
@@ -70,8 +70,8 @@ impl opendal_writer {
     #[no_mangle]
     pub unsafe extern "C" fn opendal_writer_free(ptr: *mut opendal_writer) {
         if !ptr.is_null() {
-            let _ = (&*ptr).deref().close();
-            let _ = unsafe { Box::from_raw((*ptr).inner) };
+            let _ = (&*ptr).deref_mut().close();
+            let _ = unsafe { Box::from_raw((*ptr).inner as *mut core::BlockingWriter) };
             let _ = unsafe { Box::from_raw(ptr) };
         }
     }