Nfsembed

https://docs.rs/nfsembed/0.1.0/nfsembed/
Admin
nfsembed is an embeddable NFSv3 server library for Rust that allows applications to expose custom...
Tokens:17,216
Snippets:216
Trust Score:9.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### NfsServer::start_with_portmapper

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.NfsServer.html

Starts the NFS/MOUNT server along with a standalone TCP+UDP portmapper.

```APIDOC
## pub async fn start_with_portmapper(&self, listener: TcpListener, portmapper: PortmapperSockets) -> Result<ServerHandle, ServerError>

### Description
Starts the NFS and MOUNT services together with a standalone TCP+UDP portmapper.

### Parameters
- **listener** (TcpListener) - Required - The TCP listener for the NFS server.
- **portmapper** (PortmapperSockets) - Required - The sockets configuration for the portmapper.
```

--------------------------------

### NfsServer::start

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.NfsServer.html

Starts the NFS server using the provided TCP listener.

```APIDOC
## pub async fn start(&self, listener: TcpListener) -> Result<ServerHandle, ServerError>

### Description
Starts the NFS server instance and returns a handle to the running server.

### Parameters
- **listener** (TcpListener) - Required - The TCP listener to bind the server to.
```

--------------------------------

### ReplayCache::new

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/replay/struct.ReplayCache.html

Creates a new instance of ReplayCache with the specified capacity, maximum completed bytes, and time-to-live duration.

```APIDOC
### pub fn new(capacity: usize, max_completed_bytes: usize, ttl: Duration) -> Self

Creates a new `ReplayCache` instance. 

- **capacity**: `usize` - The maximum number of entries in the cache.
- **max_completed_bytes**: `usize` - The maximum number of bytes for completed requests.
- **ttl**: `Duration` - The time-to-live duration for cache entries.
```

--------------------------------

### ReplayCache::begin

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/replay/struct.ReplayCache.html

Begins processing a request within the replay cache to determine if it should be replayed.

```APIDOC
### pub async fn begin(self: &Arc<Self>, key: ReplayKey, fingerprint: RequestFingerprint) -> Result<ReplayDecision, ReplayError>

Initiates a replay decision process for a given request.

- **key**: `ReplayKey` - The unique key identifying the request.
- **fingerprint**: `RequestFingerprint` - The fingerprint of the request.
- **Returns**: `Result<ReplayDecision, ReplayError>` - The decision on whether to replay or an error if the process fails.
```

--------------------------------

### NfsServer::serve_with_portmapper

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.NfsServer.html

Runs the NFS/MOUNT server and portmapper until a shutdown signal is received.

```APIDOC
## pub async fn serve_with_portmapper<F>(&self, listener: TcpListener, portmapper: PortmapperSockets, shutdown_signal: F) -> Result<(), ServerError>

### Description
Serves NFS and MOUNT services together with a portmapper until the shutdown signal is received.

### Parameters
- **listener** (TcpListener) - Required - The TCP listener for the server.
- **portmapper** (PortmapperSockets) - Required - The portmapper configuration.
- **shutdown_signal** (F) - Required - A future that triggers server shutdown.
```

--------------------------------

### NfsName implementation constants and methods

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.NfsName.html

Core methods for interacting with NfsName, including length constraints and conversion utilities.

```rust
pub const MAX_LEN: usize = 255
pub fn new(value: impl Into<Vec<u8>>) -> Result<Self, NfsError>
pub fn as_bytes(&self) -> &[u8] ⓘ
pub fn into_bytes(self) -> Vec<u8> ⓘ
```

--------------------------------

### mount_info

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.ServerHandle.html

Retrieves the mount information for the server.

```APIDOC
## pub fn mount_info(&self) -> MountInfo

### Description
Retrieves the mount information associated with the server handle.

### Returns
- **MountInfo** - The mount information object.
```

--------------------------------

### Re-exporting VFS components

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/index.html

Public re-exports for virtual file system interactions.

```rust
pub use vfs::ExportId;
```

```rust
pub use vfs::Principal;
```

```rust
pub use vfs::RequestContext;
```

```rust
pub use vfs::VirtualFileSystem;
```

--------------------------------

### NfsServer::builder

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.NfsServer.html

Creates a new NfsServerBuilder instance using the provided virtual file system.

```APIDOC
## pub fn builder(vfs: impl VirtualFileSystem) -> NfsServerBuilder

### Description
Creates a builder for the NfsServer using a specific virtual file system implementation.

### Parameters
- **vfs** (impl VirtualFileSystem) - Required - The virtual file system to be used by the server.
```

--------------------------------

### NfsServer::serve

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.NfsServer.html

Runs the NFS server until a shutdown signal is received.

```APIDOC
## pub async fn serve<F>(&self, listener: TcpListener, shutdown_signal: F) -> Result<(), ServerError>

### Description
Serves the NFS requests until the provided shutdown signal future completes.

### Parameters
- **listener** (TcpListener) - Required - The TCP listener for the server.
- **shutdown_signal** (F) - Required - A future that triggers server shutdown.
```

--------------------------------

### NfsServerBuilder Methods

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.NfsServerBuilder.html

Methods available on the NfsServerBuilder for configuring the NFS server.

