bacnet-client 0.15.0

BACnet async client: TSM, segmentation, discovery, and service APIs
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

use bacnet_types::MacAddr;
use bacnet_types::enums::AbortReason;

use super::{FinalSegmentIssue, TransactionOwner, TransactionPhase, Tsm};

#[derive(Debug)]
pub(crate) enum SegmentedResponseAdmission {
    Active(TransactionOwner),
    FinalSegmentSendPolling {
        owner: TransactionOwner,
        issue: FinalSegmentIssue,
    },
    InitialResponseAborted {
        wire_reason: AbortReason,
    },
    CoordinatorRejected,
    NoTransaction,
}

impl Tsm {
    /// Gate an initial segmented ComplexACK before receive state is allocated.
    pub(crate) fn admit_segmented_complex_ack(
        &mut self,
        source_mac: &[u8],
        invoke_id: u8,
        sequence_number: u8,
        segmented_response_accepted: bool,
    ) -> SegmentedResponseAdmission {
        self.admit_segmented_complex_ack_inner(
            source_mac,
            invoke_id,
            sequence_number,
            segmented_response_accepted,
            None,
        )
    }

    pub(crate) fn admit_segmented_complex_ack_for_owner(
        &mut self,
        source_mac: &[u8],
        invoke_id: u8,
        sequence_number: u8,
        segmented_response_accepted: bool,
        owner: &TransactionOwner,
    ) -> SegmentedResponseAdmission {
        self.admit_segmented_complex_ack_inner(
            source_mac,
            invoke_id,
            sequence_number,
            segmented_response_accepted,
            Some(owner),
        )
    }

    fn admit_segmented_complex_ack_inner(
        &mut self,
        source_mac: &[u8],
        invoke_id: u8,
        sequence_number: u8,
        segmented_response_accepted: bool,
        expected_owner: Option<&TransactionOwner>,
    ) -> SegmentedResponseAdmission {
        let key = (MacAddr::from_slice(source_mac), invoke_id);
        let Some(pending) = self.pending.get(&key) else {
            return SegmentedResponseAdmission::NoTransaction;
        };
        if expected_owner.is_some_and(|owner| !pending.owner.same_as(owner)) {
            return SegmentedResponseAdmission::NoTransaction;
        }

        let owner = pending.owner.clone();
        let phase = pending.phase;
        let polling_issue = pending
            .final_segment_issue
            .as_ref()
            .filter(|issue| issue.is_polling())
            .cloned();

        if phase != TransactionPhase::SegmentedResponse {
            // Sequence validity wins when both initial-response conditions fail.
            let wire_reason = if sequence_number != 0 {
                Some(AbortReason::INVALID_APDU_IN_THIS_STATE)
            } else if !segmented_response_accepted {
                Some(AbortReason::SEGMENTATION_NOT_SUPPORTED)
            } else {
                None
            };
            if let Some(wire_reason) = wire_reason {
                self.abort_invalid_apdu_in_current_state(source_mac, invoke_id, &owner);
                return SegmentedResponseAdmission::InitialResponseAborted { wire_reason };
            }
        }

        if let TransactionPhase::SegmentedRequest {
            sent_all_segments: false,
        } = phase
        {
            if let Some(issue) = polling_issue {
                return SegmentedResponseAdmission::FinalSegmentSendPolling { owner, issue };
            }
            self.abort_invalid_apdu_in_current_state(source_mac, invoke_id, &owner);
            return SegmentedResponseAdmission::InitialResponseAborted {
                wire_reason: AbortReason::INVALID_APDU_IN_THIS_STATE,
            };
        }

        SegmentedResponseAdmission::Active(owner)
    }
}