| /* |
| * Copyright (c) 2023, The OpenThread Authors. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the |
| * names of its contributors may be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** |
| * @file |
| * This file implements CLI for Backbone Router. |
| */ |
| |
| #include "cli_bbr.hpp" |
| |
| #include "cli/cli.hpp" |
| |
| #if (OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2) |
| |
| namespace ot { |
| namespace Cli { |
| |
| void Bbr::OutputConfig(const otBackboneRouterConfig &aConfig) |
| { |
| OutputLine("seqno: %u", aConfig.mSequenceNumber); |
| OutputLine("delay: %u secs", aConfig.mReregistrationDelay); |
| OutputLine("timeout: %lu secs", ToUlong(aConfig.mMlrTimeout)); |
| } |
| |
| #if OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE |
| |
| #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE |
| |
| template <> otError Bbr::Process<Cmd("mlr")>(Arg aArgs[]) |
| { |
| otError error = OT_ERROR_INVALID_COMMAND; |
| |
| /** |
| * @cli bbr mgmt mlr listener |
| * @code |
| * bbr mgmt mlr listener |
| * ff04:0:0:0:0:0:0:abcd 3534000 |
| * ff04:0:0:0:0:0:0:eeee 3537610 |
| * Done |
| * @endcode |
| * @par |
| * Returns the Multicast Listeners with the #otBackboneRouterMulticastListenerInfo |
| * `mTimeout` in seconds. |
| * @par |
| * Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` and |
| * `OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE` are enabled. |
| * @sa otBackboneRouterMulticastListenerGetNext |
| */ |
| if (aArgs[0] == "listener") |
| { |
| if (aArgs[1].IsEmpty()) |
| { |
| otBackboneRouterMulticastListenerIterator iter = OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ITERATOR_INIT; |
| otBackboneRouterMulticastListenerInfo listenerInfo; |
| |
| while (otBackboneRouterMulticastListenerGetNext(GetInstancePtr(), &iter, &listenerInfo) == OT_ERROR_NONE) |
| { |
| OutputIp6Address(listenerInfo.mAddress); |
| OutputLine(" %lu", ToUlong(listenerInfo.mTimeout)); |
| } |
| |
| ExitNow(error = OT_ERROR_NONE); |
| } |
| |
| #if OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE |
| /** |
| * @cli bbr mgmt mlr listener clear |
| * @code |
| * bbr mgmt mlr listener clear |
| * Done |
| * @endcode |
| * @par api_copy |
| * #otBackboneRouterMulticastListenerClear |
| */ |
| if (aArgs[1] == "clear") |
| { |
| otBackboneRouterMulticastListenerClear(GetInstancePtr()); |
| error = OT_ERROR_NONE; |
| } |
| /** |
| * @cli bbr mgmt mlr listener add |
| * @code |
| * bbr mgmt mlr listener add ff04::1 |
| * Done |
| * @endcode |
| * @code |
| * bbr mgmt mlr listener add ff04::2 300 |
| * Done |
| * @endcode |
| * @cparam bbr mgmt mlr listener add @ca{ipaddress} [@ca{timeout-seconds}] |
| * @par api_copy |
| * #otBackboneRouterMulticastListenerAdd |
| */ |
| else if (aArgs[1] == "add") |
| { |
| otIp6Address address; |
| uint32_t timeout = 0; |
| |
| SuccessOrExit(error = aArgs[2].ParseAsIp6Address(address)); |
| |
| if (!aArgs[3].IsEmpty()) |
| { |
| SuccessOrExit(error = aArgs[3].ParseAsUint32(timeout)); |
| } |
| |
| error = otBackboneRouterMulticastListenerAdd(GetInstancePtr(), &address, timeout); |
| } |
| } |
| /** |
| * @cli bbr mgmt mlr response |
| * @code |
| * bbr mgmt mlr response 2 |
| * Done |
| * @endcode |
| * @cparam bbr mgmt mlr response @ca{status-code} |
| * For `status-code`, use: |
| * * 0: ST_MLR_SUCCESS |
| * * 2: ST_MLR_INVALID |
| * * 3: ST_MLR_NO_PERSISTENT |
| * * 4: ST_MLR_NO_RESOURCES |
| * * 5: ST_MLR_BBR_NOT_PRIMARY |
| * * 6: ST_MLR_GENERAL_FAILURE |
| * @par api_copy |
| * #otBackboneRouterConfigNextMulticastListenerRegistrationResponse |
| */ |
| else if (aArgs[0] == "response") |
| { |
| uint8_t status; |
| |
| SuccessOrExit(error = aArgs[1].ParseAsUint8(status)); |
| otBackboneRouterConfigNextMulticastListenerRegistrationResponse(GetInstancePtr(), status); |
| error = OT_ERROR_NONE; |
| |
| #endif // OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE |
| } |
| |
| exit: |
| return error; |
| } |
| |
| #endif // #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE |
| |
| template <> otError Bbr::Process<Cmd("mgmt")>(Arg aArgs[]) |
| { |
| otError error = OT_ERROR_INVALID_COMMAND; |
| |
| if (aArgs[0].IsEmpty()) |
| { |
| ExitNow(error = OT_ERROR_INVALID_COMMAND); |
| } |
| |
| #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE && OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE |
| /** |
| * @cli bbr mgmt dua |
| * @code |
| * bbr mgmt dua 1 2f7c235e5025a2fd |
| * Done |
| * @endcode |
| * @code |
| * bbr mgmt dua 160 |
| * Done |
| * @endcode |
| * @cparam bbr mgmt dua @ca{status|coap-code} [@ca{meshLocalIid}] |
| * For `status` or `coap-code`, use: |
| * * 0: ST_DUA_SUCCESS |
| * * 1: ST_DUA_REREGISTER |
| * * 2: ST_DUA_INVALID |
| * * 3: ST_DUA_DUPLICATE |
| * * 4: ST_DUA_NO_RESOURCES |
| * * 5: ST_DUA_BBR_NOT_PRIMARY |
| * * 6: ST_DUA_GENERAL_FAILURE |
| * * 160: COAP code 5.00 |
| * @par |
| * With the `meshLocalIid` included, this command configures the response status |
| * for the next DUA registration. Without `meshLocalIid`, respond to the next |
| * DUA.req with the specified `status` or `coap-code`. |
| * @par |
| * Available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled. |
| * @sa otBackboneRouterConfigNextDuaRegistrationResponse |
| */ |
| if (aArgs[0] == "dua") |
| { |
| uint8_t status; |
| otIp6InterfaceIdentifier *mlIid = nullptr; |
| otIp6InterfaceIdentifier iid; |
| |
| SuccessOrExit(error = aArgs[1].ParseAsUint8(status)); |
| |
| if (!aArgs[2].IsEmpty()) |
| { |
| SuccessOrExit(error = aArgs[2].ParseAsHexString(iid.mFields.m8)); |
| mlIid = &iid; |
| VerifyOrExit(aArgs[3].IsEmpty(), error = OT_ERROR_INVALID_ARGS); |
| } |
| |
| otBackboneRouterConfigNextDuaRegistrationResponse(GetInstancePtr(), mlIid, status); |
| ExitNow(); |
| } |
| #endif // OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE && OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE |
| |
| #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE |
| if (aArgs[0] == "mlr") |
| { |
| error = Process<Cmd("mlr")>(aArgs + 1); |
| ExitNow(); |
| } |
| #endif |
| |
| exit: |
| return error; |
| } |
| |
| /** |
| * @cli bbr enable |
| * @code |
| * bbr enable |
| * Done |
| * @endcode |
| * @par api_copy |
| * #otBackboneRouterSetEnabled |
| */ |
| template <> otError Bbr::Process<Cmd("enable")>(Arg aArgs[]) |
| { |
| OT_UNUSED_VARIABLE(aArgs); |
| otBackboneRouterSetEnabled(GetInstancePtr(), true); |
| |
| return OT_ERROR_NONE; |
| } |
| |
| /** |
| * @cli bbr disable |
| * @code |
| * bbr disable |
| * Done |
| * @endcode |
| * @par api_copy |
| * #otBackboneRouterSetEnabled |
| */ |
| template <> otError Bbr::Process<Cmd("disable")>(Arg aArgs[]) |
| { |
| OT_UNUSED_VARIABLE(aArgs); |
| otBackboneRouterSetEnabled(GetInstancePtr(), false); |
| |
| return OT_ERROR_NONE; |
| } |
| |
| /** |
| * @cli bbr jitter (get,set) |
| * @code |
| * bbr jitter |
| * 20 |
| * Done |
| * @endcode |
| * @code |
| * bbr jitter 10 |
| * Done |
| * @endcode |
| * @cparam bbr jitter [@ca{jitter}] |
| * @par |
| * Gets or sets jitter (in seconds) for Backbone Router registration. |
| * @par |
| * Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled. |
| * @sa otBackboneRouterGetRegistrationJitter |
| * @sa otBackboneRouterSetRegistrationJitter |
| */ |
| template <> otError Bbr::Process<Cmd("jitter")>(Arg aArgs[]) |
| { |
| return ProcessGetSet(aArgs, otBackboneRouterGetRegistrationJitter, otBackboneRouterSetRegistrationJitter); |
| } |
| |
| /** |
| * @cli bbr register |
| * @code |
| * bbr register |
| * Done |
| * @endcode |
| * @par api_copy |
| * #otBackboneRouterRegister |
| */ |
| template <> otError Bbr::Process<Cmd("register")>(Arg aArgs[]) |
| { |
| OT_UNUSED_VARIABLE(aArgs); |
| |
| return otBackboneRouterRegister(GetInstancePtr()); |
| } |
| |
| /** |
| * @cli bbr state |
| * @code |
| * bbr state |
| * Disabled |
| * Done |
| * @endcode |
| * @code |
| * bbr state |
| * Primary |
| * Done |
| * @endcode |
| * @code |
| * bbr state |
| * Secondary |
| * Done |
| * @endcode |
| * @par |
| * Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled. |
| * @par api_copy |
| * #otBackboneRouterGetState |
| */ |
| template <> otError Bbr::Process<Cmd("state")>(Arg aArgs[]) |
| |
| { |
| static const char *const kStateStrings[] = { |
| "Disabled", // (0) OT_BACKBONE_ROUTER_STATE_DISABLED |
| "Secondary", // (1) OT_BACKBONE_ROUTER_STATE_SECONDARY |
| "Primary", // (2) OT_BACKBONE_ROUTER_STATE_PRIMARY |
| }; |
| |
| static_assert(0 == OT_BACKBONE_ROUTER_STATE_DISABLED, "OT_BACKBONE_ROUTER_STATE_DISABLED value is incorrect"); |
| static_assert(1 == OT_BACKBONE_ROUTER_STATE_SECONDARY, "OT_BACKBONE_ROUTER_STATE_SECONDARY value is incorrect"); |
| static_assert(2 == OT_BACKBONE_ROUTER_STATE_PRIMARY, "OT_BACKBONE_ROUTER_STATE_PRIMARY value is incorrect"); |
| |
| OT_UNUSED_VARIABLE(aArgs); |
| |
| OutputLine("%s", Stringify(otBackboneRouterGetState(GetInstancePtr()), kStateStrings)); |
| |
| return OT_ERROR_NONE; |
| } |
| |
| /** |
| * @cli bbr config |
| * @code |
| * bbr config |
| * seqno: 10 |
| * delay: 120 secs |
| * timeout: 300 secs |
| * Done |
| * @endcode |
| * @par api_copy |
| * #otBackboneRouterGetConfig |
| */ |
| template <> otError Bbr::Process<Cmd("config")>(Arg aArgs[]) |
| { |
| otError error = OT_ERROR_NONE; |
| otBackboneRouterConfig config; |
| |
| otBackboneRouterGetConfig(GetInstancePtr(), &config); |
| |
| if (aArgs[0].IsEmpty()) |
| { |
| OutputConfig(config); |
| } |
| else |
| { |
| // Set local Backbone Router configuration. |
| /** |
| * @cli bbr config (set) |
| * @code |
| * bbr config seqno 20 delay 30 |
| * Done |
| * @endcode |
| * @cparam bbr config [seqno @ca{seqno}] [delay @ca{delay}] [timeout @ca{timeout}] |
| * @par |
| * `bbr register` should be issued explicitly to register Backbone Router service to Leader |
| * for Secondary Backbone Router. |
| * @par api_copy |
| * #otBackboneRouterSetConfig |
| */ |
| for (Arg *arg = &aArgs[0]; !arg->IsEmpty(); arg++) |
| { |
| if (*arg == "seqno") |
| { |
| arg++; |
| SuccessOrExit(error = arg->ParseAsUint8(config.mSequenceNumber)); |
| } |
| else if (*arg == "delay") |
| { |
| arg++; |
| SuccessOrExit(error = arg->ParseAsUint16(config.mReregistrationDelay)); |
| } |
| else if (*arg == "timeout") |
| { |
| arg++; |
| SuccessOrExit(error = arg->ParseAsUint32(config.mMlrTimeout)); |
| } |
| else |
| { |
| ExitNow(error = OT_ERROR_INVALID_ARGS); |
| } |
| } |
| |
| error = otBackboneRouterSetConfig(GetInstancePtr(), &config); |
| } |
| |
| exit: |
| return error; |
| } |
| |
| #endif // OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE |
| |
| otError Bbr::Process(Arg aArgs[]) |
| { |
| #define CmdEntry(aCommandString) {aCommandString, &Bbr::Process<Cmd(aCommandString)>} |
| |
| otError error = OT_ERROR_INVALID_COMMAND; |
| |
| /** |
| * @cli bbr |
| * @code |
| * bbr |
| * BBR Primary: |
| * server16: 0xE400 |
| * seqno: 10 |
| * delay: 120 secs |
| * timeout: 300 secs |
| * Done |
| * @endcode |
| * @code |
| * bbr |
| * BBR Primary: None |
| * Done |
| * @endcode |
| * @par |
| * Returns the current Primary Backbone Router information for the Thread device. |
| */ |
| if (aArgs[0].IsEmpty()) |
| { |
| otBackboneRouterConfig config; |
| |
| OutputFormat("BBR Primary:"); |
| |
| if (otBackboneRouterGetPrimary(GetInstancePtr(), &config) == OT_ERROR_NONE) |
| { |
| OutputNewLine(); |
| OutputLine("server16: 0x%04X", config.mServer16); |
| OutputConfig(config); |
| } |
| else |
| { |
| OutputLine(" None"); |
| } |
| |
| error = OT_ERROR_NONE; |
| ExitNow(); |
| } |
| |
| #if OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE |
| { |
| static constexpr Command kCommands[] = { |
| CmdEntry("config"), CmdEntry("disable"), CmdEntry("enable"), CmdEntry("jitter"), |
| CmdEntry("mgmt"), CmdEntry("register"), CmdEntry("state"), |
| }; |
| |
| #undef CmdEntry |
| |
| static_assert(BinarySearch::IsSorted(kCommands), "kCommands is not sorted"); |
| |
| const Command *command; |
| |
| command = BinarySearch::Find(aArgs[0].GetCString(), kCommands); |
| VerifyOrExit(command != nullptr); |
| |
| error = (this->*command->mHandler)(aArgs + 1); |
| } |
| #endif // #if OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE |
| |
| exit: |
| return error; |
| } |
| |
| } // namespace Cli |
| } // namespace ot |
| |
| #endif // #if (OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2) |