```APIDOC
## NfsServerBuilder Methods

### pub fn export_name(self, name: impl Into<String>) -> Self
Sets the name for the export.

### pub fn export_id(self, export_id: ExportId) -> Self
Sets the export ID.

### pub fn add_export(self, export_id: ExportId, name: impl Into<String>, vfs: impl VirtualFileSystem) -> Self
Adds an independent export backed by another virtual filesystem.

### pub fn add_export_arc(self, export_id: ExportId, name: impl Into<String>, vfs: Arc<dyn VirtualFileSystem>) -> Self
Adds an independent export from a trait object.

### pub fn limits(self, limits: ServerLimits) -> Self
Configures the server limits.

### pub fn auth_policy(self, auth_policy: AuthPolicy) -> Self
Sets the authentication policy for the server.

### pub fn portmapper(self, mode: PortmapperMode) -> Self
Configures the portmapper mode.

### pub fn build(self) -> Result<NfsServer, ServerError>
Builds the NfsServer instance based on the current configuration.
```

--------------------------------

### NfsName::new

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.NfsName.html

Creates a new NfsName instance from a byte-convertible value, returning an error if validation fails.

```APIDOC
## pub fn new(value: impl Into<Vec<u8>>) -> Result<Self, NfsError>

### Description
Creates a new NfsName instance. This constructor validates the input value to ensure it meets NFS naming requirements.

### Parameters
- **value** (impl Into<Vec<u8>>) - Required - The byte sequence representing the NFS name.

### Returns
- **Result<Self, NfsError>** - Returns the NfsName instance on success, or an NfsError if the input is invalid.
```

--------------------------------

### Re-exporting server components

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/index.html

Public re-exports for server-side configuration and management.

```rust
pub use server::AuthPolicy;
```

```rust
pub use server::MountInfo;
```

```rust
pub use server::NfsServer;
```

```rust
pub use server::NfsServerBuilder;
```

```rust
pub use server::PortmapperMode;
```

```rust
pub use server::PortmapperSockets;
```

```rust
pub use server::ServerError;
```

```rust
pub use server::ServerHandle;
```

```rust
pub use server::ServerLimits;
```

--------------------------------

### ServerLimits Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.ServerLimits.html

Defines the configuration parameters for server resource limits and timeouts.

```rust
pub struct ServerLimits {Show 18 fields
    pub max_connections: usize,
    pub max_requests_per_connection: usize,
    pub max_inflight_requests: usize,
    pub max_rpc_record_size: usize,
    pub max_rpc_fragment_size: usize,
    pub max_fragments_per_record: usize,
    pub max_buffered_request_bytes: usize,
    pub max_buffered_reply_bytes: usize,
    pub max_read_size: u32,
    pub max_write_size: u32,
    pub max_readdir_response_size: u32,
    pub request_timeout: Duration,
    pub idle_connection_timeout: Duration,
    pub replay_cache_capacity: usize,
    pub replay_cache_max_bytes: usize,
    pub replay_cache_ttl: Duration,
    pub graceful_shutdown_timeout: Duration,
    pub max_mounts: usize,
}
```

--------------------------------

### VirtualFileSystem Trait Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/trait.VirtualFileSystem.html

The core trait definition for implementing a virtual file system, requiring Send, Sync, and 'static bounds.

```rust
pub trait VirtualFileSystem:
    Send
    + Sync
    + 'static {
Show 23 methods    // Required methods
    fn capabilities(&self) -> VfsCapabilities;
    fn root(&self) -> ObjectKey;
    fn getattr<'life0, 'life1, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        object: ObjectKey,
    ) -> Pin<Box<dyn Future<Output = Result<FileAttributes, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn lookup<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        parent: ObjectKey,
        name: &'life2 NfsName,
    ) -> Pin<Box<dyn Future<Output = Result<CreatedObject, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;

    // Provided methods
    fn access<'life0, 'life1, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _object: ObjectKey,
        _requested: u32,
    ) -> Pin<Box<dyn Future<Output = Result<u32, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn setattr<'life0, 'life1, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _object: ObjectKey,
        _attributes: SetAttributes,
        _guard: Option<NfsTime>,
    ) -> Pin<Box<dyn Future<Output = Result<MutationResult<()>, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn readlink<'life0, 'life1, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _object: ObjectKey,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn read<'life0, 'life1, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _object: ObjectKey,
        _offset: u64,
        _count: u32,
    ) -> Pin<Box<dyn Future<Output = Result<ReadResult, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn read_bytes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        object: ObjectKey,
        offset: u64,
        count: u32,
    ) -> Pin<Box<dyn Future<Output = Result<ReadBytesResult, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn write<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _object: ObjectKey,
        _offset: u64,
        _data: &'life2 [u8],
        _requested: WriteStability,
    ) -> Pin<Box<dyn Future<Output = Result<MutationResult<WriteResult>, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn create<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _parent: ObjectKey,
        _name: &'life2 NfsName,
        _attributes: SetAttributes,
        _mode: CreateMode,
    ) -> Pin<Box<dyn Future<Output = Result<MutationResult<CreatedObject>, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn mkdir<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _parent: ObjectKey,
        _name: &'life2 NfsName,
        _attributes: SetAttributes,
    ) -> Pin<Box<dyn Future<Output = Result<MutationResult<CreatedObject>, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn symlink<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        _context: &'life1 RequestContext,
        _parent: ObjectKey,
        _name: &'life2 NfsName,
        _target: &'life3 [u8],
        _attributes: SetAttributes,
    ) -> Pin<Box<dyn Future<Output = Result<MutationResult<CreatedObject>, NfsError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
```

--------------------------------

### HandleCodec Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/handles/struct.HandleCodec.html

The structure definition for HandleCodec.

```rust
pub struct HandleCodec { /* private fields */ }
```

--------------------------------

### VersionRange::exact

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/message/struct.VersionRange.html

