dnp3 1.6.0

Rust implementation of DNP3 (IEEE 1815) with idiomatic bindings for C, C++, .NET, and Java
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

use crate::app::measurement::*;
use crate::app::parse::traits::FixedSize;
use crate::app::variations::{Group2Var3, Group4Var3};

use scursor::{WriteCursor, WriteError};

pub(crate) enum Continue {
    Ok,
    NewHeader,
}

pub(crate) trait ToVariationCto<V>
where
    V: FixedSize,
{
    fn get_time(&self) -> Option<Time>;
    fn to_cto_variation(&self, timestamp: u16) -> V;
}

fn write_prefixed<V>(cursor: &mut WriteCursor, variation: &V, index: u16) -> Result<(), WriteError>
where
    V: FixedSize,
{
    cursor.write_u16_le(index)?;
    variation.write(cursor)?;
    Ok(())
}

/// Conforms to the WriteFn<T> function type for any type can be converted to a variation that is fixed size
pub(crate) fn write_fixed_size<V, T>(
    cursor: &mut WriteCursor,
    event: &T,
    index: u16,
    _: Time,
) -> Result<Continue, WriteError>
where
    T: ToVariation<V>,
    V: FixedSize,
{
    write_prefixed(cursor, &event.to_variation(), index).map(|_| Continue::Ok)
}

pub(crate) fn write_cto<V, T>(
    cursor: &mut WriteCursor,
    event: &T,
    index: u16,
    cto: Time,
) -> Result<Continue, WriteError>
where
    T: ToVariationCto<V>,
    V: FixedSize,
{
    let time: Time = event.get_time().into();

    // do they both have the same synchronization?
    if time.is_synchronized() != cto.is_synchronized() {
        return Ok(Continue::NewHeader);
    }

    // the timestamp is < the CTO
    if cto.timestamp().raw_value() > time.timestamp().raw_value() {
        return Ok(Continue::NewHeader);
    }

    // this can't underflow b/c of check above
    let difference: u64 = time.timestamp().raw_value() - cto.timestamp().raw_value();

    // too big of a difference to encode
    if difference > u16::MAX.into() {
        return Ok(Continue::NewHeader);
    }

    let variation = event.to_cto_variation(difference as u16); // difference in range [0, u16::max]

    write_prefixed(cursor, &variation, index).map(|_| Continue::Ok)
}

pub(crate) fn write_octet_string(
    cursor: &mut WriteCursor,
    event: &[u8],
    index: u16,
) -> Result<Continue, WriteError> {
    cursor.write_u16_le(index)?;
    cursor.write_bytes(event)?;
    Ok(Continue::Ok)
}

impl ToVariationCto<Group2Var3> for BinaryInput {
    fn get_time(&self) -> Option<Time> {
        self.time
    }

    fn to_cto_variation(&self, timestamp: u16) -> Group2Var3 {
        Group2Var3 {
            flags: self.get_wire_flags(),
            time: timestamp,
        }
    }
}

impl ToVariationCto<Group4Var3> for DoubleBitBinaryInput {
    fn get_time(&self) -> Option<Time> {
        self.time
    }

    fn to_cto_variation(&self, timestamp: u16) -> Group4Var3 {
        Group4Var3 {
            flags: self.get_wire_flags(),
            time: timestamp,
        }
    }
}