xref: /aosp_15_r20/external/openthread/src/cli/cli_bbr.cpp (revision cfb92d1480a9e65faed56933e9c12405f45898b4)

/*
 *  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)