Creates a new VersionRange where the low and high bounds are set to the same specified version.

```APIDOC
## fn exact(version: u32) -> Self

### Description
Creates a new `VersionRange` instance where both the `low` and `high` fields are set to the provided `version`.

### Parameters
- **version** (u32) - The version number to set for both bounds.

### Returns
- **Self** - A new `VersionRange` instance.
```

--------------------------------

### ReplayCache Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/replay/struct.ReplayCache.html

The internal structure definition for ReplayCache.

```rust
pub struct ReplayCache { /* private fields */ }
```

--------------------------------

### FsInfo Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.FsInfo.html

The structure definition for FsInfo, containing fields for filesystem performance and capacity limits.

```rust
pub struct FsInfo {
    pub max_read: u32,
    pub preferred_read: u32,
    pub read_multiple: u32,
    pub max_write: u32,
    pub preferred_write: u32,
    pub write_multiple: u32,
    pub preferred_readdir: u32,
    pub max_file_size: u64,
    pub time_granularity: NfsTime,
}
```

--------------------------------

### VfsCapabilities Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.VfsCapabilities.html

The primary structure definition containing boolean flags for various VFS capabilities.

```rust
pub struct VfsCapabilities {
    pub read_only: bool,
    pub hard_links: bool,
    pub symbolic_links: bool,
    pub mknod: bool,
    pub homogeneous: bool,
    pub can_set_time: bool,
}
```

--------------------------------

### Accessing the VERSION constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/portmap/constant.VERSION.html

Represents the current version of the portmap implementation as a 32-bit unsigned integer.

```rust
pub const VERSION: u32 = 2;
```

--------------------------------

### wait

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.ServerHandle.html

Waits for the server to terminate.

```APIDOC
## pub async fn wait(&self) -> Result<(), ServerError>

### Description
Blocks until all listener and connection tasks associated with the server have terminated.

### Returns
- **Result<(), ServerError>** - Returns Ok when all tasks have finished, or a ServerError if an error occurred during waiting.
```

--------------------------------

### HandleCodec Methods

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/handles/struct.HandleCodec.html

Methods available for the HandleCodec struct to manage NFS handle operations.

```APIDOC
## pub fn random() -> Self

Creates a new HandleCodec with a random instance ID.

## pub fn try_random() -> Result<Self, Error>

Attempts to create a new HandleCodec with a random instance ID, returning an error if generation fails.

## pub fn encode(&self, export_id: ExportId, object: ObjectKey) -> [u8; 45]

Encodes an export ID and object key into a 45-byte handle array.

## pub fn decode(&self, export_id: ExportId, handle: &[u8]) -> Result<ObjectKey, HandleError>

Decodes a handle into an ObjectKey for a specific export ID.

## pub fn decode_any(&self, handle: &[u8]) -> Result<(ExportId, ObjectKey), HandleError>

Decodes a handle into both an ExportId and an ObjectKey.

## pub fn instance_id(&self) -> [u8; 8]

Returns the 8-byte instance ID associated with this codec.
```

--------------------------------

### Define AUTH_SYS constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/auth/constant.AUTH_SYS.html

Represents the authentication system identifier as a 32-bit unsigned integer.

```rust
pub const AUTH_SYS: u32 = 1;
```

--------------------------------

### Define RequestContext struct

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.RequestContext.html

The structure definition for RequestContext, containing the principal, client address, and export ID.

```rust
pub struct RequestContext {
    pub principal: Principal,
    pub client_addr: SocketAddr,
    pub export_id: ExportId,
}
```

--------------------------------

### CreateArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.CreateArgs.html

The structure definition for CreateArgs, containing the target directory, creation mode, and attributes.

```rust
pub struct CreateArgs {
    pub target: DirectoryOperationArgs,
    pub mode: CreateMode,
    pub attributes: SetAttributes,
}
```

--------------------------------

### mount_infos

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.ServerHandle.html

Retrieves a slice of all mount information objects.

```APIDOC
## pub fn mount_infos(&self) -> &[MountInfo]

### Description
Returns a slice containing all mount information objects managed by the server.

### Returns
- **&[MountInfo]** - A slice of mount information.
```

--------------------------------

### ReadDirectoryPage Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.ReadDirectoryPage.html

The structure definition for ReadDirectoryPage, including its fields for verifier, entries, and EOF status.

```rust
pub struct ReadDirectoryPage {
    pub verifier: [u8; 8],
    pub entries: Vec<DirectoryEntry>,
    pub eof: bool,
}
```

--------------------------------

### MountInfo Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.MountInfo.html

The structure definition for MountInfo, containing fields for server address, export path, NFS version, and port numbers.

```rust
pub struct MountInfo {
    pub server_addr: SocketAddr,
    pub export_path: String,
    pub nfs_version: u32,
    pub nfs_port: u16,
    pub mount_port: u16,
}
```

--------------------------------

### Decoder Methods

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/codec/struct.Decoder.html

Methods available on the Decoder struct for reading data from the input buffer.

