Enum NetError 

#[repr(C)]
pub enum NetError {
    Success = 0,
    NullPointer = -1,
    InvalidUtf8 = -2,
    InvalidJson = -3,
    InitFailed = -4,
    IngestionFailed = -5,
    PollFailed = -6,
    BufferTooSmall = -7,
    ShuttingDown = -8,
    IntOverflow = -9,
    MismatchedHandles = -10,
    InteriorNul = -11,
    InvalidArgument = -12,
    Unknown = -99,
}

Error codes returned by FFI functions.

Copy because it is a fieldless #[repr(C)] enum that is passed by value everywhere already; having it lets the header-parity guard read each variant’s discriminant directly.

Variants

Success = 0

Success (no error).

NullPointer = -1

Null pointer passed.

InvalidUtf8 = -2

Invalid UTF-8 string.

InvalidJson = -3

Invalid JSON.

InitFailed = -4

Initialization failed.

IngestionFailed = -5

Ingestion failed (backpressure).

PollFailed = -6

Poll failed.

BufferTooSmall = -7

Buffer too small.

ShuttingDown = -8

Shutting down.

IntOverflow = -9

Integer overflow: result does not fit in c_int.

MismatchedHandles = -10

Stream handle does not belong to the supplied node handle. Previously the send-family FFIs accepted any (stream, node) pair without verifying they were created from the same node, allowing silent cross-session traffic.

InteriorNul = -11

CString::new failure: the input bytes are valid UTF-8 by Rust’s String invariant but contain an interior NUL byte — and the C ABI cannot represent that, since C strings are NUL-terminated. Pre-fix this was reported as InvalidUtf8, which was wrong: the input is UTF-8-valid; it just has a NUL where C expects it not to. A binding reading the typed error and seeing “invalid UTF-8” would chase the wrong cause.

InvalidArgument = -12

Input deserialized cleanly but is semantically unusable — e.g. a scope filter whose kind is unrecognized, or whose required selector is missing / empty / an all-empty list.

Distinct from Self::InvalidJson, which means the bytes were not valid JSON at all. Reporting these as InvalidJson would send a caller looking for a syntax error that isn’t there — the same reasoning that made Self::InteriorNul its own code.

Returning an error rather than silently widening is the point: a narrowing filter that cannot narrow must fail closed.

Unknown = -99

Unknown error.

Trait Implementations

impl Clone for NetError

fn clone(&self) -> NetError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for NetError

impl From<NetError> for c_int

fn from(e: NetError) -> Self

Converts to this type from the input type.