1 /*
2  *  Copyright (c) 2016-2019, The OpenThread Authors.
3  *  All rights reserved.
4  *
5  *  Redistribution and use in source and binary forms, with or without
6  *  modification, are permitted provided that the following conditions are met:
7  *  1. Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  *  2. Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *  3. Neither the name of the copyright holder nor the
13  *     names of its contributors may be used to endorse or promote products
14  *     derived from this software without specific prior written permission.
15  *
16  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  *  POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include "platform-simulation.h"
30 
31 #include <errno.h>
32 #include <sys/time.h>
33 
34 #include <openthread/cli.h>
35 #include <openthread/dataset.h>
36 #include <openthread/link.h>
37 #include <openthread/random_noncrypto.h>
38 #include <openthread/platform/alarm-micro.h>
39 #include <openthread/platform/alarm-milli.h>
40 #include <openthread/platform/diag.h>
41 #include <openthread/platform/radio.h>
42 #include <openthread/platform/time.h>
43 
44 #include "utils/code_utils.h"
45 #include "utils/link_metrics.h"
46 #include "utils/mac_frame.h"
47 #include "utils/soft_source_match_table.h"
48 
49 // The IPv4 group for receiving packets of radio simulation
50 #define OT_RADIO_GROUP "224.0.0.116"
51 
52 #define MS_PER_S 1000
53 #define US_PER_MS 1000
54 
55 enum
56 {
57     IEEE802154_ACK_LENGTH = 5,
58 
59     IEEE802154_FRAME_TYPE_ACK = 2 << 0,
60 
61     IEEE802154_FRAME_PENDING = 1 << 4,
62 };
63 
64 enum
65 {
66     SIM_RECEIVE_SENSITIVITY = -100, // dBm
67 
68     SIM_HIGH_RSSI_SAMPLE               = -30, // dBm
69     SIM_LOW_RSSI_SAMPLE                = -98, // dBm
70     SIM_HIGH_RSSI_PROB_INC_PER_CHANNEL = 5,
71 };
72 
73 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME
74 extern int      sSockFd;
75 extern uint16_t sPortBase;
76 extern uint16_t sPortOffset;
77 #else
78 static int      sTxFd       = -1;
79 static int      sRxFd       = -1;
80 static uint16_t sPortBase   = 9000;
81 static uint16_t sPortOffset = 0;
82 static uint16_t sPort       = 0;
83 #endif
84 
85 static int8_t   sEnergyScanResult  = OT_RADIO_RSSI_INVALID;
86 static bool     sEnergyScanning    = false;
87 static uint32_t sEnergyScanEndTime = 0;
88 
89 enum
90 {
91     SIM_RADIO_CHANNEL_MIN = OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MIN,
92     SIM_RADIO_CHANNEL_MAX = OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MAX,
93 };
94 
95 OT_TOOL_PACKED_BEGIN
96 struct RadioMessage
97 {
98     uint8_t mChannel;
99     uint8_t mPsdu[OT_RADIO_FRAME_MAX_SIZE];
100 } OT_TOOL_PACKED_END;
101 
102 static void radioTransmit(struct RadioMessage *aMessage, const struct otRadioFrame *aFrame);
103 static void radioSendMessage(otInstance *aInstance);
104 static void radioSendAck(void);
105 static void radioProcessFrame(otInstance *aInstance);
106 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
107 static uint8_t generateAckIeData(uint8_t *aLinkMetricsIeData, uint8_t aLinkMetricsIeDataLen);
108 #endif
109 
110 static otRadioState        sState = OT_RADIO_STATE_DISABLED;
111 static struct RadioMessage sReceiveMessage;
112 static struct RadioMessage sTransmitMessage;
113 static struct RadioMessage sAckMessage;
114 static otRadioFrame        sReceiveFrame;
115 static otRadioFrame        sTransmitFrame;
116 static otRadioFrame        sAckFrame;
117 
118 #if OPENTHREAD_CONFIG_MAC_HEADER_IE_SUPPORT
119 static otRadioIeInfo sTransmitIeInfo;
120 #endif
121 
122 static otExtAddress   sExtAddress;
123 static otShortAddress sShortAddress;
124 static otPanId        sPanid;
125 static bool           sPromiscuous = false;
126 static bool           sTxWait      = false;
127 static int8_t         sTxPower     = 0;
128 static int8_t         sCcaEdThresh = -74;
129 static int8_t         sLnaGain     = 0;
130 static uint16_t       sRegionCode  = 0;
131 
132 enum
133 {
134     kMinChannel = 11,
135     kMaxChannel = 26,
136 };
137 static int8_t  sChannelMaxTransmitPower[kMaxChannel - kMinChannel + 1];
138 static uint8_t sCurrentChannel = kMinChannel;
139 
140 static bool sSrcMatchEnabled = false;
141 
142 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
143 static uint8_t sAckIeData[OT_ACK_IE_MAX_SIZE];
144 static uint8_t sAckIeDataLength = 0;
145 #endif
146 
147 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
148 static uint32_t sCslSampleTime;
149 static uint32_t sCslPeriod;
150 #endif
151 
152 #if OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE
153 static bool sRadioCoexEnabled = true;
154 #endif
155 
156 otRadioCaps gRadioCaps =
157 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
158     OT_RADIO_CAPS_TRANSMIT_SEC;
159 #else
160     OT_RADIO_CAPS_NONE;
161 #endif
162 
163 static uint32_t         sMacFrameCounter;
164 static uint8_t          sKeyId;
165 static otMacKeyMaterial sPrevKey;
166 static otMacKeyMaterial sCurrKey;
167 static otMacKeyMaterial sNextKey;
168 static otRadioKeyType   sKeyType;
169 
170 static int8_t GetRssi(uint16_t aChannel);
171 
172 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
173 
174 static enum {
175     kFilterOff,
176     kFilterDenyList,
177     kFilterAllowList,
178 } sFilterMode = kFilterOff;
179 
180 static uint8_t sFilterNodeIdsBitVector[(MAX_NETWORK_SIZE + 7) / 8];
181 
FilterContainsId(uint16_t aNodeId)182 static bool FilterContainsId(uint16_t aNodeId)
183 {
184     uint16_t index = aNodeId - 1;
185 
186     return (sFilterNodeIdsBitVector[index / 8] & (0x80 >> (index % 8))) != 0;
187 }
188 
NodeIdFilterIsConnectable(uint16_t aNodeId)189 static bool NodeIdFilterIsConnectable(uint16_t aNodeId)
190 {
191     bool isConnectable = true;
192 
193     switch (sFilterMode)
194     {
195     case kFilterOff:
196         break;
197     case kFilterDenyList:
198         isConnectable = !FilterContainsId(aNodeId);
199         break;
200     case kFilterAllowList:
201         isConnectable = FilterContainsId(aNodeId);
202         break;
203     }
204 
205     return isConnectable;
206 }
207 
AddNodeIdToFilter(uint16_t aNodeId)208 static void AddNodeIdToFilter(uint16_t aNodeId)
209 {
210     uint16_t index = aNodeId - 1;
211 
212     sFilterNodeIdsBitVector[index / 8] |= 0x80 >> (index % 8);
213 }
214 
otCliOutputFormat(const char * aFmt,...)215 OT_TOOL_WEAK void otCliOutputFormat(const char *aFmt, ...) { OT_UNUSED_VARIABLE(aFmt); }
216 
ProcessNodeIdFilter(void * aContext,uint8_t aArgsLength,char * aArgs[])217 otError ProcessNodeIdFilter(void *aContext, uint8_t aArgsLength, char *aArgs[])
218 {
219     OT_UNUSED_VARIABLE(aContext);
220 
221     otError error = OT_ERROR_NONE;
222     bool    deny  = false;
223 
224     if (aArgsLength == 0)
225     {
226         switch (sFilterMode)
227         {
228         case kFilterOff:
229             otCliOutputFormat("off");
230             break;
231         case kFilterDenyList:
232             otCliOutputFormat("deny-list");
233             break;
234         case kFilterAllowList:
235             otCliOutputFormat("allow-list");
236             break;
237         }
238 
239         for (uint16_t nodeId = 0; nodeId <= (uint16_t)MAX_NETWORK_SIZE; nodeId++)
240         {
241             if (FilterContainsId(nodeId))
242             {
243                 otCliOutputFormat(" %d", nodeId);
244             }
245         }
246 
247         otCliOutputFormat("\r\n");
248     }
249     else if (!strcmp(aArgs[0], "clear"))
250     {
251         otEXPECT_ACTION(aArgsLength == 1, error = OT_ERROR_INVALID_ARGS);
252 
253         memset(sFilterNodeIdsBitVector, 0, sizeof(sFilterNodeIdsBitVector));
254         sFilterMode = kFilterOff;
255     }
256     else if ((deny = !strcmp(aArgs[0], "deny")) || !strcmp(aArgs[0], "allow"))
257     {
258         uint16_t nodeId;
259         char    *endptr;
260 
261         otEXPECT_ACTION(aArgsLength == 2, error = OT_ERROR_INVALID_ARGS);
262 
263         nodeId = (uint16_t)strtol(aArgs[1], &endptr, 0);
264 
265         otEXPECT_ACTION(*endptr == '\0', error = OT_ERROR_INVALID_ARGS);
266         otEXPECT_ACTION(1 <= nodeId && nodeId <= MAX_NETWORK_SIZE, error = OT_ERROR_INVALID_ARGS);
267 
268         otEXPECT_ACTION(sFilterMode != (deny ? kFilterAllowList : kFilterDenyList), error = OT_ERROR_INVALID_STATE);
269 
270         AddNodeIdToFilter(nodeId);
271         sFilterMode = deny ? kFilterDenyList : kFilterAllowList;
272     }
273     else
274     {
275         error = OT_ERROR_INVALID_COMMAND;
276     }
277 
278 exit:
279     return error;
280 }
281 #else
ProcessNodeIdFilter(void * aContext,uint8_t aArgsLength,char * aArgs[])282 otError ProcessNodeIdFilter(void *aContext, uint8_t aArgsLength, char *aArgs[])
283 {
284     OT_UNUSED_VARIABLE(aContext);
285     OT_UNUSED_VARIABLE(aArgsLength);
286     OT_UNUSED_VARIABLE(aArgs);
287 
288     return OT_ERROR_NOT_IMPLEMENTED;
289 }
290 #endif // OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
291 
IsTimeAfterOrEqual(uint32_t aTimeA,uint32_t aTimeB)292 static bool IsTimeAfterOrEqual(uint32_t aTimeA, uint32_t aTimeB) { return (aTimeA - aTimeB) < (1U << 31); }
293 
ReverseExtAddress(otExtAddress * aReversed,const otExtAddress * aOrigin)294 static void ReverseExtAddress(otExtAddress *aReversed, const otExtAddress *aOrigin)
295 {
296     for (size_t i = 0; i < sizeof(*aReversed); i++)
297     {
298         aReversed->m8[i] = aOrigin->m8[sizeof(*aOrigin) - 1 - i];
299     }
300 }
301 
hasFramePending(const otRadioFrame * aFrame)302 static bool hasFramePending(const otRadioFrame *aFrame)
303 {
304     bool         rval = false;
305     otMacAddress src;
306 
307     otEXPECT_ACTION(sSrcMatchEnabled, rval = true);
308     otEXPECT(otMacFrameGetSrcAddr(aFrame, &src) == OT_ERROR_NONE);
309 
310     switch (src.mType)
311     {
312     case OT_MAC_ADDRESS_TYPE_SHORT:
313         rval = utilsSoftSrcMatchShortFindEntry(src.mAddress.mShortAddress) >= 0;
314         break;
315     case OT_MAC_ADDRESS_TYPE_EXTENDED:
316     {
317         otExtAddress extAddr;
318 
319         ReverseExtAddress(&extAddr, &src.mAddress.mExtAddress);
320         rval = utilsSoftSrcMatchExtFindEntry(&extAddr) >= 0;
321         break;
322     }
323     default:
324         break;
325     }
326 
327 exit:
328     return rval;
329 }
330 
crc16_citt(uint16_t aFcs,uint8_t aByte)331 static uint16_t crc16_citt(uint16_t aFcs, uint8_t aByte)
332 {
333     // CRC-16/CCITT, CRC-16/CCITT-TRUE, CRC-CCITT
334     // width=16 poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 check=0x2189 name="KERMIT"
335     // http://reveng.sourceforge.net/crc-catalogue/16.htm#crc.cat.kermit
336     static const uint16_t sFcsTable[256] = {
337         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5,
338         0xe97e, 0xf8f7, 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 0x9cc9, 0x8d40, 0xbfdb, 0xae52,
339         0xdaed, 0xcb64, 0xf9ff, 0xe876, 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 0xad4a, 0xbcc3,
340         0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
341         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9,
342         0x2732, 0x36bb, 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 0x5285, 0x430c, 0x7197, 0x601e,
343         0x14a1, 0x0528, 0x37b3, 0x263a, 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 0x6306, 0x728f,
344         0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
345         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862,
346         0x9af9, 0x8b70, 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 0x0840, 0x19c9, 0x2b52, 0x3adb,
347         0x4e64, 0x5fed, 0x6d76, 0x7cff, 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 0x18c1, 0x0948,
348         0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
349         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226,
350         0xd0bd, 0xc134, 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 0xc60c, 0xd785, 0xe51e, 0xf497,
351         0x8028, 0x91a1, 0xa33a, 0xb2b3, 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 0xd68d, 0xc704,
352         0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
353         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb,
354         0x0e70, 0x1ff9, 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 0x7bc7, 0x6a4e, 0x58d5, 0x495c,
355         0x3de3, 0x2c6a, 0x1ef1, 0x0f78};
356     return (aFcs >> 8) ^ sFcsTable[(aFcs ^ aByte) & 0xff];
357 }
358 
otPlatRadioGetIeeeEui64(otInstance * aInstance,uint8_t * aIeeeEui64)359 void otPlatRadioGetIeeeEui64(otInstance *aInstance, uint8_t *aIeeeEui64)
360 {
361     OT_UNUSED_VARIABLE(aInstance);
362 
363     aIeeeEui64[0] = 0x18;
364     aIeeeEui64[1] = 0xb4;
365     aIeeeEui64[2] = 0x30;
366     aIeeeEui64[3] = 0x00;
367     aIeeeEui64[4] = (gNodeId >> 24) & 0xff;
368     aIeeeEui64[5] = (gNodeId >> 16) & 0xff;
369     aIeeeEui64[6] = (gNodeId >> 8) & 0xff;
370     aIeeeEui64[7] = gNodeId & 0xff;
371 }
372 
otPlatRadioSetPanId(otInstance * aInstance,otPanId aPanid)373 void otPlatRadioSetPanId(otInstance *aInstance, otPanId aPanid)
374 {
375     OT_UNUSED_VARIABLE(aInstance);
376 
377     assert(aInstance != NULL);
378 
379     sPanid = aPanid;
380     utilsSoftSrcMatchSetPanId(aPanid);
381 }
382 
otPlatRadioSetExtendedAddress(otInstance * aInstance,const otExtAddress * aExtAddress)383 void otPlatRadioSetExtendedAddress(otInstance *aInstance, const otExtAddress *aExtAddress)
384 {
385     OT_UNUSED_VARIABLE(aInstance);
386 
387     assert(aInstance != NULL);
388 
389     ReverseExtAddress(&sExtAddress, aExtAddress);
390 }
391 
otPlatRadioSetShortAddress(otInstance * aInstance,otShortAddress aShortAddress)392 void otPlatRadioSetShortAddress(otInstance *aInstance, otShortAddress aShortAddress)
393 {
394     OT_UNUSED_VARIABLE(aInstance);
395 
396     assert(aInstance != NULL);
397 
398     sShortAddress = aShortAddress;
399 }
400 
otPlatRadioSetPromiscuous(otInstance * aInstance,bool aEnable)401 void otPlatRadioSetPromiscuous(otInstance *aInstance, bool aEnable)
402 {
403     OT_UNUSED_VARIABLE(aInstance);
404 
405     assert(aInstance != NULL);
406 
407     sPromiscuous = aEnable;
408 }
409 
410 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
initFds(void)411 static void initFds(void)
412 {
413     int                fd;
414     int                one = 1;
415     struct sockaddr_in sockaddr;
416 
417     memset(&sockaddr, 0, sizeof(sockaddr));
418 
419     otEXPECT_ACTION((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1, perror("socket(sTxFd)"));
420 
421     sPort                    = (uint16_t)(sPortBase + sPortOffset + gNodeId);
422     sockaddr.sin_family      = AF_INET;
423     sockaddr.sin_port        = htons(sPort);
424     sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
425 
426     otEXPECT_ACTION(setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &sockaddr.sin_addr, sizeof(sockaddr.sin_addr)) != -1,
427                     perror("setsockopt(sTxFd, IP_MULTICAST_IF)"));
428 
429     otEXPECT_ACTION(setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(one)) != -1,
430                     perror("setsockopt(sRxFd, IP_MULTICAST_LOOP)"));
431 
432     otEXPECT_ACTION(bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) != -1, perror("bind(sTxFd)"));
433 
434     // Tx fd is successfully initialized.
435     sTxFd = fd;
436 
437     otEXPECT_ACTION((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1, perror("socket(sRxFd)"));
438 
439     otEXPECT_ACTION(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) != -1,
440                     perror("setsockopt(sRxFd, SO_REUSEADDR)"));
441     otEXPECT_ACTION(setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one)) != -1,
442                     perror("setsockopt(sRxFd, SO_REUSEPORT)"));
443 
444     {
445         struct ip_mreqn mreq;
446 
447         memset(&mreq, 0, sizeof(mreq));
448         inet_pton(AF_INET, OT_RADIO_GROUP, &mreq.imr_multiaddr);
449 
450         // Always use loopback device to send simulation packets.
451         mreq.imr_address.s_addr = inet_addr("127.0.0.1");
452 
453         otEXPECT_ACTION(setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &mreq.imr_address, sizeof(mreq.imr_address)) != -1,
454                         perror("setsockopt(sRxFd, IP_MULTICAST_IF)"));
455         otEXPECT_ACTION(setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) != -1,
456                         perror("setsockopt(sRxFd, IP_ADD_MEMBERSHIP)"));
457     }
458 
459     sockaddr.sin_family      = AF_INET;
460     sockaddr.sin_port        = htons((uint16_t)(sPortBase + sPortOffset));
461     sockaddr.sin_addr.s_addr = inet_addr(OT_RADIO_GROUP);
462 
463     otEXPECT_ACTION(bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) != -1, perror("bind(sRxFd)"));
464 
465     // Rx fd is successfully initialized.
466     sRxFd = fd;
467 
468 exit:
469     if (sRxFd == -1 || sTxFd == -1)
470     {
471         exit(EXIT_FAILURE);
472     }
473 }
474 #endif // OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
475 
platformRadioInit(void)476 void platformRadioInit(void)
477 {
478 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
479     parseFromEnvAsUint16("PORT_BASE", &sPortBase);
480 
481     parseFromEnvAsUint16("PORT_OFFSET", &sPortOffset);
482     sPortOffset *= (MAX_NETWORK_SIZE + 1);
483 
484     initFds();
485 #endif // OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
486 
487     sReceiveFrame.mPsdu  = sReceiveMessage.mPsdu;
488     sTransmitFrame.mPsdu = sTransmitMessage.mPsdu;
489     sAckFrame.mPsdu      = sAckMessage.mPsdu;
490 
491 #if OPENTHREAD_CONFIG_MAC_HEADER_IE_SUPPORT
492     sTransmitFrame.mInfo.mTxInfo.mIeInfo = &sTransmitIeInfo;
493 #else
494     sTransmitFrame.mInfo.mTxInfo.mIeInfo = NULL;
495 #endif
496 
497     for (size_t i = 0; i <= kMaxChannel - kMinChannel; i++)
498     {
499         sChannelMaxTransmitPower[i] = OT_RADIO_POWER_INVALID;
500     }
501 
502 #if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
503     otLinkMetricsInit(SIM_RECEIVE_SENSITIVITY);
504 #endif
505 }
506 
507 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
getCslPhase(void)508 static uint16_t getCslPhase(void)
509 {
510     uint32_t curTime       = otPlatAlarmMicroGetNow();
511     uint32_t cslPeriodInUs = sCslPeriod * OT_US_PER_TEN_SYMBOLS;
512     uint32_t diff = ((sCslSampleTime % cslPeriodInUs) - (curTime % cslPeriodInUs) + cslPeriodInUs) % cslPeriodInUs;
513 
514     return (uint16_t)(diff / OT_US_PER_TEN_SYMBOLS);
515 }
516 #endif
517 
otPlatRadioIsEnabled(otInstance * aInstance)518 bool otPlatRadioIsEnabled(otInstance *aInstance)
519 {
520     OT_UNUSED_VARIABLE(aInstance);
521 
522     return (sState != OT_RADIO_STATE_DISABLED) ? true : false;
523 }
524 
otPlatRadioEnable(otInstance * aInstance)525 otError otPlatRadioEnable(otInstance *aInstance)
526 {
527     if (!otPlatRadioIsEnabled(aInstance))
528     {
529         sState = OT_RADIO_STATE_SLEEP;
530     }
531 
532     return OT_ERROR_NONE;
533 }
534 
otPlatRadioDisable(otInstance * aInstance)535 otError otPlatRadioDisable(otInstance *aInstance)
536 {
537     otError error = OT_ERROR_NONE;
538 
539     otEXPECT(otPlatRadioIsEnabled(aInstance));
540     otEXPECT_ACTION(sState == OT_RADIO_STATE_SLEEP, error = OT_ERROR_INVALID_STATE);
541 
542     sState = OT_RADIO_STATE_DISABLED;
543 
544 exit:
545     return error;
546 }
547 
otPlatRadioSleep(otInstance * aInstance)548 otError otPlatRadioSleep(otInstance *aInstance)
549 {
550     OT_UNUSED_VARIABLE(aInstance);
551 
552     assert(aInstance != NULL);
553 
554     otError error = OT_ERROR_INVALID_STATE;
555 
556     if (sState == OT_RADIO_STATE_SLEEP || sState == OT_RADIO_STATE_RECEIVE)
557     {
558         error  = OT_ERROR_NONE;
559         sState = OT_RADIO_STATE_SLEEP;
560     }
561 
562     return error;
563 }
564 
otPlatRadioReceive(otInstance * aInstance,uint8_t aChannel)565 otError otPlatRadioReceive(otInstance *aInstance, uint8_t aChannel)
566 {
567     OT_UNUSED_VARIABLE(aInstance);
568 
569     assert(aInstance != NULL);
570 
571     otError error = OT_ERROR_INVALID_STATE;
572 
573     if (sState != OT_RADIO_STATE_DISABLED)
574     {
575         error                  = OT_ERROR_NONE;
576         sState                 = OT_RADIO_STATE_RECEIVE;
577         sTxWait                = false;
578         sReceiveFrame.mChannel = aChannel;
579         sCurrentChannel        = aChannel;
580     }
581 
582     return error;
583 }
584 
otPlatRadioTransmit(otInstance * aInstance,otRadioFrame * aFrame)585 otError otPlatRadioTransmit(otInstance *aInstance, otRadioFrame *aFrame)
586 {
587     OT_UNUSED_VARIABLE(aInstance);
588     OT_UNUSED_VARIABLE(aFrame);
589 
590     assert(aInstance != NULL);
591     assert(aFrame != NULL);
592 
593     otError error = OT_ERROR_INVALID_STATE;
594 
595     if (sState == OT_RADIO_STATE_RECEIVE)
596     {
597         error           = OT_ERROR_NONE;
598         sState          = OT_RADIO_STATE_TRANSMIT;
599         sCurrentChannel = aFrame->mChannel;
600     }
601 
602     return error;
603 }
604 
otPlatRadioGetTransmitBuffer(otInstance * aInstance)605 otRadioFrame *otPlatRadioGetTransmitBuffer(otInstance *aInstance)
606 {
607     OT_UNUSED_VARIABLE(aInstance);
608 
609     assert(aInstance != NULL);
610 
611     return &sTransmitFrame;
612 }
613 
otPlatRadioGetRssi(otInstance * aInstance)614 int8_t otPlatRadioGetRssi(otInstance *aInstance)
615 {
616     OT_UNUSED_VARIABLE(aInstance);
617     assert(aInstance != NULL);
618 
619     return GetRssi(sReceiveFrame.mChannel);
620 }
621 
GetRssi(uint16_t aChannel)622 static int8_t GetRssi(uint16_t aChannel)
623 {
624     int8_t   rssi = SIM_LOW_RSSI_SAMPLE;
625     uint32_t probabilityThreshold;
626 
627     otEXPECT((SIM_RADIO_CHANNEL_MIN <= aChannel) && aChannel <= (SIM_RADIO_CHANNEL_MAX));
628 
629     // To emulate a simple interference model, we return either a high or
630     // a low  RSSI value with a fixed probability per each channel. The
631     // probability is increased per channel by a constant.
632 
633     probabilityThreshold = (aChannel - SIM_RADIO_CHANNEL_MIN) * SIM_HIGH_RSSI_PROB_INC_PER_CHANNEL;
634 
635     if (otRandomNonCryptoGetUint16() < (probabilityThreshold * 0xffff / 100))
636     {
637         rssi = SIM_HIGH_RSSI_SAMPLE;
638     }
639 
640 exit:
641     return rssi;
642 }
643 
otPlatRadioGetCaps(otInstance * aInstance)644 otRadioCaps otPlatRadioGetCaps(otInstance *aInstance)
645 {
646     OT_UNUSED_VARIABLE(aInstance);
647 
648     assert(aInstance != NULL);
649 
650     return gRadioCaps;
651 }
652 
otPlatRadioGetPromiscuous(otInstance * aInstance)653 bool otPlatRadioGetPromiscuous(otInstance *aInstance)
654 {
655     OT_UNUSED_VARIABLE(aInstance);
656 
657     assert(aInstance != NULL);
658 
659     return sPromiscuous;
660 }
661 
radioReceive(otInstance * aInstance)662 static void radioReceive(otInstance *aInstance)
663 {
664     bool isTxDone = false;
665     bool isAck    = otMacFrameIsAck(&sReceiveFrame);
666 
667     otEXPECT(sReceiveFrame.mChannel == sReceiveMessage.mChannel);
668     otEXPECT(sState == OT_RADIO_STATE_RECEIVE || sState == OT_RADIO_STATE_TRANSMIT);
669 
670     // Unable to simulate SFD, so use the rx done timestamp instead.
671     sReceiveFrame.mInfo.mRxInfo.mTimestamp = otPlatTimeGet();
672 
673     if (sTxWait)
674     {
675         if (otMacFrameIsAckRequested(&sTransmitFrame))
676         {
677             isTxDone = isAck && otMacFrameGetSequence(&sReceiveFrame) == otMacFrameGetSequence(&sTransmitFrame);
678         }
679 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME
680         // Simulate tx done when receiving the echo frame.
681         else
682         {
683             isTxDone = !isAck && sTransmitFrame.mLength == sReceiveFrame.mLength &&
684                        memcmp(sTransmitFrame.mPsdu, sReceiveFrame.mPsdu, sTransmitFrame.mLength) == 0;
685         }
686 #endif
687     }
688 
689     if (isTxDone)
690     {
691         sState  = OT_RADIO_STATE_RECEIVE;
692         sTxWait = false;
693 
694 #if OPENTHREAD_CONFIG_DIAG_ENABLE
695 
696         if (otPlatDiagModeGet())
697         {
698             otPlatDiagRadioTransmitDone(aInstance, &sTransmitFrame, OT_ERROR_NONE);
699         }
700         else
701 #endif
702         {
703             otPlatRadioTxDone(aInstance, &sTransmitFrame, (isAck ? &sReceiveFrame : NULL), OT_ERROR_NONE);
704         }
705     }
706     else if (!isAck || sPromiscuous)
707     {
708         radioProcessFrame(aInstance);
709     }
710 
711 exit:
712     return;
713 }
714 
radioComputeCrc(struct RadioMessage * aMessage,uint16_t aLength)715 static void radioComputeCrc(struct RadioMessage *aMessage, uint16_t aLength)
716 {
717     uint16_t crc        = 0;
718     uint16_t crc_offset = aLength - sizeof(uint16_t);
719 
720     for (uint16_t i = 0; i < crc_offset; i++)
721     {
722         crc = crc16_citt(crc, aMessage->mPsdu[i]);
723     }
724 
725     aMessage->mPsdu[crc_offset]     = crc & 0xff;
726     aMessage->mPsdu[crc_offset + 1] = crc >> 8;
727 }
728 
radioProcessTransmitSecurity(otRadioFrame * aFrame)729 static otError radioProcessTransmitSecurity(otRadioFrame *aFrame)
730 {
731     otError error = OT_ERROR_NONE;
732 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
733     otMacKeyMaterial *key = NULL;
734     uint8_t           keyId;
735 
736     otEXPECT(otMacFrameIsSecurityEnabled(aFrame) && otMacFrameIsKeyIdMode1(aFrame) &&
737              !aFrame->mInfo.mTxInfo.mIsSecurityProcessed);
738 
739     if (otMacFrameIsAck(aFrame))
740     {
741         keyId = otMacFrameGetKeyId(aFrame);
742 
743         otEXPECT_ACTION(keyId != 0, error = OT_ERROR_FAILED);
744 
745         if (keyId == sKeyId)
746         {
747             key = &sCurrKey;
748         }
749         else if (keyId == sKeyId - 1)
750         {
751             key = &sPrevKey;
752         }
753         else if (keyId == sKeyId + 1)
754         {
755             key = &sNextKey;
756         }
757         else
758         {
759             error = OT_ERROR_SECURITY;
760             otEXPECT(false);
761         }
762     }
763     else
764     {
765         key   = &sCurrKey;
766         keyId = sKeyId;
767     }
768 
769     aFrame->mInfo.mTxInfo.mAesKey = key;
770 
771     if (!aFrame->mInfo.mTxInfo.mIsHeaderUpdated)
772     {
773         otMacFrameSetKeyId(aFrame, keyId);
774         otMacFrameSetFrameCounter(aFrame, sMacFrameCounter++);
775     }
776 #else
777     otEXPECT(!aFrame->mInfo.mTxInfo.mIsSecurityProcessed);
778 #endif // OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
779 
780     otMacFrameProcessTransmitAesCcm(aFrame, &sExtAddress);
781 
782 exit:
783     return error;
784 }
785 
radioSendMessage(otInstance * aInstance)786 void radioSendMessage(otInstance *aInstance)
787 {
788 #if OPENTHREAD_CONFIG_MAC_HEADER_IE_SUPPORT && OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
789     if (sTransmitFrame.mInfo.mTxInfo.mIeInfo->mTimeIeOffset != 0)
790     {
791         uint8_t *timeIe = sTransmitFrame.mPsdu + sTransmitFrame.mInfo.mTxInfo.mIeInfo->mTimeIeOffset;
792         uint64_t time = (uint64_t)((int64_t)otPlatTimeGet() + sTransmitFrame.mInfo.mTxInfo.mIeInfo->mNetworkTimeOffset);
793 
794         *timeIe = sTransmitFrame.mInfo.mTxInfo.mIeInfo->mTimeSyncSeq;
795 
796         *(++timeIe) = (uint8_t)(time & 0xff);
797         for (uint8_t i = 1; i < sizeof(uint64_t); i++)
798         {
799             time        = time >> 8;
800             *(++timeIe) = (uint8_t)(time & 0xff);
801         }
802     }
803 #endif // OPENTHREAD_CONFIG_MAC_HEADER_IE_SUPPORT && OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
804 
805 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
806     if (sCslPeriod > 0 && !sTransmitFrame.mInfo.mTxInfo.mIsHeaderUpdated)
807     {
808         otMacFrameSetCslIe(&sTransmitFrame, (uint16_t)sCslPeriod, getCslPhase());
809     }
810 #endif
811 
812     sTransmitMessage.mChannel = sTransmitFrame.mChannel;
813 
814     otEXPECT(radioProcessTransmitSecurity(&sTransmitFrame) == OT_ERROR_NONE);
815     otPlatRadioTxStarted(aInstance, &sTransmitFrame);
816     radioComputeCrc(&sTransmitMessage, sTransmitFrame.mLength);
817     radioTransmit(&sTransmitMessage, &sTransmitFrame);
818 
819 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
820     sTxWait = otMacFrameIsAckRequested(&sTransmitFrame);
821 
822     if (!sTxWait)
823     {
824         sState = OT_RADIO_STATE_RECEIVE;
825 
826 #if OPENTHREAD_CONFIG_DIAG_ENABLE
827 
828         if (otPlatDiagModeGet())
829         {
830             otPlatDiagRadioTransmitDone(aInstance, &sTransmitFrame, OT_ERROR_NONE);
831         }
832         else
833 #endif
834         {
835             otPlatRadioTxDone(aInstance, &sTransmitFrame, NULL, OT_ERROR_NONE);
836         }
837     }
838 #else
839     // Wait for echo radio in virtual time mode.
840     sTxWait = true;
841 #endif // OPENTHREAD_SIMULATION_VIRTUAL_TIME
842 exit:
843     return;
844 }
845 
platformRadioIsTransmitPending(void)846 bool platformRadioIsTransmitPending(void) { return sState == OT_RADIO_STATE_TRANSMIT && !sTxWait; }
847 
848 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME
platformRadioReceive(otInstance * aInstance,uint8_t * aBuf,uint16_t aBufLength)849 void platformRadioReceive(otInstance *aInstance, uint8_t *aBuf, uint16_t aBufLength)
850 {
851     assert(sizeof(sReceiveMessage) >= aBufLength);
852 
853     memcpy(&sReceiveMessage, aBuf, aBufLength);
854 
855     sReceiveFrame.mLength = (uint8_t)(aBufLength - 1);
856 
857     radioReceive(aInstance);
858 }
859 #else
platformRadioUpdateFdSet(fd_set * aReadFdSet,fd_set * aWriteFdSet,struct timeval * aTimeout,int * aMaxFd)860 void platformRadioUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, struct timeval *aTimeout, int *aMaxFd)
861 {
862     if (aReadFdSet != NULL && (sState != OT_RADIO_STATE_TRANSMIT || sTxWait))
863     {
864         FD_SET(sRxFd, aReadFdSet);
865 
866         if (aMaxFd != NULL && *aMaxFd < sRxFd)
867         {
868             *aMaxFd = sRxFd;
869         }
870     }
871 
872     if (aWriteFdSet != NULL && platformRadioIsTransmitPending())
873     {
874         FD_SET(sTxFd, aWriteFdSet);
875 
876         if (aMaxFd != NULL && *aMaxFd < sTxFd)
877         {
878             *aMaxFd = sTxFd;
879         }
880     }
881 
882     if (sEnergyScanning)
883     {
884         struct timeval tv  = {0, 0};
885         uint32_t       now = otPlatAlarmMilliGetNow();
886 
887         if (IsTimeAfterOrEqual(sEnergyScanEndTime, now))
888         {
889             uint32_t remaining = sEnergyScanEndTime - now;
890 
891             tv.tv_sec  = remaining / MS_PER_S;
892             tv.tv_usec = (remaining % MS_PER_S) * US_PER_MS;
893         }
894 
895         if (timercmp(&tv, aTimeout, <))
896         {
897             *aTimeout = tv;
898         }
899     }
900 }
901 
902 // no need to close in virtual time mode.
platformRadioDeinit(void)903 void platformRadioDeinit(void)
904 {
905     if (sRxFd != -1)
906     {
907         close(sRxFd);
908     }
909 
910     if (sTxFd != -1)
911     {
912         close(sTxFd);
913     }
914 }
915 #endif // OPENTHREAD_SIMULATION_VIRTUAL_TIME
916 
platformRadioProcess(otInstance * aInstance,const fd_set * aReadFdSet,const fd_set * aWriteFdSet)917 void platformRadioProcess(otInstance *aInstance, const fd_set *aReadFdSet, const fd_set *aWriteFdSet)
918 {
919     OT_UNUSED_VARIABLE(aReadFdSet);
920     OT_UNUSED_VARIABLE(aWriteFdSet);
921 
922 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
923     if (FD_ISSET(sRxFd, aReadFdSet))
924     {
925         struct sockaddr_in sockaddr;
926         socklen_t          len = sizeof(sockaddr);
927         ssize_t            rval;
928 
929         memset(&sockaddr, 0, sizeof(sockaddr));
930         rval =
931             recvfrom(sRxFd, (char *)&sReceiveMessage, sizeof(sReceiveMessage), 0, (struct sockaddr *)&sockaddr, &len);
932 
933         if (rval > 0)
934         {
935             uint16_t srcPort   = ntohs(sockaddr.sin_port);
936             uint16_t srcNodeId = srcPort - sPortOffset - sPortBase;
937 
938             if (NodeIdFilterIsConnectable(srcNodeId) && srcPort != sPort)
939             {
940                 sReceiveFrame.mLength = (uint16_t)(rval - 1);
941 
942                 radioReceive(aInstance);
943             }
944         }
945         else if (rval == 0)
946         {
947             // socket is closed, which should not happen
948             assert(false);
949         }
950         else if (errno != EINTR && errno != EAGAIN)
951         {
952             perror("recvfrom(sRxFd)");
953             exit(EXIT_FAILURE);
954         }
955     }
956 #endif // OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
957     if (platformRadioIsTransmitPending())
958     {
959         radioSendMessage(aInstance);
960     }
961 
962     if (sEnergyScanning && IsTimeAfterOrEqual(otPlatAlarmMilliGetNow(), sEnergyScanEndTime))
963     {
964         sEnergyScanning = false;
965         otPlatRadioEnergyScanDone(aInstance, sEnergyScanResult);
966     }
967 }
968 
radioTransmit(struct RadioMessage * aMessage,const struct otRadioFrame * aFrame)969 void radioTransmit(struct RadioMessage *aMessage, const struct otRadioFrame *aFrame)
970 {
971 #if OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
972     ssize_t            rval;
973     struct sockaddr_in sockaddr;
974 
975     memset(&sockaddr, 0, sizeof(sockaddr));
976     sockaddr.sin_family = AF_INET;
977     inet_pton(AF_INET, OT_RADIO_GROUP, &sockaddr.sin_addr);
978 
979     sockaddr.sin_port = htons((uint16_t)(sPortBase + sPortOffset));
980     rval =
981         sendto(sTxFd, (const char *)aMessage, 1 + aFrame->mLength, 0, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
982 
983     if (rval < 0)
984     {
985         perror("sendto(sTxFd)");
986         exit(EXIT_FAILURE);
987     }
988 #else  // OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
989     struct Event event;
990 
991     event.mDelay      = 1; // 1us for now
992     event.mEvent      = OT_SIM_EVENT_RADIO_RECEIVED;
993     event.mDataLength = 1 + aFrame->mLength; // include channel in first byte
994     memcpy(event.mData, aMessage, event.mDataLength);
995 
996     otSimSendEvent(&event);
997 #endif // OPENTHREAD_SIMULATION_VIRTUAL_TIME == 0
998 }
999 
radioSendAck(void)1000 void radioSendAck(void)
1001 {
1002     if (
1003 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
1004         // Determine if frame pending should be set
1005         ((otMacFrameIsVersion2015(&sReceiveFrame) && otMacFrameIsCommand(&sReceiveFrame)) ||
1006          otMacFrameIsData(&sReceiveFrame) || otMacFrameIsDataRequest(&sReceiveFrame))
1007 #else
1008         otMacFrameIsDataRequest(&sReceiveFrame)
1009 #endif
1010         && hasFramePending(&sReceiveFrame))
1011     {
1012         sReceiveFrame.mInfo.mRxInfo.mAckedWithFramePending = true;
1013     }
1014 
1015 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
1016     // Use enh-ack for 802.15.4-2015 frames
1017     if (otMacFrameIsVersion2015(&sReceiveFrame))
1018     {
1019         uint8_t  linkMetricsDataLen = 0;
1020         uint8_t *dataPtr            = NULL;
1021 
1022 #if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
1023         uint8_t      linkMetricsData[OT_ENH_PROBING_IE_DATA_MAX_SIZE];
1024         otMacAddress macAddress;
1025 
1026         otEXPECT(otMacFrameGetSrcAddr(&sReceiveFrame, &macAddress) == OT_ERROR_NONE);
1027 
1028         linkMetricsDataLen = otLinkMetricsEnhAckGenData(&macAddress, sReceiveFrame.mInfo.mRxInfo.mLqi,
1029                                                         sReceiveFrame.mInfo.mRxInfo.mRssi, linkMetricsData);
1030 
1031         if (linkMetricsDataLen > 0)
1032         {
1033             dataPtr = linkMetricsData;
1034         }
1035 #endif
1036 
1037         sAckIeDataLength = generateAckIeData(dataPtr, linkMetricsDataLen);
1038 
1039         otEXPECT(otMacFrameGenerateEnhAck(&sReceiveFrame, sReceiveFrame.mInfo.mRxInfo.mAckedWithFramePending,
1040                                           sAckIeData, sAckIeDataLength, &sAckFrame) == OT_ERROR_NONE);
1041 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
1042         if (sCslPeriod > 0)
1043         {
1044             otMacFrameSetCslIe(&sAckFrame, (uint16_t)sCslPeriod, getCslPhase());
1045         }
1046 #endif
1047         if (otMacFrameIsSecurityEnabled(&sAckFrame))
1048         {
1049             otEXPECT(radioProcessTransmitSecurity(&sAckFrame) == OT_ERROR_NONE);
1050         }
1051     }
1052     else
1053 #endif
1054     {
1055         otMacFrameGenerateImmAck(&sReceiveFrame, sReceiveFrame.mInfo.mRxInfo.mAckedWithFramePending, &sAckFrame);
1056     }
1057 
1058     sAckMessage.mChannel = sReceiveFrame.mChannel;
1059 
1060     radioComputeCrc(&sAckMessage, sAckFrame.mLength);
1061     radioTransmit(&sAckMessage, &sAckFrame);
1062 
1063 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
1064 exit:
1065 #endif
1066     return;
1067 }
1068 
radioProcessFrame(otInstance * aInstance)1069 void radioProcessFrame(otInstance *aInstance)
1070 {
1071     otError      error = OT_ERROR_NONE;
1072     otMacAddress macAddress;
1073     OT_UNUSED_VARIABLE(macAddress);
1074 
1075     sReceiveFrame.mInfo.mRxInfo.mRssi = -20;
1076     sReceiveFrame.mInfo.mRxInfo.mLqi  = OT_RADIO_LQI_NONE;
1077 
1078     sReceiveFrame.mInfo.mRxInfo.mAckedWithFramePending = false;
1079     sReceiveFrame.mInfo.mRxInfo.mAckedWithSecEnhAck    = false;
1080 
1081     otEXPECT(sPromiscuous == false);
1082 
1083     otEXPECT_ACTION(otMacFrameDoesAddrMatch(&sReceiveFrame, sPanid, sShortAddress, &sExtAddress),
1084                     error = OT_ERROR_ABORT);
1085 
1086 #if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
1087     otEXPECT_ACTION(otMacFrameGetSrcAddr(&sReceiveFrame, &macAddress) == OT_ERROR_NONE, error = OT_ERROR_PARSE);
1088 #endif
1089 
1090     // generate acknowledgment
1091     if (otMacFrameIsAckRequested(&sReceiveFrame))
1092     {
1093         radioSendAck();
1094 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
1095         if (otMacFrameIsSecurityEnabled(&sAckFrame))
1096         {
1097             sReceiveFrame.mInfo.mRxInfo.mAckedWithSecEnhAck = true;
1098             sReceiveFrame.mInfo.mRxInfo.mAckFrameCounter    = otMacFrameGetFrameCounter(&sAckFrame);
1099         }
1100 #endif // OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
1101     }
1102 
1103 exit:
1104 
1105     if (error != OT_ERROR_ABORT)
1106     {
1107 #if OPENTHREAD_CONFIG_DIAG_ENABLE
1108         if (otPlatDiagModeGet())
1109         {
1110             otPlatDiagRadioReceiveDone(aInstance, error == OT_ERROR_NONE ? &sReceiveFrame : NULL, error);
1111         }
1112         else
1113 #endif
1114         {
1115             otPlatRadioReceiveDone(aInstance, error == OT_ERROR_NONE ? &sReceiveFrame : NULL, error);
1116         }
1117     }
1118 }
1119 
otPlatRadioEnableSrcMatch(otInstance * aInstance,bool aEnable)1120 void otPlatRadioEnableSrcMatch(otInstance *aInstance, bool aEnable)
1121 {
1122     OT_UNUSED_VARIABLE(aInstance);
1123 
1124     assert(aInstance != NULL);
1125 
1126     sSrcMatchEnabled = aEnable;
1127 }
1128 
otPlatRadioEnergyScan(otInstance * aInstance,uint8_t aScanChannel,uint16_t aScanDuration)1129 otError otPlatRadioEnergyScan(otInstance *aInstance, uint8_t aScanChannel, uint16_t aScanDuration)
1130 {
1131     OT_UNUSED_VARIABLE(aInstance);
1132     OT_UNUSED_VARIABLE(aScanChannel);
1133 
1134     otError error = OT_ERROR_NONE;
1135 
1136     assert(aInstance != NULL);
1137     assert(aScanChannel >= SIM_RADIO_CHANNEL_MIN && aScanChannel <= SIM_RADIO_CHANNEL_MAX);
1138     assert(aScanDuration > 0);
1139 
1140     otEXPECT_ACTION((gRadioCaps & OT_RADIO_CAPS_ENERGY_SCAN), error = OT_ERROR_NOT_IMPLEMENTED);
1141     otEXPECT_ACTION(!sEnergyScanning, error = OT_ERROR_BUSY);
1142 
1143     sEnergyScanResult  = GetRssi(aScanChannel);
1144     sEnergyScanning    = true;
1145     sEnergyScanEndTime = otPlatAlarmMilliGetNow() + aScanDuration;
1146 
1147 exit:
1148     return error;
1149 }
1150 
otPlatRadioGetTransmitPower(otInstance * aInstance,int8_t * aPower)1151 otError otPlatRadioGetTransmitPower(otInstance *aInstance, int8_t *aPower)
1152 {
1153     OT_UNUSED_VARIABLE(aInstance);
1154 
1155     int8_t maxPower = sChannelMaxTransmitPower[sCurrentChannel - kMinChannel];
1156 
1157     assert(aInstance != NULL);
1158 
1159     *aPower = sTxPower < maxPower ? sTxPower : maxPower;
1160 
1161     return OT_ERROR_NONE;
1162 }
1163 
otPlatRadioSetTransmitPower(otInstance * aInstance,int8_t aPower)1164 otError otPlatRadioSetTransmitPower(otInstance *aInstance, int8_t aPower)
1165 {
1166     OT_UNUSED_VARIABLE(aInstance);
1167 
1168     assert(aInstance != NULL);
1169 
1170     sTxPower = aPower;
1171 
1172     return OT_ERROR_NONE;
1173 }
1174 
otPlatRadioGetCcaEnergyDetectThreshold(otInstance * aInstance,int8_t * aThreshold)1175 otError otPlatRadioGetCcaEnergyDetectThreshold(otInstance *aInstance, int8_t *aThreshold)
1176 {
1177     OT_UNUSED_VARIABLE(aInstance);
1178 
1179     assert(aInstance != NULL);
1180 
1181     *aThreshold = sCcaEdThresh;
1182 
1183     return OT_ERROR_NONE;
1184 }
1185 
otPlatRadioSetCcaEnergyDetectThreshold(otInstance * aInstance,int8_t aThreshold)1186 otError otPlatRadioSetCcaEnergyDetectThreshold(otInstance *aInstance, int8_t aThreshold)
1187 {
1188     OT_UNUSED_VARIABLE(aInstance);
1189 
1190     assert(aInstance != NULL);
1191 
1192     sCcaEdThresh = aThreshold;
1193 
1194     return OT_ERROR_NONE;
1195 }
1196 
otPlatRadioGetFemLnaGain(otInstance * aInstance,int8_t * aGain)1197 otError otPlatRadioGetFemLnaGain(otInstance *aInstance, int8_t *aGain)
1198 {
1199     OT_UNUSED_VARIABLE(aInstance);
1200 
1201     assert(aInstance != NULL && aGain != NULL);
1202 
1203     *aGain = sLnaGain;
1204 
1205     return OT_ERROR_NONE;
1206 }
1207 
otPlatRadioSetFemLnaGain(otInstance * aInstance,int8_t aGain)1208 otError otPlatRadioSetFemLnaGain(otInstance *aInstance, int8_t aGain)
1209 {
1210     OT_UNUSED_VARIABLE(aInstance);
1211 
1212     assert(aInstance != NULL);
1213 
1214     sLnaGain = aGain;
1215 
1216     return OT_ERROR_NONE;
1217 }
1218 
otPlatRadioGetReceiveSensitivity(otInstance * aInstance)1219 int8_t otPlatRadioGetReceiveSensitivity(otInstance *aInstance)
1220 {
1221     OT_UNUSED_VARIABLE(aInstance);
1222 
1223     assert(aInstance != NULL);
1224 
1225     return SIM_RECEIVE_SENSITIVITY;
1226 }
1227 
otPlatRadioGetState(otInstance * aInstance)1228 otRadioState otPlatRadioGetState(otInstance *aInstance)
1229 {
1230     OT_UNUSED_VARIABLE(aInstance);
1231 
1232     return sState;
1233 }
1234 
1235 #if OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE
otPlatRadioSetCoexEnabled(otInstance * aInstance,bool aEnabled)1236 otError otPlatRadioSetCoexEnabled(otInstance *aInstance, bool aEnabled)
1237 {
1238     OT_UNUSED_VARIABLE(aInstance);
1239 
1240     assert(aInstance != NULL);
1241 
1242     sRadioCoexEnabled = aEnabled;
1243     return OT_ERROR_NONE;
1244 }
1245 
otPlatRadioIsCoexEnabled(otInstance * aInstance)1246 bool otPlatRadioIsCoexEnabled(otInstance *aInstance)
1247 {
1248     OT_UNUSED_VARIABLE(aInstance);
1249 
1250     assert(aInstance != NULL);
1251 
1252     return sRadioCoexEnabled;
1253 }
1254 
otPlatRadioGetCoexMetrics(otInstance * aInstance,otRadioCoexMetrics * aCoexMetrics)1255 otError otPlatRadioGetCoexMetrics(otInstance *aInstance, otRadioCoexMetrics *aCoexMetrics)
1256 {
1257     OT_UNUSED_VARIABLE(aInstance);
1258 
1259     otError error = OT_ERROR_NONE;
1260 
1261     assert(aInstance != NULL);
1262     otEXPECT_ACTION(aCoexMetrics != NULL, error = OT_ERROR_INVALID_ARGS);
1263 
1264     memset(aCoexMetrics, 0, sizeof(otRadioCoexMetrics));
1265 
1266     aCoexMetrics->mStopped                            = false;
1267     aCoexMetrics->mNumGrantGlitch                     = 1;
1268     aCoexMetrics->mNumTxRequest                       = 2;
1269     aCoexMetrics->mNumTxGrantImmediate                = 3;
1270     aCoexMetrics->mNumTxGrantWait                     = 4;
1271     aCoexMetrics->mNumTxGrantWaitActivated            = 5;
1272     aCoexMetrics->mNumTxGrantWaitTimeout              = 6;
1273     aCoexMetrics->mNumTxGrantDeactivatedDuringRequest = 7;
1274     aCoexMetrics->mNumTxDelayedGrant                  = 8;
1275     aCoexMetrics->mAvgTxRequestToGrantTime            = 9;
1276     aCoexMetrics->mNumRxRequest                       = 10;
1277     aCoexMetrics->mNumRxGrantImmediate                = 11;
1278     aCoexMetrics->mNumRxGrantWait                     = 12;
1279     aCoexMetrics->mNumRxGrantWaitActivated            = 13;
1280     aCoexMetrics->mNumRxGrantWaitTimeout              = 14;
1281     aCoexMetrics->mNumRxGrantDeactivatedDuringRequest = 15;
1282     aCoexMetrics->mNumRxDelayedGrant                  = 16;
1283     aCoexMetrics->mAvgRxRequestToGrantTime            = 17;
1284     aCoexMetrics->mNumRxGrantNone                     = 18;
1285 
1286 exit:
1287     return error;
1288 }
1289 #endif
1290 
otPlatRadioGetNow(otInstance * aInstance)1291 uint64_t otPlatRadioGetNow(otInstance *aInstance)
1292 {
1293     OT_UNUSED_VARIABLE(aInstance);
1294 
1295     return otPlatTimeGet();
1296 }
1297 
1298 #if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
generateAckIeData(uint8_t * aLinkMetricsIeData,uint8_t aLinkMetricsIeDataLen)1299 static uint8_t generateAckIeData(uint8_t *aLinkMetricsIeData, uint8_t aLinkMetricsIeDataLen)
1300 {
1301     OT_UNUSED_VARIABLE(aLinkMetricsIeData);
1302     OT_UNUSED_VARIABLE(aLinkMetricsIeDataLen);
1303 
1304     uint8_t offset = 0;
1305 
1306 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
1307     if (sCslPeriod > 0)
1308     {
1309         offset += otMacFrameGenerateCslIeTemplate(sAckIeData);
1310     }
1311 #endif
1312 
1313 #if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
1314     if (aLinkMetricsIeData != NULL && aLinkMetricsIeDataLen > 0)
1315     {
1316         offset += otMacFrameGenerateEnhAckProbingIe(sAckIeData, aLinkMetricsIeData, aLinkMetricsIeDataLen);
1317     }
1318 #endif
1319 
1320     return offset;
1321 }
1322 #endif
1323 
1324 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
otPlatRadioEnableCsl(otInstance * aInstance,uint32_t aCslPeriod,otShortAddress aShortAddr,const otExtAddress * aExtAddr)1325 otError otPlatRadioEnableCsl(otInstance         *aInstance,
1326                              uint32_t            aCslPeriod,
1327                              otShortAddress      aShortAddr,
1328                              const otExtAddress *aExtAddr)
1329 {
1330     OT_UNUSED_VARIABLE(aInstance);
1331     OT_UNUSED_VARIABLE(aShortAddr);
1332     OT_UNUSED_VARIABLE(aExtAddr);
1333 
1334     sCslPeriod = aCslPeriod;
1335 
1336     return OT_ERROR_NONE;
1337 }
1338 
otPlatRadioResetCsl(otInstance * aInstance)1339 otError otPlatRadioResetCsl(otInstance *aInstance)
1340 {
1341     OT_UNUSED_VARIABLE(aInstance);
1342 
1343     sCslPeriod = 0;
1344 
1345     return OT_ERROR_NONE;
1346 }
1347 
otPlatRadioUpdateCslSampleTime(otInstance * aInstance,uint32_t aCslSampleTime)1348 void otPlatRadioUpdateCslSampleTime(otInstance *aInstance, uint32_t aCslSampleTime)
1349 {
1350     OT_UNUSED_VARIABLE(aInstance);
1351 
1352     sCslSampleTime = aCslSampleTime;
1353 }
1354 
otPlatRadioGetCslAccuracy(otInstance * aInstance)1355 uint8_t otPlatRadioGetCslAccuracy(otInstance *aInstance)
1356 {
1357     OT_UNUSED_VARIABLE(aInstance);
1358 
1359     return 0;
1360 }
1361 #endif // OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
1362 
otPlatRadioSetMacKey(otInstance * aInstance,uint8_t aKeyIdMode,uint8_t aKeyId,const otMacKeyMaterial * aPrevKey,const otMacKeyMaterial * aCurrKey,const otMacKeyMaterial * aNextKey,otRadioKeyType aKeyType)1363 void otPlatRadioSetMacKey(otInstance             *aInstance,
1364                           uint8_t                 aKeyIdMode,
1365                           uint8_t                 aKeyId,
1366                           const otMacKeyMaterial *aPrevKey,
1367                           const otMacKeyMaterial *aCurrKey,
1368                           const otMacKeyMaterial *aNextKey,
1369                           otRadioKeyType          aKeyType)
1370 {
1371     OT_UNUSED_VARIABLE(aInstance);
1372     OT_UNUSED_VARIABLE(aKeyIdMode);
1373 
1374     otEXPECT(aPrevKey != NULL && aCurrKey != NULL && aNextKey != NULL);
1375 
1376     sKeyId   = aKeyId;
1377     sKeyType = aKeyType;
1378     memcpy(&sPrevKey, aPrevKey, sizeof(otMacKeyMaterial));
1379     memcpy(&sCurrKey, aCurrKey, sizeof(otMacKeyMaterial));
1380     memcpy(&sNextKey, aNextKey, sizeof(otMacKeyMaterial));
1381 
1382 exit:
1383     return;
1384 }
1385 
otPlatRadioSetMacFrameCounter(otInstance * aInstance,uint32_t aMacFrameCounter)1386 void otPlatRadioSetMacFrameCounter(otInstance *aInstance, uint32_t aMacFrameCounter)
1387 {
1388     OT_UNUSED_VARIABLE(aInstance);
1389 
1390     sMacFrameCounter = aMacFrameCounter;
1391 }
1392 
otPlatRadioSetChannelMaxTransmitPower(otInstance * aInstance,uint8_t aChannel,int8_t aMaxPower)1393 otError otPlatRadioSetChannelMaxTransmitPower(otInstance *aInstance, uint8_t aChannel, int8_t aMaxPower)
1394 {
1395     OT_UNUSED_VARIABLE(aInstance);
1396 
1397     otError error = OT_ERROR_NONE;
1398 
1399     otEXPECT_ACTION(aChannel >= kMinChannel && aChannel <= kMaxChannel, error = OT_ERROR_INVALID_ARGS);
1400     sChannelMaxTransmitPower[aChannel - kMinChannel] = aMaxPower;
1401 
1402 exit:
1403     return error;
1404 }
1405 
1406 #if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
otPlatRadioConfigureEnhAckProbing(otInstance * aInstance,otLinkMetrics aLinkMetrics,const otShortAddress aShortAddress,const otExtAddress * aExtAddress)1407 otError otPlatRadioConfigureEnhAckProbing(otInstance          *aInstance,
1408                                           otLinkMetrics        aLinkMetrics,
1409                                           const otShortAddress aShortAddress,
1410                                           const otExtAddress  *aExtAddress)
1411 {
1412     OT_UNUSED_VARIABLE(aInstance);
1413 
1414     return otLinkMetricsConfigureEnhAckProbing(aShortAddress, aExtAddress, aLinkMetrics);
1415 }
1416 #endif
1417 
otPlatRadioSetRegion(otInstance * aInstance,uint16_t aRegionCode)1418 otError otPlatRadioSetRegion(otInstance *aInstance, uint16_t aRegionCode)
1419 {
1420     OT_UNUSED_VARIABLE(aInstance);
1421 
1422     sRegionCode = aRegionCode;
1423     return OT_ERROR_NONE;
1424 }
1425 
otPlatRadioGetRegion(otInstance * aInstance,uint16_t * aRegionCode)1426 otError otPlatRadioGetRegion(otInstance *aInstance, uint16_t *aRegionCode)
1427 {
1428     OT_UNUSED_VARIABLE(aInstance);
1429     otError error = OT_ERROR_NONE;
1430 
1431     otEXPECT_ACTION(aRegionCode != NULL, error = OT_ERROR_INVALID_ARGS);
1432 
1433     *aRegionCode = sRegionCode;
1434 exit:
1435     return error;
1436 }
1437 
parseFromEnvAsUint16(const char * aEnvName,uint16_t * aValue)1438 void parseFromEnvAsUint16(const char *aEnvName, uint16_t *aValue)
1439 {
1440     char *env = getenv(aEnvName);
1441 
1442     if (env)
1443     {
1444         char *endptr;
1445 
1446         *aValue = (uint16_t)strtol(env, &endptr, 0);
1447 
1448         if (*endptr != '\0')
1449         {
1450             fprintf(stderr, "Invalid %s: %s\n", aEnvName, env);
1451             exit(EXIT_FAILURE);
1452         }
1453     }
1454 }
1455