Struct riot_wrappers::gnrc_pktbuf::Pktsnip

pub struct Pktsnip<M: Mode> { /* private fields */ }

Available on riot_module_gnrc_pktbuf only.

Wrapper type around gnrc_pktsnip_t that takes care of the reference counting involved.

By constructing a Pktsnip, it is also asserted that any snip annotations are correct (for example, that a GNRC_NETTYPE_IPV6 snip does contain a full IPv6 header, as demanded by gnrc_ipv6_get_header).

Implementations

impl<'a> Pktsnip<Writable>

pub fn icmpv6_echo_build( type_: EchoType, id: u16, seq: u16, payload: &[u8] ) -> Result<Pktsnip<Writable>, NotEnoughSpace>

Available on riot_module_gnrc and riot_module_gnrc_icmpv6 only.

impl<M: Mode> Pktsnip<M>

pub fn ipv6_get_header(&self) -> Option<&Header>

Available on riot_module_gnrc and riot_module_ipv6 only.

Get the IPv6 header of the snip, if there is any thusly typed snip present

pub fn ipv6_hdr_build( self, src: Option<&Address>, dst: Option<&Address> ) -> Result<Pktsnip<Writable>, NotEnoughSpace>

Available on riot_module_gnrc and riot_module_ipv6 only.

Build an IPv6 header around the Pktsnip

impl<M: Mode> Pktsnip<M>

pub fn len(&self) -> usize

pub fn count(&self) -> usize

pub fn iter_snips(&self) -> SnipIter<'_>

pub fn search_type(&self, type_: gnrc_nettype_t) -> Option<PktsnipPart<'_>>

pub fn data(&self) -> &[u8]

Return the data of only the first snip of self.

pub unsafe fn to_ptr(self) -> *mut gnrc_pktsnip_t

Relinquish the safe Pktsnip into a pointer. The caller is responsible for calling gnrc_pktbuf_release on the result, or passing it on to someone who will.

This is not technically unsafe as it leaks the item to get a pointer out; it’s left unsafe more as a warning flag.

pub fn udp_hdr_build( self, src: NonZeroU16, dst: NonZeroU16 ) -> Result<Pktsnip<Writable>, NotEnoughSpace>

Available on riot_module_udp only.

Build a UDP header around the Pktsnip

pub fn netif_hdr_build( self, src: Option<&[u8]>, dst: Option<&[u8]> ) -> Result<Pktsnip<Writable>, NotEnoughSpace>

pub fn add( self, size: usize, nettype: gnrc_nettype_t ) -> Result<Pktsnip<Writable>, NotEnoughSpace>

Allocate and prepend an uninitialized snip of given size and type to self, returning a new (writable) snip.

impl<'a> Pktsnip<Shared>

pub unsafe fn from_ptr(input: *mut gnrc_pktsnip_t) -> Self

Take responsibility for a pointer

The pointer must currently have a refcount of at least 1; dropping the result decrements it.

pub fn start_write(self) -> Result<Pktsnip<Writable>, NotEnoughSpace>

Create an exclusive version of this pktsnip

This involves a copy if the current reference count is > 1.

impl<'a> Pktsnip<Writable>

pub unsafe fn from_ptr(input: *mut gnrc_pktsnip_t) -> Self

Take responsibility for a pointer

The pointer must currently have a refcount of 1; the buffer is freed when the result is dropped.

pub fn allocate( size: usize, nettype: gnrc_nettype_t ) -> Result<Self, NotEnoughSpace>

Allocate an uninitialized pktsnip. That its data is uninitialized is currently not expressed in Rust as the author thinks it’s harmless (any u8 is a valid u8, and the compiler can’t know that we’re receiving uninitialized memory here so it can’t take any shortcuts if someone ever read from it).

pub fn allocate_from( data: &[u8], nettype: gnrc_nettype_t ) -> Result<Self, NotEnoughSpace>

Allocate a pktsnip and copy the slice into it.

pub fn data_mut(&'a mut self) -> &'a mut [u8]

pub fn realloc_data(&mut self, size: usize) -> Result<(), NotEnoughSpace>

Trait Implementations

impl Clone for Pktsnip<Shared>

fn clone(&self) -> Pktsnip<Shared>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Mode> Debug for Pktsnip<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M: Mode> Drop for Pktsnip<M>

fn drop(&mut self)

Executes the destructor for this type.

impl Into<Pktsnip<Shared>> for Pktsnip<Writable>

fn into(self) -> Pktsnip<Shared>

Converts this type into the (usually inferred) input type.

impl Send for Pktsnip<Shared>

Pktsnip can be send because any volatile fields are accessed through the appropriate functions (hold, release), and the non-volatile fields are only written to by threads that made sure they obtained a COW copy using start_write.