1 /*
2  *    Copyright (c) 2016-2017, 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" AND
17  *    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18  *    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19  *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
20  *    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21  *    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22  *    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23  *    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  *    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25  *    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 /**
29  * @file
30  *   This file implements full thread device specified Spinel interface to the OpenThread stack.
31  */
32 
33 #include "ncp_base.hpp"
34 #include <openthread/config.h>
35 
36 #if OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE
37 #include <openthread/backbone_router_ftd.h>
38 #endif
39 #if OPENTHREAD_CONFIG_CHANNEL_MANAGER_ENABLE
40 #include <openthread/channel_manager.h>
41 #endif
42 #include <openthread/child_supervision.h>
43 #include <openthread/dataset.h>
44 #include <openthread/dataset_ftd.h>
45 #include <openthread/diag.h>
46 #include <openthread/icmp6.h>
47 #include <openthread/ncp.h>
48 #include <openthread/thread_ftd.h>
49 #include <openthread/platform/misc.h>
50 
51 #include "common/code_utils.hpp"
52 #include "common/debug.hpp"
53 #include "common/instance.hpp"
54 #if OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
55 #include "meshcop/commissioner.hpp"
56 #endif
57 
58 #if OPENTHREAD_FTD
59 namespace ot {
60 namespace Ncp {
61 
EncodeChildInfo(const otChildInfo & aChildInfo)62 otError NcpBase::EncodeChildInfo(const otChildInfo &aChildInfo)
63 {
64     otError error = OT_ERROR_NONE;
65     uint8_t modeFlags;
66 
67     modeFlags =
68         LinkFlagsToFlagByte(aChildInfo.mRxOnWhenIdle, aChildInfo.mFullThreadDevice, aChildInfo.mFullNetworkData);
69 
70     SuccessOrExit(error = mEncoder.WriteEui64(aChildInfo.mExtAddress));
71     SuccessOrExit(error = mEncoder.WriteUint16(aChildInfo.mRloc16));
72     SuccessOrExit(error = mEncoder.WriteUint32(aChildInfo.mTimeout));
73     SuccessOrExit(error = mEncoder.WriteUint32(aChildInfo.mAge));
74     SuccessOrExit(error = mEncoder.WriteUint8(aChildInfo.mNetworkDataVersion));
75     SuccessOrExit(error = mEncoder.WriteUint8(aChildInfo.mLinkQualityIn));
76     SuccessOrExit(error = mEncoder.WriteInt8(aChildInfo.mAverageRssi));
77     SuccessOrExit(error = mEncoder.WriteUint8(modeFlags));
78     SuccessOrExit(error = mEncoder.WriteInt8(aChildInfo.mLastRssi));
79 
80 exit:
81     return error;
82 }
83 
84 // ----------------------------------------------------------------------------
85 // MARK: Property/Status Changed
86 // ----------------------------------------------------------------------------
87 
88 #if OPENTHREAD_CONFIG_MLE_PARENT_RESPONSE_CALLBACK_API_ENABLE
HandleParentResponseInfo(otThreadParentResponseInfo * aInfo,void * aContext)89 void NcpBase::HandleParentResponseInfo(otThreadParentResponseInfo *aInfo, void *aContext)
90 {
91     VerifyOrExit(aInfo && aContext);
92 
93     static_cast<NcpBase *>(aContext)->HandleParentResponseInfo(*aInfo);
94 
95 exit:
96     return;
97 }
98 
HandleParentResponseInfo(const otThreadParentResponseInfo & aInfo)99 void NcpBase::HandleParentResponseInfo(const otThreadParentResponseInfo &aInfo)
100 {
101     VerifyOrExit(!mChangedPropsSet.IsPropertyFiltered(SPINEL_PROP_PARENT_RESPONSE_INFO));
102 
103     SuccessOrExit(mEncoder.BeginFrame(SPINEL_HEADER_FLAG | SPINEL_HEADER_IID_0, SPINEL_CMD_PROP_VALUE_IS,
104                                       SPINEL_PROP_PARENT_RESPONSE_INFO));
105 
106     SuccessOrExit(mEncoder.WriteEui64(aInfo.mExtAddr));
107     SuccessOrExit(mEncoder.WriteUint16(aInfo.mRloc16));
108     SuccessOrExit(mEncoder.WriteInt8(aInfo.mRssi));
109     SuccessOrExit(mEncoder.WriteInt8(aInfo.mPriority));
110     SuccessOrExit(mEncoder.WriteUint8(aInfo.mLinkQuality3));
111     SuccessOrExit(mEncoder.WriteUint8(aInfo.mLinkQuality2));
112     SuccessOrExit(mEncoder.WriteUint8(aInfo.mLinkQuality1));
113     SuccessOrExit(mEncoder.WriteBool(aInfo.mIsAttached));
114 
115     SuccessOrExit(mEncoder.EndFrame());
116 
117 exit:
118     return;
119 }
120 #endif
121 
HandleNeighborTableChanged(otNeighborTableEvent aEvent,const otNeighborTableEntryInfo * aEntry)122 void NcpBase::HandleNeighborTableChanged(otNeighborTableEvent aEvent, const otNeighborTableEntryInfo *aEntry)
123 {
124     GetNcpInstance()->HandleNeighborTableChanged(aEvent, *aEntry);
125 }
126 
HandleNeighborTableChanged(otNeighborTableEvent aEvent,const otNeighborTableEntryInfo & aEntry)127 void NcpBase::HandleNeighborTableChanged(otNeighborTableEvent aEvent, const otNeighborTableEntryInfo &aEntry)
128 {
129     otError           error   = OT_ERROR_NONE;
130     unsigned int      command = SPINEL_CMD_PROP_VALUE_REMOVED;
131     spinel_prop_key_t property;
132 
133     switch (aEvent)
134     {
135     case OT_NEIGHBOR_TABLE_EVENT_CHILD_ADDED:
136         command = SPINEL_CMD_PROP_VALUE_INSERTED;
137 
138         OT_FALL_THROUGH;
139 
140     case OT_NEIGHBOR_TABLE_EVENT_CHILD_REMOVED:
141         property = SPINEL_PROP_THREAD_CHILD_TABLE;
142         VerifyOrExit(!aEntry.mInfo.mChild.mIsStateRestoring);
143         break;
144 
145     case OT_NEIGHBOR_TABLE_EVENT_ROUTER_ADDED:
146         command = SPINEL_CMD_PROP_VALUE_INSERTED;
147 
148         OT_FALL_THROUGH;
149 
150     case OT_NEIGHBOR_TABLE_EVENT_ROUTER_REMOVED:
151         property = SPINEL_PROP_THREAD_NEIGHBOR_TABLE;
152         break;
153 
154     default:
155         ExitNow();
156     }
157 
158     VerifyOrExit(!mChangedPropsSet.IsPropertyFiltered(property));
159 
160     SuccessOrExit(error = mEncoder.BeginFrame(SPINEL_HEADER_FLAG | SPINEL_HEADER_IID_0, command, property));
161 
162     if (property == SPINEL_PROP_THREAD_CHILD_TABLE)
163     {
164         SuccessOrExit(error = EncodeChildInfo(aEntry.mInfo.mChild));
165     }
166     else
167     {
168         SuccessOrExit(error = EncodeNeighborInfo(aEntry.mInfo.mRouter));
169     }
170 
171     SuccessOrExit(error = mEncoder.EndFrame());
172 
173 exit:
174 
175     // If the frame can not be added (out of NCP buffer space), we remember
176     // to send an async `LAST_STATUS(NOMEM)` when buffer space becomes
177     // available. Also `mShouldEmitChildTableUpdate` flag is set to `true` so
178     // that the entire child table is later emitted as `VALUE_IS` spinel frame
179     // update from `ProcessThreadChangedFlags()`.
180 
181     if (error != OT_ERROR_NONE)
182     {
183         if (property == SPINEL_PROP_THREAD_CHILD_TABLE)
184         {
185             mShouldEmitChildTableUpdate = true;
186         }
187 
188         mChangedPropsSet.AddLastStatus(SPINEL_STATUS_NOMEM);
189         mUpdateChangedPropsTask.Post();
190     }
191 }
192 
193 // ----------------------------------------------------------------------------
194 // MARK: Individual Property Handlers
195 // ----------------------------------------------------------------------------
196 
HandlePropertyGet(void)197 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_LOCAL_LEADER_WEIGHT>(void)
198 {
199     return mEncoder.WriteUint8(otThreadGetLocalLeaderWeight(mInstance));
200 }
201 
HandlePropertyGet(void)202 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_LEADER_WEIGHT>(void)
203 {
204     return mEncoder.WriteUint8(otThreadGetLeaderWeight(mInstance));
205 }
206 
HandlePropertyGet(void)207 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_CHILD_TABLE>(void)
208 {
209     otError     error = OT_ERROR_NONE;
210     otChildInfo childInfo;
211     uint16_t    maxChildren;
212 
213     maxChildren = otThreadGetMaxAllowedChildren(mInstance);
214 
215     for (uint16_t index = 0; index < maxChildren; index++)
216     {
217         if ((otThreadGetChildInfoByIndex(mInstance, index, &childInfo) != OT_ERROR_NONE) || childInfo.mIsStateRestoring)
218         {
219             continue;
220         }
221 
222         SuccessOrExit(error = mEncoder.OpenStruct());
223         SuccessOrExit(error = EncodeChildInfo(childInfo));
224         SuccessOrExit(error = mEncoder.CloseStruct());
225     }
226 
227 exit:
228     return error;
229 }
230 
HandlePropertyGet(void)231 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_ROUTER_TABLE>(void)
232 {
233     otError      error = OT_ERROR_NONE;
234     otRouterInfo routerInfo;
235     uint8_t      maxRouterId;
236 
237     maxRouterId = otThreadGetMaxRouterId(mInstance);
238 
239     for (uint8_t routerId = 0; routerId <= maxRouterId; routerId++)
240     {
241         if ((otThreadGetRouterInfo(mInstance, routerId, &routerInfo) != OT_ERROR_NONE) || !routerInfo.mAllocated)
242         {
243             continue;
244         }
245 
246         SuccessOrExit(error = mEncoder.OpenStruct());
247 
248         SuccessOrExit(error = mEncoder.WriteEui64(routerInfo.mExtAddress));
249         SuccessOrExit(error = mEncoder.WriteUint16(routerInfo.mRloc16));
250         SuccessOrExit(error = mEncoder.WriteUint8(routerInfo.mRouterId));
251         SuccessOrExit(error = mEncoder.WriteUint8(routerInfo.mNextHop));
252         SuccessOrExit(error = mEncoder.WriteUint8(routerInfo.mPathCost));
253         SuccessOrExit(error = mEncoder.WriteUint8(routerInfo.mLinkQualityIn));
254         SuccessOrExit(error = mEncoder.WriteUint8(routerInfo.mLinkQualityOut));
255         SuccessOrExit(error = mEncoder.WriteUint8(routerInfo.mAge));
256         SuccessOrExit(error = mEncoder.WriteBool(routerInfo.mLinkEstablished));
257 
258         SuccessOrExit(error = mEncoder.CloseStruct());
259     }
260 
261 exit:
262     return error;
263 }
264 
HandlePropertyGet(void)265 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_CHILD_TABLE_ADDRESSES>(void)
266 {
267     otError                   error = OT_ERROR_NONE;
268     otChildInfo               childInfo;
269     uint16_t                  maxChildren;
270     otIp6Address              ip6Address;
271     otChildIp6AddressIterator iterator = OT_CHILD_IP6_ADDRESS_ITERATOR_INIT;
272 
273     maxChildren = otThreadGetMaxAllowedChildren(mInstance);
274 
275     for (uint16_t childIndex = 0; childIndex < maxChildren; childIndex++)
276     {
277         if ((otThreadGetChildInfoByIndex(mInstance, childIndex, &childInfo) != OT_ERROR_NONE) ||
278             childInfo.mIsStateRestoring)
279         {
280             continue;
281         }
282 
283         SuccessOrExit(error = mEncoder.OpenStruct());
284 
285         SuccessOrExit(error = mEncoder.WriteEui64(childInfo.mExtAddress));
286         SuccessOrExit(error = mEncoder.WriteUint16(childInfo.mRloc16));
287 
288         iterator = OT_CHILD_IP6_ADDRESS_ITERATOR_INIT;
289 
290         while (otThreadGetChildNextIp6Address(mInstance, childIndex, &iterator, &ip6Address) == OT_ERROR_NONE)
291         {
292             SuccessOrExit(error = mEncoder.WriteIp6Address(ip6Address));
293         }
294 
295         SuccessOrExit(error = mEncoder.CloseStruct());
296     }
297 
298 exit:
299     return error;
300 }
301 
HandlePropertyGet(void)302 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_ROUTER_ROLE_ENABLED>(void)
303 {
304     return mEncoder.WriteBool(otThreadIsRouterEligible(mInstance));
305 }
306 
HandlePropertySet(void)307 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_ROUTER_ROLE_ENABLED>(void)
308 {
309     bool    eligible;
310     otError error = OT_ERROR_NONE;
311 
312     SuccessOrExit(error = mDecoder.ReadBool(eligible));
313 
314     error = otThreadSetRouterEligible(mInstance, eligible);
315 
316 exit:
317     return error;
318 }
319 
HandlePropertyGet(void)320 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_MAC_MAX_RETRY_NUMBER_INDIRECT>(void)
321 {
322     return mEncoder.WriteUint8(otLinkGetMaxFrameRetriesIndirect(mInstance));
323 }
324 
HandlePropertySet(void)325 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MAC_MAX_RETRY_NUMBER_INDIRECT>(void)
326 {
327     uint8_t maxFrameRetriesIndirect;
328     otError error = OT_ERROR_NONE;
329 
330     SuccessOrExit(error = mDecoder.ReadUint8(maxFrameRetriesIndirect));
331     otLinkSetMaxFrameRetriesIndirect(mInstance, maxFrameRetriesIndirect);
332 
333 exit:
334     return error;
335 }
336 
337 #if (OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2)
HandlePropertyGet(void)338 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_DOMAIN_NAME>(void)
339 {
340     return mEncoder.WriteUtf8(otThreadGetDomainName(mInstance));
341 }
342 
HandlePropertySet(void)343 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_DOMAIN_NAME>(void)
344 {
345     otError     error = OT_ERROR_NONE;
346     const char *domainName;
347 
348     SuccessOrExit(error = mDecoder.ReadUtf8(domainName));
349 
350     error = otThreadSetDomainName(mInstance, domainName);
351 
352 exit:
353     return error;
354 }
355 #endif
356 
357 #if OPENTHREAD_CONFIG_DUA_ENABLE
HandlePropertyGet(void)358 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_DUA_ID>(void)
359 {
360     const otIp6InterfaceIdentifier *iid   = otThreadGetFixedDuaInterfaceIdentifier(mInstance);
361     otError                         error = OT_ERROR_NONE;
362 
363     if (iid == nullptr)
364     {
365         // send empty response
366     }
367     else
368     {
369         for (uint8_t i : iid->mFields.m8)
370         {
371             SuccessOrExit(error = mEncoder.WriteUint8(i));
372         }
373     }
374 
375 exit:
376     return error;
377 }
378 
HandlePropertySet(void)379 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_DUA_ID>(void)
380 {
381     otError error = OT_ERROR_NONE;
382 
383     if (mDecoder.GetRemainingLength() == 0)
384     {
385         SuccessOrExit(error = otThreadSetFixedDuaInterfaceIdentifier(mInstance, nullptr));
386     }
387     else
388     {
389         otIp6InterfaceIdentifier iid;
390 
391         for (uint8_t &i : iid.mFields.m8)
392         {
393             SuccessOrExit(error = mDecoder.ReadUint8(i));
394         }
395 
396         SuccessOrExit(error = otThreadSetFixedDuaInterfaceIdentifier(mInstance, &iid));
397     }
398 
399 exit:
400     return error;
401 }
402 #endif // OPENTHREAD_CONFIG_DUA_ENABLE
403 
404 #if OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE
HandlePropertyGet(void)405 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_STATE>(void)
406 {
407     uint8_t state = SPINEL_THREAD_BACKBONE_ROUTER_STATE_DISABLED;
408 
409     switch (otBackboneRouterGetState(mInstance))
410     {
411     case OT_BACKBONE_ROUTER_STATE_DISABLED:
412         state = SPINEL_THREAD_BACKBONE_ROUTER_STATE_DISABLED;
413         break;
414 
415     case OT_BACKBONE_ROUTER_STATE_SECONDARY:
416         state = SPINEL_THREAD_BACKBONE_ROUTER_STATE_SECONDARY;
417         break;
418 
419     case OT_BACKBONE_ROUTER_STATE_PRIMARY:
420         state = SPINEL_THREAD_BACKBONE_ROUTER_STATE_PRIMARY;
421         break;
422     }
423 
424     return mEncoder.WriteUint8(state);
425 }
426 
HandlePropertySet(void)427 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_STATE>(void)
428 {
429     uint8_t state;
430     otError error = OT_ERROR_NONE;
431 
432     SuccessOrExit(error = mDecoder.ReadUint8(state));
433 
434     if (state)
435     {
436         otBackboneRouterSetEnabled(mInstance, true);
437     }
438     else
439     {
440         otBackboneRouterSetEnabled(mInstance, false);
441     }
442 
443 exit:
444     return error;
445 }
446 
HandlePropertyGet(void)447 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_CONFIG>(void)
448 {
449     otError                error = OT_ERROR_NONE;
450     otBackboneRouterConfig bbrConfig;
451 
452     otBackboneRouterGetConfig(mInstance, &bbrConfig);
453 
454     SuccessOrExit(error = mEncoder.WriteUint16(bbrConfig.mReregistrationDelay));
455     SuccessOrExit(error = mEncoder.WriteUint32(bbrConfig.mMlrTimeout));
456     SuccessOrExit(error = mEncoder.WriteUint8(bbrConfig.mSequenceNumber));
457 
458 exit:
459     return error;
460 }
461 
HandlePropertySet(void)462 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_CONFIG>(void)
463 {
464     otError                error = OT_ERROR_NONE;
465     otBackboneRouterConfig bbrConfig;
466 
467     SuccessOrExit(error = mDecoder.ReadUint16(bbrConfig.mReregistrationDelay));
468     SuccessOrExit(error = mDecoder.ReadUint32(bbrConfig.mMlrTimeout));
469     SuccessOrExit(error = mDecoder.ReadUint8(bbrConfig.mSequenceNumber));
470 
471     SuccessOrExit(error = otBackboneRouterSetConfig(mInstance, &bbrConfig));
472 
473 exit:
474     return error;
475 }
476 
HandlePropertySet(void)477 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTER>(void)
478 {
479     return otBackboneRouterRegister(mInstance);
480 }
481 
HandlePropertyGet(void)482 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTRATION_JITTER>(void)
483 {
484     uint8_t jitter = otBackboneRouterGetRegistrationJitter(mInstance);
485 
486     return mEncoder.WriteUint8(jitter);
487 }
488 
HandlePropertySet(void)489 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTRATION_JITTER>(void)
490 {
491     otError error = OT_ERROR_NONE;
492     uint8_t jitter;
493 
494     SuccessOrExit(error = mDecoder.ReadUint8(jitter));
495 
496     otBackboneRouterSetRegistrationJitter(mInstance, jitter);
497 
498 exit:
499     return error;
500 }
501 #endif // OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE
502 
HandlePropertyGet(void)503 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_NET_PSKC>(void)
504 {
505     Pskc pskc;
506 
507     otThreadGetPskc(mInstance, &pskc);
508 
509     return mEncoder.WriteData(pskc.m8, sizeof(spinel_net_pskc_t));
510 }
511 
HandlePropertySet(void)512 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_NET_PSKC>(void)
513 {
514     const uint8_t *ptr = nullptr;
515     uint16_t       len;
516     otError        error = OT_ERROR_NONE;
517 
518     SuccessOrExit(error = mDecoder.ReadData(ptr, len));
519 
520     VerifyOrExit(len == sizeof(spinel_net_pskc_t), error = OT_ERROR_PARSE);
521 
522     error = otThreadSetPskc(mInstance, reinterpret_cast<const otPskc *>(ptr));
523 
524 exit:
525     return error;
526 }
527 
528 #if OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE
HandlePropertySet(void)529 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_NET_PARTITION_ID>(void)
530 {
531     uint32_t partitionId = 0;
532     otError  error       = OT_ERROR_NONE;
533 
534     SuccessOrExit(error = mDecoder.ReadUint32(partitionId));
535 
536     otThreadSetPreferredLeaderPartitionId(mInstance, partitionId);
537 
538 exit:
539     return error;
540 }
541 #endif
542 
HandlePropertyGet(void)543 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_CHILD_COUNT_MAX>(void)
544 {
545     return mEncoder.WriteUint8(static_cast<uint8_t>(otThreadGetMaxAllowedChildren(mInstance)));
546 }
547 
HandlePropertySet(void)548 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_CHILD_COUNT_MAX>(void)
549 {
550     uint8_t maxChildren = 0;
551     otError error       = OT_ERROR_NONE;
552 
553     SuccessOrExit(error = mDecoder.ReadUint8(maxChildren));
554 
555     error = otThreadSetMaxAllowedChildren(mInstance, maxChildren);
556 
557 exit:
558     return error;
559 }
560 
HandlePropertyGet(void)561 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_ROUTER_UPGRADE_THRESHOLD>(void)
562 {
563     return mEncoder.WriteUint8(otThreadGetRouterUpgradeThreshold(mInstance));
564 }
565 
HandlePropertySet(void)566 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_ROUTER_UPGRADE_THRESHOLD>(void)
567 {
568     uint8_t threshold = 0;
569     otError error     = OT_ERROR_NONE;
570 
571     SuccessOrExit(error = mDecoder.ReadUint8(threshold));
572 
573     otThreadSetRouterUpgradeThreshold(mInstance, threshold);
574 
575 exit:
576     return error;
577 }
578 
HandlePropertyGet(void)579 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD>(void)
580 {
581     return mEncoder.WriteUint8(otThreadGetRouterDowngradeThreshold(mInstance));
582 }
583 
HandlePropertySet(void)584 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD>(void)
585 {
586     uint8_t threshold = 0;
587     otError error     = OT_ERROR_NONE;
588 
589     SuccessOrExit(error = mDecoder.ReadUint8(threshold));
590 
591     otThreadSetRouterDowngradeThreshold(mInstance, threshold);
592 
593 exit:
594     return error;
595 }
596 
HandlePropertyGet(void)597 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_ROUTER_SELECTION_JITTER>(void)
598 {
599     return mEncoder.WriteUint8(otThreadGetRouterSelectionJitter(mInstance));
600 }
601 
HandlePropertySet(void)602 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_ROUTER_SELECTION_JITTER>(void)
603 {
604     uint8_t jitter = 0;
605     otError error  = OT_ERROR_NONE;
606 
607     SuccessOrExit(error = mDecoder.ReadUint8(jitter));
608 
609     otThreadSetRouterSelectionJitter(mInstance, jitter);
610 
611 exit:
612     return error;
613 }
614 
HandlePropertyGet(void)615 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_CONTEXT_REUSE_DELAY>(void)
616 {
617     return mEncoder.WriteUint32(otThreadGetContextIdReuseDelay(mInstance));
618 }
619 
HandlePropertySet(void)620 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_CONTEXT_REUSE_DELAY>(void)
621 {
622     uint32_t delay = 0;
623     otError  error = OT_ERROR_NONE;
624 
625     SuccessOrExit(error = mDecoder.ReadUint32(delay));
626 
627     otThreadSetContextIdReuseDelay(mInstance, delay);
628 
629 exit:
630     return error;
631 }
632 
HandlePropertyGet(void)633 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_NETWORK_ID_TIMEOUT>(void)
634 {
635     return mEncoder.WriteUint8(otThreadGetNetworkIdTimeout(mInstance));
636 }
637 
HandlePropertySet(void)638 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_NETWORK_ID_TIMEOUT>(void)
639 {
640     uint8_t timeout = 0;
641     otError error   = OT_ERROR_NONE;
642 
643     SuccessOrExit(error = mDecoder.ReadUint8(timeout));
644 
645     otThreadSetNetworkIdTimeout(mInstance, timeout);
646 
647 exit:
648     return error;
649 }
650 
HandlePropertyGet(void)651 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_NEW_DATASET>(void)
652 {
653     otError              error;
654     otOperationalDataset dataset;
655 
656     error = otDatasetCreateNewNetwork(mInstance, &dataset);
657 
658     if (error == OT_ERROR_NONE)
659     {
660         error = EncodeOperationalDataset(dataset);
661     }
662     else
663     {
664         error = mEncoder.OverwriteWithLastStatusError(ThreadErrorToSpinelStatus(error));
665     }
666 
667     return error;
668 }
669 
670 #if OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
671 
HandlePropertyGet(void)672 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_MESHCOP_COMMISSIONER_STATE>(void)
673 {
674     uint8_t state = SPINEL_MESHCOP_COMMISSIONER_STATE_DISABLED;
675 
676     switch (otCommissionerGetState(mInstance))
677     {
678     case OT_COMMISSIONER_STATE_DISABLED:
679         state = SPINEL_MESHCOP_COMMISSIONER_STATE_DISABLED;
680         break;
681 
682     case OT_COMMISSIONER_STATE_PETITION:
683         state = SPINEL_MESHCOP_COMMISSIONER_STATE_PETITION;
684         break;
685 
686     case OT_COMMISSIONER_STATE_ACTIVE:
687         state = SPINEL_MESHCOP_COMMISSIONER_STATE_ACTIVE;
688         break;
689     }
690 
691     return mEncoder.WriteUint8(state);
692 }
693 
HandlePropertySet(void)694 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MESHCOP_COMMISSIONER_STATE>(void)
695 {
696     uint8_t state;
697     otError error = OT_ERROR_NONE;
698 
699     SuccessOrExit(error = mDecoder.ReadUint8(state));
700 
701     switch (state)
702     {
703     case SPINEL_MESHCOP_COMMISSIONER_STATE_DISABLED:
704         error = otCommissionerStop(mInstance);
705         break;
706 
707     case SPINEL_MESHCOP_COMMISSIONER_STATE_ACTIVE:
708         error = otCommissionerStart(mInstance, nullptr, nullptr, nullptr);
709         break;
710 
711     default:
712         error = OT_ERROR_INVALID_ARGS;
713         break;
714     }
715 
716 exit:
717     return error;
718 }
719 
HandlePropertyGet(void)720 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS>(void)
721 {
722     otError      error = OT_ERROR_NONE;
723     uint16_t     iter  = 0;
724     otJoinerInfo joinerInfo;
725 
726     while (otCommissionerGetNextJoinerInfo(mInstance, &iter, &joinerInfo) == OT_ERROR_NONE)
727     {
728         SuccessOrExit(error = mEncoder.OpenStruct());
729 
730         SuccessOrExit(error = mEncoder.OpenStruct()); // Joiner Id (any, EUI64 or a Joiner Discerner) struct
731 
732         switch (joinerInfo.mType)
733         {
734         case OT_JOINER_INFO_TYPE_ANY:
735             break;
736 
737         case OT_JOINER_INFO_TYPE_EUI64:
738             SuccessOrExit(error = mEncoder.WriteEui64(joinerInfo.mSharedId.mEui64));
739             break;
740 
741         case OT_JOINER_INFO_TYPE_DISCERNER:
742             SuccessOrExit(error = mEncoder.WriteUint8(joinerInfo.mSharedId.mDiscerner.mLength));
743             SuccessOrExit(error = mEncoder.WriteUint64(joinerInfo.mSharedId.mDiscerner.mValue));
744             break;
745         }
746 
747         SuccessOrExit(error = mEncoder.CloseStruct());
748 
749         SuccessOrExit(error = mEncoder.WriteUint32(joinerInfo.mExpirationTime));
750         SuccessOrExit(error = mEncoder.WriteUtf8(joinerInfo.mPskd.m8));
751 
752         SuccessOrExit(error = mEncoder.CloseStruct());
753     }
754 
755 exit:
756     return error;
757 }
758 
HandlePropertyInsert(void)759 template <> otError NcpBase::HandlePropertyInsert<SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS>(void)
760 {
761     otError             error = OT_ERROR_NONE;
762     otJoinerDiscerner   discerner;
763     bool                withDiscerner = false;
764     const otExtAddress *eui64;
765     uint32_t            timeout;
766     const char         *psk;
767 
768     SuccessOrExit(error = mDecoder.OpenStruct());
769 
770     switch (mDecoder.GetRemainingLengthInStruct())
771     {
772     case 0:
773         // Empty struct indicates any joiner
774         eui64 = nullptr;
775         break;
776 
777     case sizeof(spinel_eui64_t):
778         SuccessOrExit(error = mDecoder.ReadEui64(eui64));
779         break;
780 
781     default:
782         SuccessOrExit(error = mDecoder.ReadUint8(discerner.mLength));
783         SuccessOrExit(error = mDecoder.ReadUint64(discerner.mValue));
784         withDiscerner = true;
785         break;
786     }
787 
788     SuccessOrExit(error = mDecoder.CloseStruct());
789 
790     SuccessOrExit(error = mDecoder.ReadUint32(timeout));
791     SuccessOrExit(error = mDecoder.ReadUtf8(psk));
792 
793     if (withDiscerner)
794     {
795         error = otCommissionerAddJoinerWithDiscerner(mInstance, &discerner, psk, timeout);
796     }
797     else
798     {
799         error = otCommissionerAddJoiner(mInstance, eui64, psk, timeout);
800     }
801 
802 exit:
803     return error;
804 }
805 
HandlePropertyRemove(void)806 template <> otError NcpBase::HandlePropertyRemove<SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS>(void)
807 {
808     otError             error = OT_ERROR_NONE;
809     otJoinerDiscerner   discerner;
810     bool                withDiscerner = false;
811     const otExtAddress *eui64;
812 
813     SuccessOrExit(error = mDecoder.OpenStruct());
814 
815     switch (mDecoder.GetRemainingLengthInStruct())
816     {
817     case 0:
818         // Empty struct indicates any joiner
819         eui64 = nullptr;
820         break;
821 
822     case sizeof(spinel_eui64_t):
823         SuccessOrExit(error = mDecoder.ReadEui64(eui64));
824         break;
825 
826     default:
827         SuccessOrExit(error = mDecoder.ReadUint8(discerner.mLength));
828         SuccessOrExit(error = mDecoder.ReadUint64(discerner.mValue));
829         withDiscerner = true;
830         break;
831     }
832 
833     SuccessOrExit(error = mDecoder.CloseStruct());
834 
835     if (withDiscerner)
836     {
837         error = otCommissionerRemoveJoinerWithDiscerner(mInstance, &discerner);
838     }
839     else
840     {
841         error = otCommissionerRemoveJoiner(mInstance, eui64);
842     }
843 
844 exit:
845     return error;
846 }
847 
HandlePropertyGet(void)848 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_MESHCOP_COMMISSIONER_PROVISIONING_URL>(void)
849 {
850     return mEncoder.WriteUtf8(otCommissionerGetProvisioningUrl(mInstance));
851 }
852 
HandlePropertySet(void)853 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MESHCOP_COMMISSIONER_PROVISIONING_URL>(void)
854 {
855     otError     error = OT_ERROR_NONE;
856     const char *url;
857 
858     SuccessOrExit(error = mDecoder.ReadUtf8(url));
859 
860     error = otCommissionerSetProvisioningUrl(mInstance, url);
861 
862 exit:
863     return error;
864 }
865 
HandlePropertyGet(void)866 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_MESHCOP_COMMISSIONER_SESSION_ID>(void)
867 {
868     return mEncoder.WriteUint16(otCommissionerGetSessionId(mInstance));
869 }
870 
HandlePropertySet(void)871 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MESHCOP_COMMISSIONER_ANNOUNCE_BEGIN>(void)
872 {
873     otError             error = OT_ERROR_NONE;
874     uint32_t            channelMask;
875     uint8_t             count;
876     uint16_t            period;
877     const otIp6Address *address;
878 
879     SuccessOrExit(error = mDecoder.ReadUint32(channelMask));
880     SuccessOrExit(error = mDecoder.ReadUint8(count));
881     SuccessOrExit(error = mDecoder.ReadUint16(period));
882     SuccessOrExit(error = mDecoder.ReadIp6Address(address));
883 
884     error = otCommissionerAnnounceBegin(mInstance, channelMask, count, period, address);
885 
886 exit:
887     return error;
888 }
889 
HandlePropertySet(void)890 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MESHCOP_COMMISSIONER_ENERGY_SCAN>(void)
891 {
892     otError             error = OT_ERROR_NONE;
893     uint32_t            channelMask;
894     uint8_t             count;
895     uint16_t            period;
896     uint16_t            scanDuration;
897     const otIp6Address *address;
898 
899     SuccessOrExit(error = mDecoder.ReadUint32(channelMask));
900     SuccessOrExit(error = mDecoder.ReadUint8(count));
901     SuccessOrExit(error = mDecoder.ReadUint16(period));
902     SuccessOrExit(error = mDecoder.ReadUint16(scanDuration));
903     SuccessOrExit(error = mDecoder.ReadIp6Address(address));
904 
905     error = otCommissionerEnergyScan(mInstance, channelMask, count, period, scanDuration, address,
906                                      &NcpBase::HandleCommissionerEnergyReport_Jump, this);
907 
908 exit:
909     return error;
910 }
911 
HandleCommissionerEnergyReport_Jump(uint32_t aChannelMask,const uint8_t * aEnergyData,uint8_t aLength,void * aContext)912 void NcpBase::HandleCommissionerEnergyReport_Jump(uint32_t       aChannelMask,
913                                                   const uint8_t *aEnergyData,
914                                                   uint8_t        aLength,
915                                                   void          *aContext)
916 {
917     static_cast<NcpBase *>(aContext)->HandleCommissionerEnergyReport(aChannelMask, aEnergyData, aLength);
918 }
919 
HandleCommissionerEnergyReport(uint32_t aChannelMask,const uint8_t * aEnergyData,uint8_t aLength)920 void NcpBase::HandleCommissionerEnergyReport(uint32_t aChannelMask, const uint8_t *aEnergyData, uint8_t aLength)
921 {
922     otError error = OT_ERROR_NONE;
923 
924     SuccessOrExit(error = mEncoder.BeginFrame(SPINEL_HEADER_FLAG | SPINEL_HEADER_IID_0, SPINEL_CMD_PROP_VALUE_INSERTED,
925                                               SPINEL_PROP_MESHCOP_COMMISSIONER_ENERGY_SCAN_RESULT));
926     SuccessOrExit(error = mEncoder.WriteUint32(aChannelMask));
927     SuccessOrExit(error = mEncoder.WriteDataWithLen(aEnergyData, aLength));
928     SuccessOrExit(error = mEncoder.EndFrame());
929 
930 exit:
931 
932     if (error != OT_ERROR_NONE)
933     {
934         mChangedPropsSet.AddLastStatus(SPINEL_STATUS_NOMEM);
935         mUpdateChangedPropsTask.Post();
936     }
937 }
938 
HandlePropertySet(void)939 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MESHCOP_COMMISSIONER_PAN_ID_QUERY>(void)
940 {
941     otError             error = OT_ERROR_NONE;
942     uint16_t            panId;
943     uint32_t            channelMask;
944     const otIp6Address *address;
945 
946     SuccessOrExit(error = mDecoder.ReadUint16(panId));
947     SuccessOrExit(error = mDecoder.ReadUint32(channelMask));
948     SuccessOrExit(error = mDecoder.ReadIp6Address(address));
949 
950     error = otCommissionerPanIdQuery(mInstance, panId, channelMask, address,
951                                      &NcpBase::HandleCommissionerPanIdConflict_Jump, this);
952 
953 exit:
954     return error;
955 }
956 
HandleCommissionerPanIdConflict_Jump(uint16_t aPanId,uint32_t aChannelMask,void * aContext)957 void NcpBase::HandleCommissionerPanIdConflict_Jump(uint16_t aPanId, uint32_t aChannelMask, void *aContext)
958 {
959     static_cast<NcpBase *>(aContext)->HandleCommissionerPanIdConflict(aPanId, aChannelMask);
960 }
961 
HandleCommissionerPanIdConflict(uint16_t aPanId,uint32_t aChannelMask)962 void NcpBase::HandleCommissionerPanIdConflict(uint16_t aPanId, uint32_t aChannelMask)
963 {
964     otError error = OT_ERROR_NONE;
965 
966     SuccessOrExit(error = mEncoder.BeginFrame(SPINEL_HEADER_FLAG | SPINEL_HEADER_IID_0, SPINEL_CMD_PROP_VALUE_INSERTED,
967                                               SPINEL_PROP_MESHCOP_COMMISSIONER_PAN_ID_CONFLICT_RESULT));
968 
969     SuccessOrExit(error = mEncoder.WriteUint16(aPanId));
970     SuccessOrExit(error = mEncoder.WriteUint32(aChannelMask));
971     SuccessOrExit(error = mEncoder.EndFrame());
972 
973 exit:
974 
975     if (error != OT_ERROR_NONE)
976     {
977         mChangedPropsSet.AddLastStatus(SPINEL_STATUS_NOMEM);
978         mUpdateChangedPropsTask.Post();
979     }
980 }
981 
HandlePropertySet(void)982 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MESHCOP_COMMISSIONER_MGMT_GET>(void)
983 {
984     otError        error = OT_ERROR_NONE;
985     const uint8_t *tlvs;
986     uint16_t       length;
987 
988     SuccessOrExit(error = mDecoder.ReadDataWithLen(tlvs, length));
989     VerifyOrExit(length <= 255, error = OT_ERROR_INVALID_ARGS);
990 
991     error = otCommissionerSendMgmtGet(mInstance, tlvs, static_cast<uint8_t>(length));
992 
993 exit:
994     return error;
995 }
996 
HandlePropertySet(void)997 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_MESHCOP_COMMISSIONER_MGMT_SET>(void)
998 {
999     otError                error = OT_ERROR_NONE;
1000     const uint8_t         *tlvs;
1001     uint16_t               length;
1002     otCommissioningDataset dataset;
1003 
1004     SuccessOrExit(error = mDecoder.ReadDataWithLen(tlvs, length));
1005     VerifyOrExit(length <= 255, error = OT_ERROR_INVALID_ARGS);
1006 
1007     memset(&dataset, 0, sizeof(otCommissioningDataset));
1008     error = otCommissionerSendMgmtSet(mInstance, &dataset, tlvs, static_cast<uint8_t>(length));
1009 
1010 exit:
1011     return error;
1012 }
1013 
HandlePropertySet_SPINEL_PROP_MESHCOP_COMMISSIONER_GENERATE_PSKC(uint8_t aHeader)1014 otError NcpBase::HandlePropertySet_SPINEL_PROP_MESHCOP_COMMISSIONER_GENERATE_PSKC(uint8_t aHeader)
1015 {
1016     otError        error = OT_ERROR_NONE;
1017     const char    *passPhrase;
1018     const char    *networkName;
1019     const uint8_t *extPanIdData;
1020     uint16_t       length;
1021     otPskc         pskc;
1022 
1023     SuccessOrExit(error = mDecoder.ReadUtf8(passPhrase));
1024     SuccessOrExit(error = mDecoder.ReadUtf8(networkName));
1025     SuccessOrExit(error = mDecoder.ReadDataWithLen(extPanIdData, length));
1026     VerifyOrExit(length == sizeof(spinel_net_xpanid_t), error = OT_ERROR_PARSE);
1027 
1028     SuccessOrExit(error = otDatasetGeneratePskc(passPhrase, reinterpret_cast<const otNetworkName *>(networkName),
1029                                                 reinterpret_cast<const otExtendedPanId *>(extPanIdData), &pskc));
1030 
1031     SuccessOrExit(
1032         error = mEncoder.BeginFrame(aHeader, SPINEL_CMD_PROP_VALUE_IS, SPINEL_PROP_MESHCOP_COMMISSIONER_GENERATE_PSKC));
1033     SuccessOrExit(error = mEncoder.WriteData(pskc.m8, sizeof(pskc)));
1034     SuccessOrExit(error = mEncoder.EndFrame());
1035 
1036 exit:
1037     return error;
1038 }
1039 
1040 // SPINEL_PROP_THREAD_COMMISSIONER_ENABLED is replaced by SPINEL_PROP_MESHCOP_COMMISSIONER_STATE. Please use the new
1041 // property. The old property/implementation remains for backward compatibility.
1042 
HandlePropertyGet(void)1043 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_COMMISSIONER_ENABLED>(void)
1044 {
1045     return mEncoder.WriteBool(otCommissionerGetState(mInstance) == OT_COMMISSIONER_STATE_ACTIVE);
1046 }
1047 
HandlePropertySet_SPINEL_PROP_THREAD_COMMISSIONER_ENABLED(uint8_t aHeader)1048 otError NcpBase::HandlePropertySet_SPINEL_PROP_THREAD_COMMISSIONER_ENABLED(uint8_t aHeader)
1049 {
1050     bool    enabled = false;
1051     otError error   = OT_ERROR_NONE;
1052 
1053     SuccessOrExit(error = mDecoder.ReadBool(enabled));
1054 
1055     if (!enabled)
1056     {
1057         error = otCommissionerStop(mInstance);
1058     }
1059     else
1060     {
1061         error = otCommissionerStart(mInstance, nullptr, nullptr, nullptr);
1062     }
1063 
1064 exit:
1065     return PrepareLastStatusResponse(aHeader, ThreadErrorToSpinelStatus(error));
1066 }
1067 
1068 // SPINEL_PROP_THREAD_JOINERS is replaced by SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS. Please us the new property.
1069 // The old property/implementation remains for backward compatibility.
1070 
HandlePropertyInsert(void)1071 template <> otError NcpBase::HandlePropertyInsert<SPINEL_PROP_THREAD_JOINERS>(void)
1072 {
1073     otError             error         = OT_ERROR_NONE;
1074     const otExtAddress *eui64         = nullptr;
1075     const char         *pskd          = nullptr;
1076     uint32_t            joinerTimeout = 0;
1077 
1078     SuccessOrExit(error = mDecoder.ReadUtf8(pskd));
1079     SuccessOrExit(error = mDecoder.ReadUint32(joinerTimeout));
1080 
1081     if (mDecoder.ReadEui64(eui64) != OT_ERROR_NONE)
1082     {
1083         eui64 = nullptr;
1084     }
1085 
1086     error = otCommissionerAddJoiner(mInstance, eui64, pskd, joinerTimeout);
1087 
1088 exit:
1089     return error;
1090 }
1091 #endif // OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
1092 
HandlePropertySet(void)1093 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_LOCAL_LEADER_WEIGHT>(void)
1094 {
1095     uint8_t weight;
1096     otError error = OT_ERROR_NONE;
1097 
1098     SuccessOrExit(error = mDecoder.ReadUint8(weight));
1099 
1100     otThreadSetLocalLeaderWeight(mInstance, weight);
1101 
1102 exit:
1103     return error;
1104 }
1105 
1106 #if OPENTHREAD_CONFIG_MLE_STEERING_DATA_SET_OOB_ENABLE
1107 
HandlePropertyGet(void)1108 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_STEERING_DATA>(void)
1109 {
1110     return mEncoder.WriteEui64(mSteeringDataAddress);
1111 }
1112 
HandlePropertySet(void)1113 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_STEERING_DATA>(void)
1114 {
1115     otError error = OT_ERROR_NONE;
1116 
1117     SuccessOrExit(error = mDecoder.ReadEui64(mSteeringDataAddress));
1118 
1119     otThreadSetSteeringData(mInstance, &mSteeringDataAddress);
1120 
1121 exit:
1122     return error;
1123 }
1124 #endif // #if OPENTHREAD_CONFIG_MLE_STEERING_DATA_SET_OOB_ENABLE
1125 
HandlePropertyGet(void)1126 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_PREFERRED_ROUTER_ID>(void)
1127 {
1128     return mEncoder.WriteUint8(mPreferredRouteId);
1129 }
1130 
HandlePropertySet(void)1131 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_PREFERRED_ROUTER_ID>(void)
1132 {
1133     otError error = OT_ERROR_NONE;
1134 
1135     SuccessOrExit(error = mDecoder.ReadUint8(mPreferredRouteId));
1136 
1137     SuccessOrExit(error = otThreadSetPreferredRouterId(mInstance, mPreferredRouteId));
1138 
1139 exit:
1140     return error;
1141 }
1142 
HandlePropertyRemove(void)1143 template <> otError NcpBase::HandlePropertyRemove<SPINEL_PROP_THREAD_ACTIVE_ROUTER_IDS>(void)
1144 {
1145     otError error = OT_ERROR_NONE;
1146     uint8_t routerId;
1147 
1148     SuccessOrExit(error = mDecoder.ReadUint8(routerId));
1149 
1150     error = otThreadReleaseRouterId(mInstance, routerId);
1151 
1152     // `INVALID_STATE` is returned when router ID was not allocated (i.e. not in the list)
1153     // in such a case, the "remove" operation can be considered successful.
1154 
1155     if (error == OT_ERROR_INVALID_STATE)
1156     {
1157         error = OT_ERROR_NONE;
1158     }
1159 
1160 exit:
1161     return error;
1162 }
1163 
HandlePropertyGet(void)1164 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_ADDRESS_CACHE_TABLE>(void)
1165 {
1166     otError              error = OT_ERROR_NONE;
1167     otCacheEntryIterator iterator;
1168     otCacheEntryInfo     entry;
1169 
1170     memset(&iterator, 0, sizeof(iterator));
1171 
1172     for (uint8_t index = 0;; index++)
1173     {
1174         SuccessOrExit(otThreadGetNextCacheEntry(mInstance, &entry, &iterator));
1175 
1176         SuccessOrExit(error = mEncoder.OpenStruct());
1177         SuccessOrExit(error = mEncoder.WriteIp6Address(entry.mTarget));
1178         SuccessOrExit(error = mEncoder.WriteUint16(entry.mRloc16));
1179         SuccessOrExit(error = mEncoder.WriteUint8(index));
1180 
1181         switch (entry.mState)
1182         {
1183         case OT_CACHE_ENTRY_STATE_CACHED:
1184             SuccessOrExit(error = mEncoder.WriteUint8(SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED));
1185             break;
1186         case OT_CACHE_ENTRY_STATE_SNOOPED:
1187             SuccessOrExit(error = mEncoder.WriteUint8(SPINEL_ADDRESS_CACHE_ENTRY_STATE_SNOOPED));
1188             break;
1189         case OT_CACHE_ENTRY_STATE_QUERY:
1190             SuccessOrExit(error = mEncoder.WriteUint8(SPINEL_ADDRESS_CACHE_ENTRY_STATE_QUERY));
1191             break;
1192         case OT_CACHE_ENTRY_STATE_RETRY_QUERY:
1193             SuccessOrExit(error = mEncoder.WriteUint8(SPINEL_ADDRESS_CACHE_ENTRY_STATE_RETRY_QUERY));
1194             break;
1195         }
1196 
1197         SuccessOrExit(error = mEncoder.OpenStruct());
1198 
1199         if (entry.mState == OT_CACHE_ENTRY_STATE_CACHED)
1200         {
1201             SuccessOrExit(error = mEncoder.WriteBool(entry.mValidLastTrans));
1202             SuccessOrExit(error = mEncoder.WriteUint32(entry.mLastTransTime));
1203             SuccessOrExit(error = mEncoder.WriteIp6Address(entry.mMeshLocalEid));
1204         }
1205 
1206         SuccessOrExit(error = mEncoder.CloseStruct());
1207 
1208         SuccessOrExit(error = mEncoder.OpenStruct());
1209 
1210         if (entry.mState != OT_CACHE_ENTRY_STATE_CACHED)
1211         {
1212             SuccessOrExit(error = mEncoder.WriteBool(entry.mCanEvict));
1213             SuccessOrExit(error = mEncoder.WriteUint16(entry.mTimeout));
1214             SuccessOrExit(error = mEncoder.WriteUint16(entry.mRetryDelay));
1215         }
1216 
1217         SuccessOrExit(error = mEncoder.CloseStruct());
1218 
1219         SuccessOrExit(error = mEncoder.CloseStruct());
1220     }
1221 
1222 exit:
1223     return error;
1224 }
1225 
HandlePropertyGet(void)1226 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHILD_SUPERVISION_INTERVAL>(void)
1227 {
1228     return mEncoder.WriteUint16(otChildSupervisionGetInterval(mInstance));
1229 }
1230 
HandlePropertySet(void)1231 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHILD_SUPERVISION_INTERVAL>(void)
1232 {
1233     otError  error = OT_ERROR_NONE;
1234     uint16_t interval;
1235 
1236     SuccessOrExit(error = mDecoder.ReadUint16(interval));
1237     otChildSupervisionSetInterval(mInstance, interval);
1238 
1239 exit:
1240     return error;
1241 }
1242 
1243 #if OPENTHREAD_CONFIG_CHANNEL_MANAGER_ENABLE
1244 
HandlePropertyGet(void)1245 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHANNEL_MANAGER_NEW_CHANNEL>(void)
1246 {
1247     return mEncoder.WriteUint8(otChannelManagerGetRequestedChannel(mInstance));
1248 }
1249 
HandlePropertySet(void)1250 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHANNEL_MANAGER_NEW_CHANNEL>(void)
1251 {
1252     uint8_t channel;
1253     otError error = OT_ERROR_NONE;
1254 
1255     SuccessOrExit(error = mDecoder.ReadUint8(channel));
1256 
1257     otChannelManagerRequestChannelChange(mInstance, channel);
1258 
1259 exit:
1260     return error;
1261 }
1262 
HandlePropertyGet(void)1263 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHANNEL_MANAGER_DELAY>(void)
1264 {
1265     return mEncoder.WriteUint16(otChannelManagerGetDelay(mInstance));
1266 }
1267 
HandlePropertySet(void)1268 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHANNEL_MANAGER_DELAY>(void)
1269 {
1270     uint16_t delay;
1271     otError  error = OT_ERROR_NONE;
1272 
1273     SuccessOrExit(error = mDecoder.ReadUint16(delay));
1274 
1275     error = otChannelManagerSetDelay(mInstance, delay);
1276 
1277 exit:
1278     return error;
1279 }
1280 
HandlePropertyGet(void)1281 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHANNEL_MANAGER_SUPPORTED_CHANNELS>(void)
1282 {
1283     return EncodeChannelMask(otChannelManagerGetSupportedChannels(mInstance));
1284 }
1285 
HandlePropertySet(void)1286 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHANNEL_MANAGER_SUPPORTED_CHANNELS>(void)
1287 {
1288     uint32_t channelMask = 0;
1289     otError  error       = OT_ERROR_NONE;
1290 
1291     SuccessOrExit(error = DecodeChannelMask(channelMask));
1292     otChannelManagerSetSupportedChannels(mInstance, channelMask);
1293 
1294 exit:
1295     return error;
1296 }
1297 
HandlePropertyGet(void)1298 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHANNEL_MANAGER_FAVORED_CHANNELS>(void)
1299 {
1300     return EncodeChannelMask(otChannelManagerGetFavoredChannels(mInstance));
1301 }
1302 
HandlePropertySet(void)1303 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHANNEL_MANAGER_FAVORED_CHANNELS>(void)
1304 {
1305     uint32_t channelMask = 0;
1306     otError  error       = OT_ERROR_NONE;
1307 
1308     SuccessOrExit(error = DecodeChannelMask(channelMask));
1309     otChannelManagerSetFavoredChannels(mInstance, channelMask);
1310 
1311 exit:
1312     return error;
1313 }
1314 
HandlePropertyGet(void)1315 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHANNEL_MANAGER_CHANNEL_SELECT>(void)
1316 {
1317     return mEncoder.WriteBool(false);
1318 }
1319 
HandlePropertySet(void)1320 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHANNEL_MANAGER_CHANNEL_SELECT>(void)
1321 {
1322     bool    skipQualityCheck = false;
1323     otError error            = OT_ERROR_NONE;
1324 
1325     SuccessOrExit(error = mDecoder.ReadBool(skipQualityCheck));
1326     error = otChannelManagerRequestChannelSelect(mInstance, skipQualityCheck);
1327 
1328 exit:
1329     return error;
1330 }
1331 
HandlePropertyGet(void)1332 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_ENABLED>(void)
1333 {
1334     return mEncoder.WriteBool(otChannelManagerGetAutoChannelSelectionEnabled(mInstance));
1335 }
1336 
HandlePropertySet(void)1337 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_ENABLED>(void)
1338 {
1339     bool    enabled = false;
1340     otError error   = OT_ERROR_NONE;
1341 
1342     SuccessOrExit(error = mDecoder.ReadBool(enabled));
1343     otChannelManagerSetAutoChannelSelectionEnabled(mInstance, enabled);
1344 
1345 exit:
1346     return error;
1347 }
1348 
HandlePropertyGet(void)1349 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_INTERVAL>(void)
1350 {
1351     return mEncoder.WriteUint32(otChannelManagerGetAutoChannelSelectionInterval(mInstance));
1352 }
1353 
HandlePropertySet(void)1354 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_INTERVAL>(void)
1355 {
1356     uint32_t interval;
1357     otError  error = OT_ERROR_NONE;
1358 
1359     SuccessOrExit(error = mDecoder.ReadUint32(interval));
1360     error = otChannelManagerSetAutoChannelSelectionInterval(mInstance, interval);
1361 
1362 exit:
1363     return error;
1364 }
1365 
1366 #endif // OPENTHREAD_CONFIG_CHANNEL_MANAGER_ENABLE
1367 
1368 #if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
HandlePropertyGet(void)1369 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_TIME_SYNC_PERIOD>(void)
1370 {
1371     return mEncoder.WriteUint16(otNetworkTimeGetSyncPeriod(mInstance));
1372 }
1373 
HandlePropertySet(void)1374 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_TIME_SYNC_PERIOD>(void)
1375 {
1376     otError  error = OT_ERROR_NONE;
1377     uint16_t timeSyncPeriod;
1378 
1379     SuccessOrExit(error = mDecoder.ReadUint16(timeSyncPeriod));
1380 
1381     SuccessOrExit(error = otNetworkTimeSetSyncPeriod(mInstance, timeSyncPeriod));
1382 
1383 exit:
1384     return error;
1385 }
1386 
HandlePropertyGet(void)1387 template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_TIME_SYNC_XTAL_THRESHOLD>(void)
1388 {
1389     return mEncoder.WriteUint16(otNetworkTimeGetXtalThreshold(mInstance));
1390 }
1391 
HandlePropertySet(void)1392 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_TIME_SYNC_XTAL_THRESHOLD>(void)
1393 {
1394     otError  error = OT_ERROR_NONE;
1395     uint16_t xtalThreshold;
1396 
1397     SuccessOrExit(error = mDecoder.ReadUint16(xtalThreshold));
1398 
1399     SuccessOrExit(error = otNetworkTimeSetXtalThreshold(mInstance, xtalThreshold));
1400 
1401 exit:
1402     return error;
1403 }
1404 #endif // OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
1405 
1406 } // namespace Ncp
1407 } // namespace ot
1408 
1409 #endif // OPENTHREAD_FTD
1410