nfs4fs 0.1.0__tar.gz

nfs4fs-0.1.0/Cargo.toml

@@ -0,0 +1,11 @@
+[workspace]
+members = ["vnfs", "nfsv41-sys"]
+resolver = "2"
+
+[workspace.dependencies]
+clap = { version = "4.5.17", features = ["derive"] }
+libc = "0.2"
+libntirpc-sys = "0.2.1"
+nfsv41-sys = { path = "nfsv41-sys", version = "0.1.1" }
+xdr-codec = "0.4.4"
+xdrgen = "0.4.4"

nfs4fs-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: nfs4fs
+Version: 0.1.0
+Requires-Dist: fsspec
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'test'
+Provides-Extra: dev
+Provides-Extra: test
+Summary: fsspec NFSv4.1 filesystem backed by the vectorized vnfs client
+License: MIT OR Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# nfs4fs
+
+An `fsspec` filesystem (`nfs4://`) backed by the vectorized
+[`vnfs`](../vnfs) NFSv4.1 client.
+
+The Rust extension (`nfs4fs._native`) links libntirpc **statically**, so
+`import nfs4fs` works without `LD_LIBRARY_PATH`.
+
+## Build
+
+```sh
+python3 -m venv .venv
+.venv/bin/pip install maturin fsspec pytest
+cd python
+../.venv/bin/maturin develop
+```
+
+## Use
+
+```python
+import fsspec
+import nfs4fs  # registers the "nfs4" protocol
+
+fs = fsspec.filesystem("nfs4", host="127.0.0.1", root="git/some/tree")
+fs.pipe({"nfs4:///a.txt": b"hello", "nfs4:///b.txt": b"world"})
+print(fs.cat(["nfs4:///a.txt", "nfs4:///b.txt"]))
+```
+
+For tests without an NFS server, use `backend="dummy"` (a local-directory
+implementation of the same vectorized API):
+
+```python
+fs = fsspec.filesystem("nfs4", backend="dummy", dummy_root="/tmp/scratch")
+```
+

nfs4fs-0.1.0/README.md

@@ -0,0 +1,34 @@
+# nfs4fs
+
+An `fsspec` filesystem (`nfs4://`) backed by the vectorized
+[`vnfs`](../vnfs) NFSv4.1 client.
+
+The Rust extension (`nfs4fs._native`) links libntirpc **statically**, so
+`import nfs4fs` works without `LD_LIBRARY_PATH`.
+
+## Build
+
+```sh
+python3 -m venv .venv
+.venv/bin/pip install maturin fsspec pytest
+cd python
+../.venv/bin/maturin develop
+```
+
+## Use
+
+```python
+import fsspec
+import nfs4fs  # registers the "nfs4" protocol
+
+fs = fsspec.filesystem("nfs4", host="127.0.0.1", root="git/some/tree")
+fs.pipe({"nfs4:///a.txt": b"hello", "nfs4:///b.txt": b"world"})
+print(fs.cat(["nfs4:///a.txt", "nfs4:///b.txt"]))
+```
+
+For tests without an NFS server, use `backend="dummy"` (a local-directory
+implementation of the same vectorized API):
+
+```python
+fs = fsspec.filesystem("nfs4", backend="dummy", dummy_root="/tmp/scratch")
+```

nfs4fs-0.1.0/nfsv41-sys/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "nfsv41-sys"
+version = "0.1.2"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+description = "Bindings for the NFSv4.1 protocol structs and XDR codecs (nfsv41.h)"
+repository = "https://github.com/vmingchen/vnfs"
+documentation = "https://docs.rs/nfsv41-sys"
+links = "nfsv41"
+readme = "README.md"
+
+[dependencies]
+libntirpc-sys = { workspace = true }
+
+[build-dependencies]
+bindgen = "0.72"

nfs4fs-0.1.0/nfsv41-sys/README.md