```APIDOC
## Decoder Methods

### new(input: &'a [u8]) -> Self
Creates a new Decoder instance from the provided input slice.

### position() -> usize
Returns the current position in the input buffer.

### remaining() -> usize
Returns the number of bytes remaining in the input buffer.

### read_u32() -> Result<u32, DecodeError>
Reads a u32 value.

### read_i32() -> Result<i32, DecodeError>
Reads an i32 value.

### read_u64() -> Result<u64, DecodeError>
Reads a u64 value.

### read_bool() -> Result<bool, DecodeError>
Reads a boolean value.

### read_enum<T>(kind: &'static str, convert: impl FnOnce(u32) -> Option<T>) -> Result<T, DecodeError>
Reads an enum value using a conversion function.

### read_fixed<const N: usize>() -> Result<[u8; N], DecodeError>
Reads a fixed-size byte array.

### read_opaque(field: &'static str, limit: usize) -> Result<Vec<u8>, DecodeError>
Reads a variable-length opaque value into a Vec.

### read_opaque_slice(field: &'static str, limit: usize) -> Result<&'a [u8], DecodeError>
Reads a variable-length opaque value as a slice without copying.

### read_string(field: &'static str, limit: usize) -> Result<Vec<u8>, DecodeError>
Reads a string value.

### read_array<T>(field: &'static str, limit: usize, decode: impl FnMut(&mut Self) -> Result<T, DecodeError>) -> Result<Vec<T>, DecodeError>
Reads an array of items using a provided decoder function.

### finish() -> Result<(), DecodeError>
Validates that all input has been consumed.
```

--------------------------------

### VersionRange Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/message/struct.VersionRange.html

The structure definition for VersionRange, containing low and high version bounds.

```rust
pub struct VersionRange {
    pub low: u32,
    pub high: u32,
}
```

--------------------------------

### get_port function signature

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/portmap/dispatch/fn.get_port.html

The function signature for retrieving a port from a mapping.

```rust
pub fn get_port(request: &mapping, nfs_port: u16, mount_port: u16) -> u32
```

--------------------------------

### Define PROGRAM constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/mount3/types/constant.PROGRAM.html

Represents the PROGRAM constant as a 32-bit unsigned integer.

```rust
pub const PROGRAM: u32 = 100_005;
```

--------------------------------

### FileAttributes Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.FileAttributes.html

The primary structure definition containing 13 fields representing file metadata.

```rust
pub struct FileAttributes {Show 13 fields
    pub file_type: FileType,
    pub mode: u32,
    pub links: u32,
    pub uid: u32,
    pub gid: u32,
    pub size: u64,
    pub used: u64,
    pub device: Option<DeviceNumber>,
    pub fs_id: u64,
    pub file_id: u64,
    pub access_time: NfsTime,
    pub modify_time: NfsTime,
    pub change_time: NfsTime,
}
```

--------------------------------

### shutdown

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.ServerHandle.html

Requests the server to shut down.

```APIDOC
## pub async fn shutdown(&self) -> Result<(), ServerError>

### Description
Requests the server to initiate a shutdown. Calling this method multiple times is safe and has no additional effect.

### Returns
- **Result<(), ServerError>** - Returns Ok on success, or a ServerError if the shutdown request fails.
```

--------------------------------

### NfsName::as_bytes

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.NfsName.html

Returns a reference to the underlying byte representation of the NfsName.

```APIDOC
## pub fn as_bytes(&self) -> &[u8]

### Description
Provides access to the internal byte representation of the NfsName without consuming the object.

### Returns
- **&[u8]** - A slice containing the bytes of the name.
```

--------------------------------

### PathConf Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.PathConf.html

The definition of the PathConf struct containing various filesystem configuration fields.

```rust
pub struct PathConf {
    pub max_links: u32,
    pub max_name_length: u32,
    pub no_truncation: bool,
    pub chown_restricted: bool,
    pub case_insensitive: bool,
    pub case_preserving: bool,
}
```

--------------------------------

### ReplayKey Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/replay/struct.ReplayKey.html

The definition of the ReplayKey struct, which includes fields for client address, export ID, and transaction ID.

```rust
pub struct ReplayKey {
    pub client_addr: SocketAddr,
    pub export_id: ExportId,
    pub xid: u32,
}
```

--------------------------------

### get_port

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/portmap/dispatch/fn.get_port.html

Retrieves a port mapping based on the provided request and port configuration.

```APIDOC
## get_port

### Description
Retrieves a port mapping based on the provided request and default NFS/mount port configurations.

### Signature
`pub fn get_port(request: &mapping, nfs_port: u16, mount_port: u16) -> u32`

### Parameters
- **request** (&mapping) - The mapping request object.
- **nfs_port** (u16) - The default NFS port.
- **mount_port** (u16) - The default mount port.

### Returns
- **u32** - The resulting port number.
```

--------------------------------

### read_record_budgeted

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/fn.read_record_budgeted.html

Reads a record while reserving its maximum aggregate byte budget before the first fragment body is allocated. A whole-record reservation avoids fragmented readers holding partial reservations while waiting on each other. The returned permit keeps the record charged while it is queued or executing.

```APIDOC
## read_record_budgeted

### Signature
`pub async fn read_record_budgeted<R: AsyncRead + Unpin>(reader: &mut R, limits: RecordLimits, budget: Arc<Semaphore>) -> Result<(Vec<u8>, OwnedSemaphorePermit), RecordError>`

### Description
Reads a record while reserving its maximum aggregate byte budget before the first fragment body is allocated. A whole-record reservation avoids fragmented readers holding partial reservations while waiting on each other. The returned permit keeps the record charged while it is queued or executing.

### Parameters
- **reader** (&mut R) - The asynchronous reader to read the record from.
- **limits** (RecordLimits) - The limits applied to the record reading process.
- **budget** (Arc<Semaphore>) - The semaphore used to manage the byte budget.

### Returns
- **Result<(Vec<u8>, OwnedSemaphorePermit), RecordError>** - A tuple containing the record data as a byte vector and the semaphore permit, or a RecordError if the operation fails.
```

--------------------------------

### Define IPPROTO_UDP constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/portmap/constant.IPPROTO_UDP.html

