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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

pub mod areq;
pub mod sreq;
pub mod srsp;

use crate::error::Error;
use crate::subsystem::MTFramePayload;
use crate::types::CommandType;
use num_traits::FromPrimitive;

pub fn try_decode(cmd_type: &CommandType, id: u8, buffer: &[u8]) -> Result<MTFramePayload, Error> {
    use crate::types::MACCommandId::*;
    use MTFramePayload::*;

    let id = FromPrimitive::from_u8(id).ok_or(Error::InvalidCommandId(id))?;

    match cmd_type {
        CommandType::POLL => Err(Error::NotImplemented),
        CommandType::SREQ => match id {
            Init => sreq::Init::try_decode(buffer).map(|x| MAC_Init_SREQ(x)),
            DataReq => sreq::DataReq::try_decode(buffer).map(|x| MAC_DataReq_SREQ(x)),
            PurgeReq => sreq::PurgeReq::try_decode(buffer).map(|x| MAC_PurgeReq_SREQ(x)),
            AssociateReq => {
                sreq::AssociateReq::try_decode(buffer).map(|x| MAC_AssociateReq_SREQ(x))
            }
            AssociateRsp => {
                sreq::AssociateRsp::try_decode(buffer).map(|x| MAC_AssociateRsp_SREQ(x))
            }
            DisassociateReq => {
                sreq::DisassociateReq::try_decode(buffer).map(|x| MAC_DisassociateReq_SREQ(x))
            }
            GetReq => sreq::GetReq::try_decode(buffer).map(|x| MAC_GetReq_SREQ(x)),
            SetReq => sreq::SetReq::try_decode(buffer).map(|x| MAC_SetReq_SREQ(x)),
            SecurityGetReq => {
                sreq::SecurityGetReq::try_decode(buffer).map(|x| MAC_SecurityGetReq_SREQ(x))
            }
            SecuritySetReq => {
                sreq::SecuritySetReq::try_decode(buffer).map(|x| MAC_SecuritySetReq_SREQ(x))
            }
            UpdatePANIdReq => {
                sreq::UpdatePANIdReq::try_decode(buffer).map(|x| MAC_UpdatePANIdReq_SREQ(x))
            }
            AddDeviceReq => {
                sreq::AddDeviceReq::try_decode(buffer).map(|x| MAC_AddDeviceReq_SREQ(x))
            }
            DeleteDeviceReq => {
                sreq::DeleteDeviceReq::try_decode(buffer).map(|x| MAC_DeleteDeviceReq_SREQ(x))
            }
            DeleteAllDevicesReq => sreq::DeleteAllDevicesReq::try_decode(buffer)
                .map(|x| MAC_DeleteAllDevicesReq_SREQ(x)),
            DeleteKeyReq => {
                sreq::DeleteKeyReq::try_decode(buffer).map(|x| MAC_DeleteKeyReq_SREQ(x))
            }
            ReadKeyReq => sreq::ReadKeyReq::try_decode(buffer).map(|x| MAC_ReadKeyReq_SREQ(x)),
            WriteKeyReq => sreq::WriteKeyReq::try_decode(buffer).map(|x| MAC_WriteKeyReq_SREQ(x)),
            OrphanRsp => sreq::OrphanRsp::try_decode(buffer).map(|x| MAC_OrphanRsp_SREQ(x)),
            PollReq => sreq::PollReq::try_decode(buffer).map(|x| MAC_PollReq_SREQ(x)),
            ResetReq => sreq::ResetReq::try_decode(buffer).map(|x| MAC_ResetReq_SREQ(x)),
            ScanReq => sreq::ScanReq::try_decode(buffer).map(|x| MAC_ScanReq_SREQ(x)),
            StartReq => sreq::StartReq::try_decode(buffer).map(|x| MAC_StartReq_SREQ(x)),
            SyncReq => sreq::SyncReq::try_decode(buffer).map(|x| MAC_SyncReq_SREQ(x)),
            SetRxGainReq => {
                sreq::SetRxGainReq::try_decode(buffer).map(|x| MAC_SetRxGainReq_SREQ(x))
            }
            WSAsyncReq => sreq::WSAsyncReq::try_decode(buffer).map(|x| MAC_WSAsyncReq_SREQ(x)),
            FHEnableReq => sreq::FHEnableReq::try_decode(buffer).map(|x| MAC_FHEnableReq_SREQ(x)),
            FHStartReq => sreq::FHStartReq::try_decode(buffer).map(|x| MAC_FHStartReq_SREQ(x)),
            FHGetReq => sreq::FHGetReq::try_decode(buffer).map(|x| MAC_FHGetReq_SREQ(x)),
            FHSetReq => sreq::FHSetReq::try_decode(buffer).map(|x| MAC_FHSetReq_SREQ(x)),
            _ => Err(Error::NotImplemented),
        },
        CommandType::AREQ => match id {
            DataCnf => areq::DataCnf::try_decode(buffer).map(|x| MAC_DataCnf_AREQ(x)),
            DataInd => areq::DataInd::try_decode(buffer).map(|x| MAC_DataInd_AREQ(x)),
            PurgeCnf => areq::PurgeCnf::try_decode(buffer).map(|x| MAC_PurgeCnf_AREQ(x)),
            WSAsyncInd => areq::WSAsyncInd::try_decode(buffer).map(|x| MAC_WSAsyncInd_AREQ(x)),
            SyncLossInd => areq::SyncLossInd::try_decode(buffer).map(|x| MAC_SyncLossInd_AREQ(x)),
            AssociateInd => {
                areq::AssociateInd::try_decode(buffer).map(|x| MAC_AssociateInd_AREQ(x))
            }
            AssociateCnf => {
                areq::AssociateCnf::try_decode(buffer).map(|x| MAC_AssociateCnf_AREQ(x))
            }
            BeaconNotifyInd => {
                areq::BeaconNotifyInd::try_decode(buffer).map(|x| MAC_BeaconNotifyInd_AREQ(x))
            }
            DisassociateInd => {
                areq::DisassociateInd::try_decode(buffer).map(|x| MAC_DisassociateInd_AREQ(x))
            }
            DisassociateCnf => {
                areq::DisassociateCnf::try_decode(buffer).map(|x| MAC_DisassociateCnf_AREQ(x))
            }
            OrphanInd => areq::OrphanInd::try_decode(buffer).map(|x| MAC_OrphanInd_AREQ(x)),
            PollCnf => areq::PollCnf::try_decode(buffer).map(|x| MAC_PollCnf_AREQ(x)),
            PollInd => areq::PollInd::try_decode(buffer).map(|x| MAC_PollInd_AREQ(x)),
            ScanCnf => areq::ScanCnf::try_decode(buffer).map(|x| MAC_ScanCnf_AREQ(x)),
            CommStatusInd => {
                areq::CommStatusInd::try_decode(buffer).map(|x| MAC_CommStatusInd_AREQ(x))
            }
            StartCnf => areq::StartCnf::try_decode(buffer).map(|x| MAC_StartCnf_AREQ(x)),
            WSAsyncCnf => areq::WSAsyncCnf::try_decode(buffer).map(|x| MAC_WSAsyncCnf_AREQ(x)),
            _ => Err(Error::NotImplemented),
        },
        CommandType::SRSP => match id {
            Init => srsp::Init::try_decode(buffer).map(|x| MAC_Init_SRSP(x)),
            DataReq => srsp::DataReq::try_decode(buffer).map(|x| MAC_DataReq_SRSP(x)),
            PurgeReq => srsp::PurgeReq::try_decode(buffer).map(|x| MAC_PurgeReq_SRSP(x)),
            AssociateReq => {
                srsp::AssociateReq::try_decode(buffer).map(|x| MAC_AssociateReq_SRSP(x))
            }
            AssociateRsp => {
                srsp::AssociateRsp::try_decode(buffer).map(|x| MAC_AssociateRsp_SRSP(x))
            }
            DisassociateReq => {
                srsp::DisassociateReq::try_decode(buffer).map(|x| MAC_DisassociateReq_SRSP(x))
            }
            GetReq => srsp::GetReq::try_decode(buffer).map(|x| MAC_GetReq_SRSP(x)),
            SetReq => srsp::SetReq::try_decode(buffer).map(|x| MAC_SetReq_SRSP(x)),
            SecurityGetReq => {
                srsp::SecurityGetReq::try_decode(buffer).map(|x| MAC_SecurityGetReq_SRSP(x))
            }
            SecuritySetReq => {
                srsp::SecuritySetReq::try_decode(buffer).map(|x| MAC_SecuritySetReq_SRSP(x))
            }
            UpdatePANIdReq => {
                srsp::UpdatePANIdReq::try_decode(buffer).map(|x| MAC_UpdatePANIdReq_SRSP(x))
            }
            AddDeviceReq => {
                srsp::AddDeviceReq::try_decode(buffer).map(|x| MAC_AddDeviceReq_SRSP(x))
            }
            DeleteDeviceReq => {
                srsp::DeleteDeviceReq::try_decode(buffer).map(|x| MAC_DeleteDeviceReq_SRSP(x))
            }
            DeleteAllDevicesReq => srsp::DeleteAllDevicesReq::try_decode(buffer)
                .map(|x| MAC_DeleteAllDevicesReq_SRSP(x)),
            DeleteKeyReq => {
                srsp::DeleteKeyReq::try_decode(buffer).map(|x| MAC_DeleteKeyReq_SRSP(x))
            }
            ReadKeyReq => srsp::ReadKeyReq::try_decode(buffer).map(|x| MAC_ReadKeyReq_SRSP(x)),
            WriteKeyReq => srsp::WriteKeyReq::try_decode(buffer).map(|x| MAC_WriteKeyReq_SRSP(x)),
            OrphanRsp => srsp::OrphanRsp::try_decode(buffer).map(|x| MAC_OrphanRsp_SRSP(x)),
            PollReq => srsp::PollReq::try_decode(buffer).map(|x| MAC_PollReq_SRSP(x)),
            ResetReq => srsp::ResetReq::try_decode(buffer).map(|x| MAC_ResetReq_SRSP(x)),
            ScanReq => srsp::ScanReq::try_decode(buffer).map(|x| MAC_ScanReq_SRSP(x)),
            StartReq => srsp::StartReq::try_decode(buffer).map(|x| MAC_StartReq_SRSP(x)),
            SyncReq => srsp::SyncReq::try_decode(buffer).map(|x| MAC_SyncReq_SRSP(x)),
            SetRxGainReq => {
                srsp::SetRxGainReq::try_decode(buffer).map(|x| MAC_SetRxGainReq_SRSP(x))
            }
            WSAsyncReq => srsp::WSAsyncReq::try_decode(buffer).map(|x| MAC_WSAsyncReq_SRSP(x)),
            FHEnableReq => srsp::FHEnableReq::try_decode(buffer).map(|x| MAC_FHEnableReq_SRSP(x)),
            FHStartReq => srsp::FHStartReq::try_decode(buffer).map(|x| MAC_FHStartReq_SRSP(x)),
            FHGetReq => srsp::FHGetReq::try_decode(buffer).map(|x| MAC_FHGetReq_SRSP(x)),
            FHSetReq => srsp::FHSetReq::try_decode(buffer).map(|x| MAC_FHSetReq_SRSP(x)),
            _ => Err(Error::NotImplemented),
        },
    }
}