@@ -0,0 +1,117 @@
+# nfsv41-sys
+
+Raw FFI bindings for the NFSv4.1 protocol, vendored from NFS-Ganesha's
+`nfsv41.h`. This crate provides the protocol data types (`COMPOUND4args`,
+`nfs_argop4`, `nfs_resop4`, ...) and the XDR codecs that encode/decode them,
+as a low-level foundation for the `vnfs` client.
+
+This is a `-sys` crate: it exposes unsafe `extern` types and functions with
+manual memory management. Higher-level, safe wrappers live in the `vnfs`
+crate.
+
+## What's in the box
+
+| File | Purpose |
+|------|---------|
+| `src/nfsv41.h` | NFS-Ganesha's NFSv4.1 protocol header (structs + static-inline XDR codecs) |
+| `src/wrapper.c` | Five `xdr_wrap_*` extern entry points around the `static inline` codecs (Rust cannot call static-inline functions directly) |
+| `src/wrapper.h` | The bindgen input header (includes `nfsv41.h`, declares the wrappers) |
+| `src/lib.rs` | `include!` of the generated bindings, plus the `-lntirpc` link directive |
+| `build.rs` | Compiles `wrapper.c` into `libnfsv41.a` and runs bindgen |
+
+## Build
+
+`build.rs` performs two steps:
+
+1. **C codec archive**: `gcc` compiles `src/wrapper.c` (with libntirpc's
+   include directories, supplied by `libntirpc-sys` via its `links`
+   metadata as `DEP_NTIRPC_INCLUDE` / `DEP_NTIRPC_INCLUDE2`) into
+   `libnfsv41.a`.
+2. **bindgen**: generates ~15k lines of Rust declarations from
+   `src/wrapper.h` into `$OUT_DIR/bindings.rs`, which `src/lib.rs` includes.
+
+The archive's object files reference `libntirpc.so` symbols, so the crate
+re-emits `-lntirpc` (and `-lntirpcmonitoring`) at final link time; binaries
+also need `libntirpc.so` on the dynamic linker path at runtime.
+
+## Usage
+
+```rust
+use nfsv41_sys::*;
+use std::os::raw::c_char;
+
+unsafe {
+    let mut argop: nfs_argop4 = std::mem::zeroed();
+    argop.argop = nfs_opnum4_NFS4_OP_PUTFH;
+    argop.nfs_argop4_u.opputfh.object.nfs_fh4_len = 4;
+    argop.nfs_argop4_u.opputfh.object.nfs_fh4_val = fh.as_ptr() as *mut c_char;
+
+    let mut args: COMPOUND4args = std::mem::zeroed();
+    // ... wire up tag / argarray ...
+
+    let mut xdr: XDR = std::mem::zeroed();
+    xdrmem_ncreate(&mut xdr, buf.as_mut_ptr() as *mut c_char, BUF, xdr_op_XDR_ENCODE);
+    xdr_wrap_COMPOUND4args(&mut xdr, &mut args);
+}
+```
+
+## Tests
+
+`tests/roundtrip.rs` encodes a `COMPOUND4args`/`COMPOUND4res` (one PUTFH op)
+with the codecs, decodes it back, and checks the fields match. Run with:
+
+```sh
+cargo test -p nfsv41-sys
+```
+
+## Improvement roadmap
+
+- **Pure-Rust codecs via `xdrgen`.** The workspace already carries
+  `protocol/nfsv41.x` (the RFC 5661 XDR spec) and the `xdrgen` /
+  `xdr-codec` dependencies. `xdrgen` parses the `.x` spec and emits typed
+  `Pack`/`Unpack` implementations, which would remove gcc, `wrapper.c`,
+  bindgen, and the `-Wno-incompatible-pointer-types` workaround. See below.
+- **Safe wrapper layer.** Owned buffer types (`Vec<u8>`, `String`), RAII for
+  decoded trees (no manual `xdr_free_null_stream`), and safe accessors for
+  the `nfs_argop4_u` / `nfs_resop4_u` unions.
+- **Narrow the bindings.** An allowlist of NFS types (instead of blocklists)
+  would shrink the generated surface and compile time.
+- **More codec tests.** Round-trips cover PUTFH plus the basic ops
+  (READ, WRITE, LOOKUP, READDIR, REMOVE, RENAME, CREATE, GETFH, READLINK,
+  GETATTR, COMMIT, LINK) in `tests/ops_roundtrip.rs`; property-based
+  round-trips across the remaining ops would catch more XDR bugs.
+
+### How xdrgen generates Rust
+
+`xdrgen` (used together with the `xdr-codec` runtime) turns an RFC 4506 /
+RFC 5661 XDR specification into plain Rust source:
+
+1. **Parse.** The XDR grammar is parsed (xdrgen's parser is built on
+   `nom`) into an AST of typedefs, structs, unions, enums, constants, and
+   program/version blocks.
+2. **Emit.** The AST is lowered into Rust source text (xdrgen uses `quote`)
+   written to `$OUT_DIR/<name>_xdr.rs`. For every type it emits a matching
+   `struct` (or `enum` for unions) plus:
+   - `impl Pack for T` — the encoder, following the XDR wire rules
+     (4-byte alignment, variable-length `<>` prefixes, discriminants for
+     unions),
+   - `impl Unpack for T` — the decoder, allocating owned `Vec`s/`String`s
+     as it goes.
+3. **Wire up.** The generated file is included with
+   `include!(concat!(env!("OUT_DIR"), "/nfsv41_xdr.rs"))` inside a module,
+   with `xdr-codec` as a dependency. Types the generator can't express
+   (e.g. the `%`-passthrough `authsys_parms`) get hand-written
+   `Pack`/`Unpack` impls.
+
+In a `build.rs` the whole thing is one call:
+
+```rust
+fn main() {
+    xdrgen::compile("protocol/nfsv41.x").unwrap();
+}
+```
+
+For NFSv4.1 the practical caveat is that `xdrgen` 0.4.4 is an old crate
+(deps from the `quote` 0.3 / `nom` 3 era); the complex NFSv4.1 unions and
+the `authsys_parms` passthrough may need manual impls, and the generator
+itself may need a build fix before the raw bindings can be retired.