The constant is defined as a 32-bit unsigned integer with a value of 17.

```rust
pub const IPPROTO_UDP: u32 = 17;
```

--------------------------------

### ReplayCache::is_empty

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/replay/struct.ReplayCache.html

Checks if the cache is currently empty.

```APIDOC
### pub async fn is_empty(&self) -> bool

Returns `true` if the cache contains no entries.
```

--------------------------------

### ReadDirEntryExtension Enum Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/enum.ReadDirEntryExtension.html

Defines the variants for directory entry extensions, where the Plus variant optionally includes file attributes and a file handle.

```rust
pub enum ReadDirEntryExtension {
    Basic,
    Plus {
        attributes: Option<FileAttributes>,
        handle: Option<Vec<u8>>,
    },
}
```

--------------------------------

### portmapper_addr

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/server/struct.ServerHandle.html

Retrieves the configured portmapper address.

```APIDOC
## pub fn portmapper_addr(&self) -> Option<SocketAddr>

### Description
Returns the shared TCP/UDP portmapper address, if it has been configured.

### Returns
- **Option<SocketAddr>** - The socket address if configured, otherwise None.
```

--------------------------------

### encode_readdir_entry

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/codec/fn.encode_readdir_entry.html

Encodes a ReadDirEntry into the provided encoder.

```APIDOC
## encode_readdir_entry

### Signature
`pub fn encode_readdir_entry(encoder: &mut Encoder, entry: &ReadDirEntry) -> Result<(), EncodeError>`

### Description
Encodes a directory entry into the NFSv3 encoder. This function is used to serialize directory entries during readdir operations.

### Parameters
- **encoder** (&mut Encoder) - The encoder instance used to serialize the data.
- **entry** (&ReadDirEntry) - The directory entry structure to be encoded.

### Returns
- **Result<(), EncodeError>** - Returns Ok(()) on success, or an EncodeError if the encoding fails.
```

--------------------------------

### SetAttributes Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.SetAttributes.html

The structure definition for SetAttributes, containing optional fields for file system attributes.

```rust
pub struct SetAttributes {
    pub mode: Option<u32>,
    pub uid: Option<u32>,
    pub gid: Option<u32>,
    pub size: Option<u64>,
    pub access_time: Option<SetTime>,
    pub modify_time: Option<SetTime>,
}
```

--------------------------------

### Accessing the PROGRAM constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/portmap/constant.PROGRAM.html

The constant represents the portmap program number, defined as a 32-bit unsigned integer.

```rust
pub const PROGRAM: u32 = 100000;
```

--------------------------------

### encode_readdir_entry function signature

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/codec/fn.encode_readdir_entry.html

The function signature for encoding a ReadDirEntry using an Encoder.

```rust
pub fn encode_readdir_entry(
    encoder: &mut Encoder,
    entry: &ReadDirEntry,
) -> Result<(), EncodeError>
```

--------------------------------

### Define NFS3 PROGRAM constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/types/constant.PROGRAM.html

Represents the NFS version 3 program identifier as a 32-bit unsigned integer.

```rust
pub const PROGRAM: u32 = 100_003;
```

--------------------------------

### DirectoryEntry Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.DirectoryEntry.html

The definition of the DirectoryEntry struct showing its fields.

```rust
pub struct DirectoryEntry {
    pub object: ObjectKey,
    pub file_id: u64,
    pub name: NfsName,
    pub cookie: u64,
    pub attributes: Option<FileAttributes>,
}
```

--------------------------------

### WriteArgs::validate

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.WriteArgs.html

Validates the write arguments before processing.

```APIDOC
## pub fn validate(&self) -> Result<(), NfsStatus>

### Description
Validates the current WriteArgs instance to ensure the parameters are correct for an NFSv3 write operation.

### Returns
- **Result<(), NfsStatus>** - Returns Ok(()) if valid, or an NfsStatus error if validation fails.
```

--------------------------------

### ReplayCache::len

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/replay/struct.ReplayCache.html

Returns the number of entries currently stored in the cache.

```APIDOC
### pub async fn len(&self) -> usize

Returns the current number of items in the cache.
```

--------------------------------

### Accessing the VERSION constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/mount3/types/constant.VERSION.html

The VERSION constant is defined as a 32-bit unsigned integer.

```rust
pub const VERSION: u32 = 3;
```

--------------------------------

### CreatedObject Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.CreatedObject.html

The structure definition for CreatedObject, which holds an ObjectKey and optional FileAttributes.

```rust
pub struct CreatedObject {
    pub object: ObjectKey,
    pub attributes: Option<FileAttributes>,
}
```

--------------------------------

### Encoder Methods

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/codec/struct.Encoder.html

Methods available for the Encoder struct to manage and write data to the buffer.

```APIDOC
## Encoder Methods

### new()
Creates a new, empty Encoder.

### with_capacity(capacity: usize)
Creates an encoder with room for a known fixed protocol prefix or bounded reply, avoiding geometric growth for predictable messages.

### write_u32(value: u32)
Writes a 32-bit unsigned integer to the buffer.

### write_u64(value: u64)
Writes a 64-bit unsigned integer to the buffer.

### write_bool(value: bool)
Writes a boolean value to the buffer.

### write_fixed(value: &[u8])
Writes a fixed-length byte slice to the buffer.

### write_opaque(value: &[u8]) -> Result<(), EncodeError>
Writes an opaque byte slice to the buffer, returning an error if encoding fails.

### len() -> usize
Returns the current length of the encoded data.

### is_empty() -> bool
Returns true if the encoder contains no data.

### into_bytes(self) -> Vec<u8>
Consumes the encoder and returns the underlying byte vector.
```

