bacnet-server 0.15.0

BACnet server: APDU dispatch and service handlers
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use super::*;

pub(super) fn can_segment(segmentation: Segmentation) -> bool {
    matches!(segmentation, Segmentation::BOTH | Segmentation::TRANSMIT)
}

pub(super) fn limit(peer: u16, local: u32) -> u16 {
    peer.min(u16::try_from(local).unwrap_or(u16::MAX))
}

pub(super) async fn response(
    db: &RwLock<ObjectDatabase>,
    request: &ConfirmedRequestPdu,
    mut budget: GetEventInformationBudget,
    effective_max_apdu: u16,
    segmented_response_available: bool,
) -> Apdu {
    if !segmented_response_available {
        budget.max_service_ack_bytes =
            budget
                .max_service_ack_bytes
                .min(unsegmented_complex_ack_service_budget(
                    request.invoke_id,
                    request.service_choice,
                    effective_max_apdu,
                ));
    }
    let mut service_ack = BytesMut::new();
    let db = db.read().await;
    match handlers::handle_get_event_information_configured(
        &db,
        &request.service_request,
        &mut service_ack,
        budget,
    ) {
        Ok(()) => Apdu::ComplexAck(ComplexAck {
            segmented: false,
            more_follows: false,
            invoke_id: request.invoke_id,
            sequence_number: None,
            proposed_window_size: None,
            service_choice: request.service_choice,
            service_ack: service_ack.freeze(),
        }),
        Err(handlers::EventInformationFailure::Service(error)) => {
            confirmed_response::error_apdu_from_error(
                request.invoke_id,
                request.service_choice,
                &error,
            )
        }
        Err(failure) => Apdu::Abort(AbortPdu {
            sent_by_server: true,
            invoke_id: request.invoke_id,
            abort_reason: match failure {
                handlers::EventInformationFailure::Objects => AbortReason::OUT_OF_RESOURCES,
                _ => AbortReason::BUFFER_OVERFLOW,
            },
        }),
    }
}

pub(super) fn unsegmented_complex_ack_service_budget(
    invoke_id: u8,
    service_choice: ConfirmedServiceChoice,
    max_apdu: u16,
) -> usize {
    let envelope = Apdu::ComplexAck(ComplexAck {
        segmented: false,
        more_follows: false,
        invoke_id,
        sequence_number: None,
        proposed_window_size: None,
        service_choice,
        service_ack: Bytes::new(),
    });
    let mut encoded = BytesMut::new();
    encode_apdu(&mut encoded, &envelope).expect("valid empty ComplexACK encoding");
    usize::from(max_apdu).saturating_sub(encoded.len())
}

#[cfg(test)]
mod budget_tests {
    use super::*;

    #[tokio::test]
    async fn get_event_information_default_rejects_4097_total_objects() {
        for count in [4096, 4097] {
            let mut database = ObjectDatabase::new();
            for instance in 0..count {
                database
                    .add(Box::new(
                        bacnet_objects::notification_class::NotificationClass::new(
                            instance,
                            format!("NC-{instance}"),
                        )
                        .unwrap(),
                    ))
                    .unwrap();
            }
            let request = ConfirmedRequestPdu {
                segmented: false,
                more_follows: false,
                segmented_response_accepted: true,
                max_segments: None,
                max_apdu_length: 1476,
                invoke_id: 77,
                sequence_number: None,
                proposed_window_size: None,
                service_choice: ConfirmedServiceChoice::GET_EVENT_INFORMATION,
                service_request: Bytes::new(),
            };
            let response = response(
                &RwLock::new(database),
                &request,
                GetEventInformationBudget::default(),
                1476,
                true,
            )
            .await;
            if count == 4096 {
                assert!(
                    matches!(response, Apdu::ComplexAck(ack) if ack.service_ack.as_ref() == [0x0e, 0x0f, 0x19, 0])
                );
            } else {
                assert!(matches!(response, Apdu::Abort(abort)
            if abort.sent_by_server && abort.abort_reason == AbortReason::OUT_OF_RESOURCES));
            }
        }
    }
}