nfs4fs-0.1.0/nfsv41-sys/build.rs

@@ -0,0 +1,104 @@
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    let src_dir = manifest_dir.join("src");
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    // The python/ workspace builds a standalone extension and wants libntirpc
+    // linked statically (see python/third_party/libntirpc-sys/build.rs). Only
+    // that workspace sets VNFS_STATIC_NTIRPC, so the main workspace keeps the
+    // historical dynamic-link flags.
+    let static_ntirpc = env::var("VNFS_STATIC_NTIRPC").as_deref() == Ok("1");
+
+    // Include directory provided by libntirpc-sys (via its `links` metadata).
+    let ntirpc_inc = env::var("DEP_NTIRPC_INCLUDE")
+        .expect("DEP_NTIRPC_INCLUDE not set; libntirpc-sys must be a dependency");
+    // The installed config.h includes "ntirpc/version.h", resolvable only
+    // from the libntirpc build tree (DEP_NTIRPC_INCLUDE2).
+    let ntirpc_build_inc = env::var("DEP_NTIRPC_INCLUDE2").unwrap_or_default();
+
+    // Compile the wrappers around the nfsv41.h static inline codecs.
+    let mut gcc = Command::new("gcc");
+    gcc.arg("-c")
+        .arg("-O2")
+        .arg("-fno-strict-aliasing")
+        // Ganesha's codec calls xdr_pointer with `char **` where ntirpc's
+        // prototype takes `void **`; GCC 14 turns this constraint violation
+        // into an error by default.
+        .arg("-Wno-incompatible-pointer-types")
+        .arg(format!("-I{}", ntirpc_inc))
+        .arg(format!("-I{}", src_dir.display()));
+    if !ntirpc_build_inc.is_empty() {
+        gcc.arg(format!("-I{}", ntirpc_build_inc));
+    }
+    let status = gcc
+        .arg(src_dir.join("wrapper.c"))
+        .arg("-o")
+        .arg(out_dir.join("wrapper.o"))
+        .status()
+        .unwrap();
+    assert!(status.success(), "gcc failed to compile wrapper.c");
+
+    let status = Command::new("ar")
+        .arg("rcs")
+        .arg(out_dir.join("libnfsv41.a"))
+        .arg(out_dir.join("wrapper.o"))
+        .status()
+        .unwrap();
+    assert!(status.success(), "ar failed");
+
+    println!("cargo:rustc-link-search=native={}", out_dir.display());
+    println!("cargo:rustc-link-lib=static=nfsv41");
+    if static_ntirpc {
+        // wrapper.o (embedded in this crate's rlib) references symbols in
+        // libntirpc; resolve them from the static archive.
+        println!("cargo:rustc-link-lib=static=ntirpc");
+    } else {
+        // wrapper.o references symbols in libntirpc.so; re-assert the link so
+        // consumers (including this crate's own tests) get the dynamic
+        // library linked too.
+        println!("cargo:rustc-link-lib=dylib=ntirpc");
+        println!("cargo:rustc-link-lib=dylib=ntirpcmonitoring");
+    }
+    println!("cargo:rerun-if-changed=src/wrapper.c");
+    println!("cargo:rerun-if-changed=src/wrapper.h");
+    println!("cargo:rerun-if-changed=src/nfsv41.h");
+    println!("cargo:rerun-if-changed=src/ganesha_rpc.h");
+    println!("cargo:rerun-if-changed=src/config.h");
+
+    let mut bindgen = bindgen::Builder::default()
+        .header(src_dir.join("wrapper.h").to_str().unwrap())
+        .clang_arg(format!("-I{}", ntirpc_inc))
+        .clang_arg(format!("-I{}", src_dir.display()));
+    if !ntirpc_build_inc.is_empty() {
+        bindgen = bindgen.clang_arg(format!("-I{}", ntirpc_build_inc));
+    }
+    bindgen
+        .blocklist_type("rpcblist")
+        // Following are unsupported because of usage u128
+        .blocklist_function("xdr_quadruple")
+        .blocklist_function("strtold")
+        .blocklist_type("_Float64x")
+        .blocklist_function("qecvt_r")
+        .blocklist_function("qfcvt_r")
+        .blocklist_function("qecvt")
+        .blocklist_function("qfcvt")
+        .blocklist_function("qgcvt")
+        .generate()
+        .expect("Unable to generate bindings")
+        .write_to_file(out_dir.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+
+    // Edition 2024 requires extern blocks to be `unsafe`; rewrite the
+    // generated ones that bindgen still emits as plain `extern "C" {`,
+    // leaving the blocks bindgen already marks `unsafe` untouched.
+    let bindings_path = out_dir.join("bindings.rs");
+    let generated = std::fs::read_to_string(&bindings_path).expect("read bindings");
+    let rewritten = generated
+        .replace("unsafe extern \"C\" {", "\u{0}unsafe_extern\u{0}")
+        .replace("extern \"C\" {", "unsafe extern \"C\" {")
+        .replace("\u{0}unsafe_extern\u{0}", "unsafe extern \"C\" {");
+    std::fs::write(&bindings_path, rewritten).expect("rewrite bindings");
+}