--------------------------------

### write_record

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/fn.write_record.html

Writes a record to an asynchronous writer with a defined maximum fragment size.

```APIDOC
## write_record

### Signature
`pub async fn write_record<W: AsyncWrite + Unpin>(writer: &mut W, record: &[u8], max_fragment_size: usize) -> Result<(), RecordError>`

### Description
Writes a byte slice record to an asynchronous writer, splitting it into fragments based on the provided maximum fragment size.

### Parameters
- **writer** (&mut W) - The asynchronous writer to output the record to.
- **record** (&[u8]) - The data record to be written.
- **max_fragment_size** (usize) - The maximum size allowed for each fragment.

### Returns
- **Result<(), RecordError>** - Returns Ok(()) on success, or a RecordError if the operation fails.
```

--------------------------------

### WccAttributes Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.WccAttributes.html

The structure definition for WccAttributes, containing fields for file size and timestamps.

```rust
pub struct WccAttributes {
    pub size: u64,
    pub modify_time: NfsTime,
    pub change_time: NfsTime,
}
```

--------------------------------

### export_matches

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/mount3/dispatch/fn.export_matches.html

Checks if the provided request path matches the given export path.

```APIDOC
## Function: export_matches

### Description
Determines whether a given request path matches an export path.

### Signature
`pub fn export_matches(export_path: &[u8], request_path: &[u8]) -> bool`

### Parameters
- **export_path** (&[u8]) - The export path to compare against.
- **request_path** (&[u8]) - The request path to check.

### Returns
- **bool** - Returns true if the paths match, false otherwise.
```

--------------------------------

### MountEntry Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/mount3/types/struct.MountEntry.html

The structure definition for MountEntry, which holds the host and path as byte vectors.

```rust
pub struct MountEntry {
    pub host: Vec<u8>,
    pub path: Vec<u8>,
}
```

--------------------------------

### pub fn encode_attributes

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/codec/fn.encode_attributes.html

Encodes the provided FileAttributes into the given Encoder.

```APIDOC
## encode_attributes

### Signature
`pub fn encode_attributes(encoder: &mut Encoder, attributes: &FileAttributes) -> Result<(), EncodeError>`

### Description
Encodes a `FileAttributes` structure into the provided `Encoder`. This function is part of the `nfsembed::nfs3::codec` module and is used during the serialization process for NFSv3 attribute data.

### Parameters
- **encoder** (&mut Encoder) - The encoder instance used to serialize the data.
- **attributes** (&FileAttributes) - The file attributes structure to be encoded.

### Returns
- **Result<(), EncodeError>** - Returns `Ok(())` on success, or an `EncodeError` if the encoding process fails.
```

--------------------------------

### NfsName::into_bytes

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.NfsName.html

Consumes the NfsName and returns the underlying byte vector.

```APIDOC
## pub fn into_bytes(self) -> Vec<u8>

### Description
Consumes the NfsName instance and returns the validated storage as a Vec<u8> without performing additional copies.

### Returns
- **Vec<u8>** - The owned byte vector.
```

--------------------------------

### MkdirArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.MkdirArgs.html

The structure definition for MkdirArgs, which includes the target directory operation arguments and the attributes to be set.

```rust
pub struct MkdirArgs {
    pub target: DirectoryOperationArgs,
    pub attributes: SetAttributes,
}
```

--------------------------------

### NfsName definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.NfsName.html

The internal structure definition for NfsName.

```rust
pub struct NfsName(/* private fields */);
```

--------------------------------

### DirectoryOperationArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.DirectoryOperationArgs.html

The primary structure used to define directory operation arguments in the NFSv3 procedure set.

```rust
pub struct DirectoryOperationArgs {
    pub directory: FileHandle,
    pub name: Vec<u8>,
}
```

--------------------------------

### MkdirResult Enum Structure

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.MkdirResult.html

The underlying enum structure for MkdirResult, defining the Ok and Err variants.

```rust
pub enum MkdirResult {
    Ok {
        object_handle: Option<Vec<u8>>,
        object_attributes: Option<FileAttributes>,
        directory_wcc: WccData,
    },
    Err {
        status: NfsStatus,
        directory_wcc: WccData,
    },
}
```

--------------------------------

### FileType Enum Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/enum.FileType.html

The enumeration of supported file system entry types.

```rust
pub enum FileType {
    Regular,
    Directory,
    BlockDevice,
    CharacterDevice,
    Symlink,
    Socket,
    Fifo,
}
```

--------------------------------

### Define RecordLimits struct

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/struct.RecordLimits.html

The structure definition for RecordLimits, containing fields for record and fragment size constraints.

```rust
pub struct RecordLimits {
    pub max_record_size: usize,
    pub max_fragment_size: usize,
    pub max_fragments: usize,
}
```

--------------------------------

### SetTime Enum Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/enum.SetTime.html

The definition of the SetTime enum, showing its variants for server and client time.

```rust
pub enum SetTime {
    ServerTime,
    ClientTime(NfsTime),
}
```

--------------------------------

### DirectoryOperationArgs Structure

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.RmdirArgs.html

The underlying structure for RmdirArgs, containing the directory path and the name of the entry to remove.

```rust
pub struct RmdirArgs {
    pub directory: Vec<u8>,
    pub name: Vec<u8>,
}
```

--------------------------------

### Define NFSv3 Procedure Enum

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/dispatch/enum.Procedure.html

