A lightweight low-level CoAP message manipulation crate.
Its goal is to be compliant with the CoAP standards and to provide a building block for libraries (e.g. coap) and applications.
coap-lite supports #![no_std] and embedded environments.
It was originally based on the improved low-level message handling code from the [coap] crate as well as [rust-async-coap], made to work in bare metal environments.
This crate provides several types that can be used to build, modify and encode/decode CoAP messages to/from their byte representation.
Note for no_std users: it does require allocation, so you might have to set a global allocator depending on your target.
The following example uses std::net::UdpSocket to send the UDP packet but
you can use anything, e.g. smoltcp
for embedded.
```rust use coap_lite::{ CoapRequest, RequestType as Method }; use std::net::{SocketAddr, UdpSocket};
fn main() {
let mut request: CoapRequest
request.set_method(Method::Get);
request.set_path("/test");
let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
let packet = request.message.to_bytes().unwrap();
socket.send_to(&packet[..], "127.0.0.1:5683").expect("Could not send the data");
} ```
```rust use coap_lite::{CoapRequest, Packet}; use std::net::{UdpSocket};
fn main() { let socket = UdpSocket::bind("127.0.0.1:5683").unwrap(); let mut buf = [0; 100]; let (size, src) = socket.recv_from(&mut buf).expect("Didn't receive data");
println!("Payload {:x?}", &buf[..size]);
let packet = Packet::from_bytes(&buf[..size]).unwrap();
let request = CoapRequest::from_packet(packet, src);
let method = request.get_method().clone();
let path = request.get_path();
println!("Received CoAP request '{:?} {}' from {}", method, path, src);
let mut response = request.response.unwrap();
response.message.payload = b"OK".to_vec();
let packet = response.message.to_bytes().unwrap();
socket.send_to(&packet[..], &src).expect("Could not send the data");
} ```
```rust use coap_lite::{ CoapOption, MessageClass, MessageType, Packet, RequestType, ResponseType, };
let mut request = Packet::new(); request.header.messageid = 23839; request.header.code = MessageClass::Request(RequestType::Get); request.settoken(vec![0, 0, 57, 116]); request.addoption(CoapOption::UriHost, b"localhost".tovec()); request.addoption(CoapOption::UriPath, b"tv1".tovec()); asserteq!( [ 0x44, 0x01, 0x5D, 0x1F, 0x00, 0x00, 0x39, 0x74, 0x39, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x68, 0x6F, 0x73, 0x74, 0x83, 0x74, 0x76, 0x31, ], request.tobytes().unwrap()[..] );
let response = Packet::frombytes(&[ 0x64, 0x45, 0x5D, 0x1F, 0x00, 0x00, 0x39, 0x74, 0xFF, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21, ]) .unwrap(); asserteq!(23839, response.header.messageid); asserteq!( MessageClass::Response(ResponseType::Content), response.header.code ); asserteq!(MessageType::Acknowledgement, response.header.gettype()); asserteq!([0, 0, 57, 116], response.gettoken()[..]); assert_eq!(b"Hello World!", &response.payload[..]); ```
Licensed under either of
at your option.
This is a modification of the coap and rust-async-coap crates, their licenses are in LICENSE-3RD-PARTY.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.