nfs4fs-0.1.0/nfsv41-sys/examples/dbg.rs

@@ -0,0 +1,68 @@
+use nfsv41_sys::*;
+use std::os::raw::c_char;
+
+fn main() {
+    unsafe {
+        let fh: [u8; 4] = [0xde, 0xad, 0xbe, 0xef];
+        let tag = b"roundtrip\0".to_vec();
+        let mut argop: nfs_argop4 = std::mem::zeroed();
+        argop.argop = nfs_opnum4_NFS4_OP_PUTFH;
+        argop.nfs_argop4_u.opputfh.object.nfs_fh4_len = fh.len() as u32;
+        argop.nfs_argop4_u.opputfh.object.nfs_fh4_val = fh.as_ptr() as *mut c_char;
+        let mut args: COMPOUND4args = std::mem::zeroed();
+        args.tag.utf8string_len = tag.len() as u32;
+        args.tag.utf8string_val = tag.as_ptr() as *mut c_char;
+        args.minorversion = 1;
+        args.argarray.argarray_len = 1;
+        args.argarray.argarray_val = &mut argop as *mut nfs_argop4;
+
+        let mut xdr: XDR = std::mem::zeroed();
+        let mut buf = vec![0u8; 4096];
+        xdrmem_ncreate(
+            &mut xdr,
+            buf.as_mut_ptr() as *mut c_char,
+            4096,
+            xdr_op_XDR_ENCODE,
+        );
+        let ok = xdr_wrap_COMPOUND4args(&mut xdr, &mut args);
+        println!("encode ok: {}", ok);
+        let len = xdr.x_data.offset_from(xdr.x_v.vio_base) as usize;
+        println!("len: {}", len);
+        println!("hex: {:02x?}", &buf[0..len]);
+
+        let mut xdr2: XDR = std::mem::zeroed();
+        let mut b2 = buf[0..len].to_vec();
+        xdrmem_ncreate(
+            &mut xdr2,
+            b2.as_mut_ptr() as *mut c_char,
+            len as u32,
+            xdr_op_XDR_DECODE,
+        );
+        let mut decoded: COMPOUND4args = std::mem::zeroed();
+        let ok2 = xdr_wrap_COMPOUND4args(&mut xdr2, &mut decoded);
+        println!("decode ok: {}", ok2);
+        if ok2 {
+            println!(
+                "tag len {}: {}",
+                decoded.tag.utf8string_len,
+                String::from_utf8_lossy(std::slice::from_raw_parts(
+                    decoded.tag.utf8string_val as *const u8,
+                    decoded.tag.utf8string_len as usize
+                ))
+            );
+            println!("minorversion: {}", decoded.minorversion);
+            println!("nargs: {}", decoded.argarray.argarray_len);
+            let da = &*decoded.argarray.argarray_val;
+            println!("argop: {}", da.argop);
+            println!("fh len: {}", da.nfs_argop4_u.opputfh.object.nfs_fh4_len);
+            println!(
+                "fh: {:02x?}",
+                std::slice::from_raw_parts(
+                    da.nfs_argop4_u.opputfh.object.nfs_fh4_val as *const u8,
+                    da.nfs_argop4_u.opputfh.object.nfs_fh4_len as usize
+                )
+            );
+            xdr_wrap_COMPOUND4args(&raw mut xdr_free_null_stream, &mut decoded);
+        }
+    }
+}