The Procedure enum uses repr(u32) to map NFSv3 operations to their corresponding wire protocol identifiers.

```rust
#[repr(u32)]
pub enum Procedure {
Show 22 variants    Null = 0,
    GetAttr = 1,
    SetAttr = 2,
    Lookup = 3,
    Access = 4,
    ReadLink = 5,
    Read = 6,
    Write = 7,
    Create = 8,
    Mkdir = 9,
    Symlink = 10,
    Mknod = 11,
    Remove = 12,
    Rmdir = 13,
    Rename = 14,
    Link = 15,
    ReadDir = 16,
    ReadDirPlus = 17,
    FsStat = 18,
    FsInfo = 19,
    PathConf = 20,
    Commit = 21,
}
```

--------------------------------

### AccessArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.AccessArgs.html

The primary structure definition for AccessArgs, containing the target file handle and requested access permissions.

```rust
pub struct AccessArgs {
    pub object: FileHandle,
    pub requested: u32,
}
```

--------------------------------

### read_record_budgeted function signature

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/fn.read_record_budgeted.html

The function signature for reading a record with a budgeted semaphore permit.

```rust
pub async fn read_record_budgeted<R: AsyncRead + Unpin>(
    reader: &mut R,
    limits: RecordLimits,
    budget: Arc<Semaphore>,
) -> Result<(Vec<u8>, OwnedSemaphorePermit), RecordError>
```

--------------------------------

### IPPROTO_TCP Constant Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/portmap/constant.IPPROTO_TCP.html

Defines the TCP protocol constant as a u32 value of 6.

```rust
pub const IPPROTO_TCP: u32 = 6;
```

--------------------------------

### SymlinkArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.SymlinkArgs.html

The structure definition for SymlinkArgs, which includes the target directory operation arguments, file attributes, and the path as a byte vector.

```rust
pub struct SymlinkArgs {
    pub target: DirectoryOperationArgs,
    pub attributes: SetAttributes,
    pub path: Vec<u8>,
}
```

--------------------------------

### MknodResult Enum Structure

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.MknodResult.html

The underlying enum structure for MknodResult, defining Ok and Err variants.

```rust
pub enum MknodResult {
    Ok {
        object_handle: Option<Vec<u8>>,
        object_attributes: Option<FileAttributes>,
        directory_wcc: WccData,
    },
    Err {
        status: NfsStatus,
        directory_wcc: WccData,
    },
}
```

--------------------------------

### WccData Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/types/struct.WccData.html

The structure definition for WccData, containing optional before and after attributes.

```rust
pub struct WccData {
    pub before: Option<WccAttributes>,
    pub after: Option<FileAttributes>,
}
```

--------------------------------

### write_record function signature

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/fn.write_record.html

The function signature for writing records asynchronously to an AsyncWrite implementor.

```rust
pub async fn write_record<W: AsyncWrite + Unpin>(
    writer: &mut W,
    record: &[u8],
    max_fragment_size: usize,
) -> Result<(), RecordError>
```

--------------------------------

### Define NoopMetrics struct

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/observability/struct.NoopMetrics.html

The definition of the NoopMetrics struct.

```rust
pub struct NoopMetrics;
```

--------------------------------

### WriteRequest Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.WriteRequest.html

The structure definition for WriteRequest, containing the file handle, offset, count, stability level, and data payload.

```rust
pub struct WriteRequest {
    pub object: FileHandle,
    pub offset: u64,
    pub count: u32,
    pub requested: WriteStability,
    pub data: Bytes,
}
```

--------------------------------

### read_record_budgeted

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/index.html

Reads a record while reserving its maximum aggregate byte budget before the first fragment body is allocated.

```APIDOC
## read_record_budgeted

### Description
Reads a record while reserving its maximum aggregate byte budget before the first fragment body is allocated. A whole-record reservation avoids fragmented readers holding partial reservations while waiting on each other. The returned permit keeps the record charged while it is queued or executing.
```

--------------------------------

### RequestFingerprint Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/replay/struct.RequestFingerprint.html

The primary definition of the RequestFingerprint struct as a tuple containing a 32-byte array.

```rust
pub struct RequestFingerprint(pub [u8; 32]);
```

--------------------------------

### FsInfoArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.FsInfoArgs.html

The underlying structure definition for the aliased type.

```rust
pub struct FsInfoArgs {
    pub object: Vec<u8>,
}
```

--------------------------------

### encode_post_attributes function signature

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/codec/fn.encode_post_attributes.html

The function signature for encoding file attributes in the NFSv3 codec.

```rust
pub fn encode_post_attributes(
    encoder: &mut Encoder,
    attributes: Option<&FileAttributes>,
) -> Result<(), EncodeError>
```

--------------------------------

### MkdirResult Type Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.MkdirResult.html

The type alias definition for MkdirResult.

```rust
pub type MkdirResult = CreateResult;
```

--------------------------------

### Define the Metrics trait

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/observability/trait.Metrics.html

The trait defines optional methods for tracking connection and request events. Implementations must be Send, Sync, and 'static.

```rust
pub trait Metrics:
    Send
    + Sync
    + 'static {
    // Provided methods
    fn connection_opened(&self) { ... }
    fn connection_closed(&self) { ... }
    fn request_finished(
        &self,
        _procedure: u32,
        _duration: Duration,
        _status: u32,
    ) { ... }
    fn request_rejected(&self, _reason: &'static str) { ... }
}
```

--------------------------------

### ObjectArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.ObjectArgs.html

The definition of the ObjectArgs struct containing the object file handle.

```rust
pub struct ObjectArgs {
    pub object: FileHandle,
}
```

