Struct PacketBuffer

pub struct PacketBuffer<'b> {
    pkt: &'b mut coap_pkt_t,
    buf: *mut u8,
    len: usize,
}

Available on riot_module_gcoap only.

A representation of the incoming or outgoing data on the server side of a request. This includes the coap_pkt_t pre-parsed header and option pointers as well as the memory area dedicated to returning the packet.

This struct wraps the unsafety of the C API, but does not structurally ensure that valid CoAP messages are created. (For example, it does not keep the user from adding options after the payload marker). Use CoAP generalization for that.

Fields

pkt: &'b mut coap_pkt_t

buf: *mut u8

len: usize

Implementations

impl<'b> PacketBuffer<'b>

pub fn get_code_raw(&self) -> u8

Wrapper for coap_get_code_raw

pub fn resp_init(&mut self, code: u8) -> Result<(), NumericError>

Wrapper for gcoap_resp_init

As it is used and wrapped here, this makes GCOAP_RESP_OPTIONS_BUF bytes unusable, but working around that would mean duplicating code. Just set GCOAP_RESP_OPTIONS_BUF to zero to keep the overhead low.

pub fn set_code_raw(&mut self, code: u8)

pub fn get_length(&self, payload_used: usize) -> usize

Return the total number of bytes in the message, given that payload_used bytes were written at the payload pointer. Note that those bytes have to include the payload marker.

This measures the distance between the payload pointer in the pkt and the start of the buffer. It is the header length after prepare_response, and grows as options are added.

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

A view of the current message payload

This is only the CoAP payload after opt_finish has been called; before, it is a view on the remaining buffer space after any options that have already been added.

pub fn payload_mut(&mut self) -> &mut [u8]

A mutable view of the current message payload

See payload.

pub fn opt_add_uint( &mut self, optnum: u16, value: u32, ) -> Result<(), NumericError>

Add an integer value as an option

pub fn opt_add_opaque( &mut self, optnum: u16, data: &[u8], ) -> Result<(), NumericError>

Add a binary value as an option

pub fn opt_iter<'a>(&'a self) -> PacketBufferOptIter<'a, 'b>

pub fn opt_iter_mut<'a>(&'a mut self) -> PacketBufferOptIterMut<'a, 'b>

Trait Implementations

impl<'b> Debug for PacketBuffer<'b>

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

Formats the value using the given formatter.

impl<'b> ReadableMessage for PacketBuffer<'b>

type Code = u8

See Self::code()

type OptionsIter<'a> = OptionsIterator<'a, 'b> where Self: 'a

See Self::options()

type MessageOption<'a> = MessageOption<'a> where Self: 'a

Type of an individual option, indiciating its option number and value

fn code(&self) -> Self::Code

Get the code (request method or response code) of the message

fn payload(&self) -> &[u8]

Get the payload set in the message

fn options(&self) -> Self::OptionsIter<'_>

Produce all options in arbitrary order as an iterator

fn with_static_type_annotation(&self) -> Option<RefWithStaticType<'_, Self>>

Type ID of Self or a ’static version of Self

impl<'b> WithSortedOptions for PacketBuffer<'b>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 12 bytes