nfs4fs-0.1.0/nfsv41-sys/src/config.h

@@ -0,0 +1,9 @@
+/*
+ * Stand-in for NFS-Ganesha's config.h. The real ganesha config.h
+ * carries build-time feature flags (_HAVE_GSSAPI etc.); nfsv41.h does
+ * not depend on any of them, so an empty config is sufficient here.
+ */
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#endif /* !CONFIG_H */

nfs4fs-0.1.0/nfsv41-sys/src/ganesha_rpc.h

@@ -0,0 +1,99 @@
+/*
+ * Minimal stand-in for the NFS-Ganesha <ganesha_rpc.h> header that
+ * nfsv41.h includes. nfsv41.h only needs the libntirpc RPC/XDR types
+ * plus a couple of GSS-related type names; it does not need any of the
+ * real Ganesha infrastructure, so this shim deliberately pulls in only
+ * the individual libntirpc headers (avoiding <rpc/rpc.h>, which would
+ * drag in <gssapi/gssapi.h> via <rpc/auth_gss.h>).
+ */
+#ifndef GANESHA_RPC_H
+#define GANESHA_RPC_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "config.h"
+
+#include <rpc/types.h>
+#include <rpc/xdr.h>
+#include <rpc/xdr_inline.h>
+#include <rpc/rpc_msg.h>
+#include <rpc/auth_unix.h>
+
+/*
+ * Bounded-array limits for the nfsv41.h codecs. The rpcgen-era header
+ * that txn-compound vendors passes maxsize = ~0 for every unbounded
+ * array; ntirpc's inline xdr_array_decode rejects maxsize with
+ * maxsize > UINT_MAX/selem (an overflow guard), so unbounded arrays
+ * must be given a finite cap. Values match NFS-Ganesha
+ * src/include/gsh_rpc.h.
+ */
+#define XDR_ARRAY_MAXLEN 1024
+/* General-attribute opaque cap (matches NFS-Ganesha gsh_rpc.h). */
+#define XDR_BYTES_MAXLEN (1024 * 1024)
+/* READ/WRITE payloads use the I/O cap (XDR_BYTES_MAXLEN_IO upstream) instead
+ * of the 1 MiB general cap, so a single data op can carry a whole compound's
+ * budget. */
+#define XDR_BYTES_MAXLEN_IO (64 * 1024 * 1024)
+#define XDR_STRING_MAXLEN (8 * 1024)
+
+/* RPCSEC_GSS service type, normally from <rpc/auth_gss.h>. */
+typedef enum rpc_gss_svc {
+	RPC_GSS_SVC_NONE = 1,
+	RPC_GSS_SVC_INTEGRITY = 2,
+	RPC_GSS_SVC_PRIVACY = 3
+} rpc_gss_svc_t;
+
+/*
+ * Only used by the rpcgen-generated freeresult prototypes in nfsv41.h;
+ * the struct layout is never referenced, so an opaque forward-declared
+ * typedef is sufficient.
+ */
+typedef struct __rpc_svcxprt SVCXPRT;
+
+/*
+ * Only used in the rpcgen-generated cb_* prototypes in nfsv41.h; the
+ * struct layout is never referenced, so an opaque forward-declared
+ * typedef is sufficient.
+ */
+typedef struct rpc_client CLIENT;
+
+/*
+ * Ganesha's request-lookahead tracking. nfsv41.h's xdr_nfs_argop4 /
+ * xdr_nfs_resop4 codecs maintain a nfs_request_lookahead pointed to by
+ * XDR.x_public while they walk the arg/res arrays; the fields are never
+ * read back in this crate, but they must be defined for the codecs to
+ * compile. Values match NFS-Ganesha src/Protocols/nfs4/support/nfsxdr.h.
+ */
+#define NFS_LOOKAHEAD_NONE 0x0000
+#define NFS_LOOKAHEAD_MOUNT 0x0001
+#define NFS_LOOKAHEAD_OPEN 0x0002
+#define NFS_LOOKAHEAD_CLOSE 0x0004
+#define NFS_LOOKAHEAD_READ 0x0008
+#define NFS_LOOKAHEAD_WRITE 0x0010
+#define NFS_LOOKAHEAD_COMMIT 0x0020
+#define NFS_LOOKAHEAD_CREATE 0x0040
+#define NFS_LOOKAHEAD_REMOVE 0x0080
+#define NFS_LOOKAHEAD_RENAME 0x0100
+#define NFS_LOOKAHEAD_LOCK 0x0200
+#define NFS_LOOKAHEAD_READDIR 0x0400
+#define NFS_LOOKAHEAD_LAYOUTCOMMIT 0x0040
+#define NFS_LOOKAHEAD_SETATTR 0x0080
+#define NFS_LOOKAHEAD_SETCLIENTID 0x0100
+#define NFS_LOOKAHEAD_SETCLIENTID_CONFIRM 0x0200
+#define NFS_LOOKAHEAD_LOOKUP 0x0400
+#define NFS_LOOKAHEAD_READLINK 0x0800
+
+struct nfs_request_lookahead {
+	uint32_t flags;
+	uint16_t read;
+	uint16_t write;
+};
+
+#define NFS_LOOKAHEAD_HIGH_LATENCY(lkhd) \
+	(((lkhd).flags & (NFS_LOOKAHEAD_READ | NFS_LOOKAHEAD_WRITE | \
+			  NFS_LOOKAHEAD_COMMIT | NFS_LOOKAHEAD_LAYOUTCOMMIT | \
+			  NFS_LOOKAHEAD_READDIR)))
+
+#endif /* !GANESHA_RPC_H */

nfs4fs-0.1.0/nfsv41-sys/src/lib.rs

@@ -0,0 +1,18 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(clippy::missing_safety_doc)]
+#![allow(unnecessary_transmutes)]
+#![allow(improper_ctypes)]
+#![allow(improper_ctypes_definitions)]
+#![allow(unsafe_op_in_unsafe_fn)]
+#![allow(clippy::ptr_offset_with_cast)]
+
+// The codec wrappers in wrapper.c (compiled into this crate's rlib)
+// reference libntirpc.so symbols directly, so any binary that uses this
+// crate must also link the dynamic library. `#[link]` ensures rustc
+// re-emits -lntirpc at final link time whenever this rlib is pulled in.
+#[link(name = "ntirpc", kind = "dylib")]
+unsafe extern "C" {}
+
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));