--------------------------------

### LinkArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.LinkArgs.html

The structure definition for LinkArgs, containing the object file handle and target directory operation arguments.

```rust
pub struct LinkArgs {
    pub object: FileHandle,
    pub target: DirectoryOperationArgs,
}
```

--------------------------------

### WriteArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/struct.WriteArgs.html

The primary structure used to encapsulate write request parameters.

```rust
pub struct WriteArgs {
    pub object: FileHandle,
    pub offset: u64,
    pub count: u32,
    pub requested: WriteStability,
    pub data: Vec<u8>,
}
```

--------------------------------

### DeviceNumber Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.DeviceNumber.html

The structure definition for DeviceNumber, containing major and minor fields as unsigned 32-bit integers.

```rust
pub struct DeviceNumber {
    pub major: u32,
    pub minor: u32,
}
```

--------------------------------

### truncate_readdir_result

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/codec/index.html

Applies the production READDIR wire-size policy to a complete typed result. It ensures the result fits within the specified max_size, excluding the status discriminant as required by RFC 1813.

```APIDOC
## truncate_readdir_result

### Description
Applies the production READDIR wire-size policy to a complete typed result. Returns `false` when even the empty success shape cannot fit.

### Parameters
- **max_size** (usize) - Required - The maximum size allowed for the successful result arm.
```

--------------------------------

### LookupArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.LookupArgs.html

The underlying structure definition for LookupArgs, containing the directory and name fields.

```rust
pub struct LookupArgs {
    pub directory: Vec<u8>,
    pub name: Vec<u8>,
}
```

--------------------------------

### read_record function signature

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/fn.read_record.html

The function signature for reading a record asynchronously from an AsyncRead source.

```rust
pub async fn read_record<R: AsyncRead + Unpin>(
    reader: &mut R,
    limits: RecordLimits,
) -> Result<Vec<u8>, RecordError>
```

--------------------------------

### ReadBytesResult Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.ReadBytesResult.html

The definition of the ReadBytesResult struct, which holds the data, EOF status, and file attributes.

```rust
pub struct ReadBytesResult {
    pub data: Bytes,
    pub eof: bool,
    pub attributes: Option<FileAttributes>,
}
```

--------------------------------

### ReadLinkArgs Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.ReadLinkArgs.html

The underlying structure definition for the aliased type.

```rust
pub struct ReadLinkArgs {
    pub object: Vec<u8>,
}
```

--------------------------------

### write_record_limited

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/record/fn.write_record_limited.html

Writes one record while enforcing aggregate size and fragment-count limits as well as the per-fragment limit.

```APIDOC
## Function: write_record_limited

### Description
Writes one record to an asynchronous writer while enforcing aggregate size, fragment-count, and per-fragment limits.

### Signature
`pub async fn write_record_limited<W: AsyncWrite + Unpin>(writer: &mut W, record: &[u8], limits: RecordLimits) -> Result<(), RecordError>`

### Parameters
- **writer** (&mut W) - The asynchronous writer to which the record is written.
- **record** (&[u8]) - The data record to be written.
- **limits** (RecordLimits) - The constraints applied to the write operation.
```

--------------------------------

### NfsTime Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.NfsTime.html

The definition of the NfsTime struct showing its public fields.

```rust
pub struct NfsTime {
    pub seconds: u64,
    pub nanoseconds: u32,
}
```

--------------------------------

### Define PROCEDURE_COUNT constant

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/types/constant.PROCEDURE_COUNT.html

Represents the total count of NFSv3 procedures as a 32-bit unsigned integer.

```rust
pub const PROCEDURE_COUNT: u32 = 22;
```

--------------------------------

### ReadResult Struct Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/vfs/struct.ReadResult.html

The structure definition for ReadResult, containing the byte data, EOF status, and optional file attributes.

```rust
pub struct ReadResult {
    pub data: Vec<u8>,
    pub eof: bool,
    pub attributes: Option<FileAttributes>,
}
```

--------------------------------

### Structure of PathConfArgs

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/procedures/type.PathConfArgs.html

The underlying structure of the PathConfArgs type.

```rust
pub struct PathConfArgs {
    pub object: Vec<u8>,
}
```

--------------------------------

### MAX_PATH Constant Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/mount3/types/constant.MAX_PATH.html

The constant represents the maximum path length allowed by the library.

```rust
pub const MAX_PATH: usize = 1024;
```

--------------------------------

### pub fn encode_wcc

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/nfs3/codec/fn.encode_wcc.html

Encodes WccData into the provided encoder. This function is part of the nfs3 codec implementation.

```APIDOC
## encode_wcc

### Signature
`pub fn encode_wcc(encoder: &mut Encoder, wcc: &WccData) -> Result<(), EncodeError>`

### Description
Encodes the provided `WccData` structure into the given `Encoder` instance. This is used during the serialization process for NFSv3 protocol messages.

### Parameters
- **encoder** (&mut Encoder) - The encoder instance to write the data into.
- **wcc** (&WccData) - The Weak Cache Consistency data to be encoded.

### Returns
- **Result<(), EncodeError>** - Returns `Ok(())` on success, or an `EncodeError` if the encoding process fails.
```

--------------------------------

### AUTH_NONE Constant Definition

Source: https://docs.rs/nfsembed/0.1.0/nfsembed/rpc/auth/constant.AUTH_NONE.html

Defines the AUTH_NONE constant as a 32-bit unsigned integer with a value of 0.

```rust
pub const AUTH_NONE: u32 = 0;
```
Tokens:
Raw