sig-net 0.5.1

Sig-Net secure CoAP-based DMX512 lighting control protocol library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::*;

fn option_nibble(value: u16) -> (u8, u8) {
    match value {
        0..=12 => (value as u8, 0),
        13..=268 => (13, 1),
        _ => (14, 2),  // >= 269
    }
}

fn encode_option_nibble(buffer: &mut PacketBuffer, delta: u16, length: u16) -> Result<()> {
    let (delta_nib, delta_ext) = option_nibble(delta);
    let (len_nib, len_ext) = option_nibble(length);

    let nibble = (delta_nib << 4) | len_nib;
    buffer.write_byte(nibble)?;

    match delta_ext {
        1 => buffer.write_byte((delta - 13) as u8)?,
        2 => buffer.write_u16(delta - 269)?,
        _ => {}
    }

    match len_ext {
        1 => buffer.write_byte((length - 13) as u8)?,
        2 => buffer.write_u16(length - 269)?,
        _ => {}
    }

    Ok(())
}

pub fn encode_coap_option(
    buffer: &mut PacketBuffer,
    option_number: u16,
    prev_option: u16,
    option_value: &[u8],
) -> Result<()> {
    let delta = option_number - prev_option;
    encode_option_nibble(buffer, delta, option_value.len() as u16)?;
    buffer.write_bytes(option_value)
}

pub fn build_coap_header(buffer: &mut PacketBuffer, message_id: u16) -> Result<()> {
    let header = CoAPHeader::new(message_id);
    buffer.write_bytes(&header.to_bytes())
}

pub fn build_uri_path_options(buffer: &mut PacketBuffer, universe: u16) -> Result<()> {
    if universe < MIN_UNIVERSE || universe > MAX_UNIVERSE {
        return Err(SigNetError::InvalidArgument);
    }

    let segments = [
        SIGNET_URI_PREFIX,
        SIGNET_URI_VERSION,
        SIGNET_URI_SCOPE_DEFAULT,
        SIGNET_URI_LEVEL,
    ];

    let mut prev_option: u16 = 0;
    for &segment in &segments {
        encode_coap_option(buffer, COAP_OPTION_URI_PATH, prev_option, segment.as_bytes())?;
        prev_option = COAP_OPTION_URI_PATH;
    }

    let universe_str = universe.to_string();
    encode_coap_option(buffer, COAP_OPTION_URI_PATH, prev_option, universe_str.as_bytes())
}

pub fn build_uri_string(universe: u16, uri_output: &mut [u8]) -> Result<usize> {
    if universe < MIN_UNIVERSE || universe > MAX_UNIVERSE {
        return Err(SigNetError::InvalidArgument);
    }
    let s = format!(
        "/{}/{}/{}/{}/{}",
        SIGNET_URI_PREFIX,
        SIGNET_URI_VERSION,
        SIGNET_URI_SCOPE_DEFAULT,
        SIGNET_URI_LEVEL,
        universe
    );
    let bytes = s.as_bytes();
    if bytes.len() > uri_output.len() {
        return Err(SigNetError::InvalidArgument);
    }
    uri_output[..bytes.len()].copy_from_slice(bytes);
    Ok(bytes.len())
}

pub fn build_node_uri_string(
    tuid: &[u8; TUID_LENGTH],
    endpoint: u16,
    uri_output: &mut [u8],
) -> Result<usize> {
    let hex = TUID(*tuid).to_hex();
    let hex_str = core::str::from_utf8(&hex).unwrap_or("000000000000");
    let s = format!(
        "/{}/{}/{}/{}/{}/{}",
        SIGNET_URI_PREFIX,
        SIGNET_URI_VERSION,
        SIGNET_URI_SCOPE_DEFAULT,
        SIGNET_URI_NODE,
        hex_str,
        endpoint
    );
    let bytes = s.as_bytes();
    if bytes.len() > uri_output.len() {
        return Err(SigNetError::InvalidArgument);
    }
    uri_output[..bytes.len()].copy_from_slice(bytes);
    Ok(bytes.len())
}