I created a prototype locally, which is roughly structured as follows:

diff --git a/bindings/c/src/reader.rs b/bindings/c/src/reader.rs
index 1c34658e..4e56403b 100644
--- a/bindings/c/src/reader.rs
+++ b/bindings/c/src/reader.rs
@@ -16,12 +16,16 @@
 // under the License.
 
 use std::ffi::c_void;
-use std::io::Read;
+use std::io::{Read, Seek, SeekFrom};
 
 use ::opendal as core;
 
 use super::*;
 
+pub const OPENDAL_SEEK_SET: i32 = 0;
+pub const OPENDAL_SEEK_CUR: i32 = 1;
+pub const OPENDAL_SEEK_END: i32 = 2;
+
 /// \brief The result type returned by opendal's reader operation.
 ///
 /// \note The opendal_reader actually owns a pointer to
@@ -72,6 +76,33 @@ impl opendal_reader {
         }
     }
 
+    /// \brief Seek to an offset, in bytes, in a stream.
+    #[no_mangle]
+    pub unsafe extern "C" fn opendal_reader_seek(
+        &mut self,
+        offset: i64,
+        whence: i32,
+    ) -> *mut opendal_error {
+        let pos = match whence {
+            _x @ OPENDAL_SEEK_SET => SeekFrom::Start(offset as u64),
+            _x @ OPENDAL_SEEK_CUR => SeekFrom::Current(offset),
+            _x @ OPENDAL_SEEK_END => SeekFrom::End(offset),
+            _ => {
+                return opendal_error::new(core::Error::new(
+                    core::ErrorKind::Unexpected,
+                    "undefined whence",
+                ))
+            }
+        };
+
+        match self.deref_mut().seek(pos) {
+            Ok(_) => std::ptr::null_mut(),
+            Err(e) => {
+                opendal_error::new(core::Error::new(core::ErrorKind::Unexpected, e.to_string()))
+            }
+        }
+    }
+
     /// \brief Frees the heap memory used by the opendal_reader.
     #[no_mangle]
     pub unsafe extern "C" fn opendal_reader_free(ptr: *mut opendal_reader) {

Explanation of the Code:
1. Why are OPENDAL_SEEK_SET, OPENDAL_SEEK_CUR, and OPENDAL_SEEK_END defined separately?
These macros are defined to generate corresponding #define definitions in C.
Why assign specific values here instead of directly using the definitions from <stdio.h>?
I noticed that the C standard does not define the numerical values for these three macros; it only defines their names. This makes me worry about potential cross-platform issues.

2.
3. Why is an unused _x used in the match statement?The reason is that I discovered a pitfall in Rust's match when matching against constants.
You can actually delete the constant definitions for OPENDAL_SEEK_SET, OPENDAL_SEEK_CUR, and OPENDAL_SEEK_END, and the match below will not raise an error!
The compiler will treat OPENDAL_SEEK_SET, OPENDAL_SEEK_CUR, and OPENDAL_SEEK_END as variable names, which is extremely dangerous. I once encountered a bug because of this issue.

I’d love to hear your thoughts. This is my first time contributing a PR, so I have quite a few concerns.

Need range reader or seek in c binding #6083

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions