third_party/ot-br-posix/repo/src/backbone_router/backbone_agent.cpp

   1 /*
   2  *    Copyright (c) 2020, 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 /**
  30  * @file
  31  *   The file implements the Thread Backbone agent.
  32  */
  33
  34 #include "backbone_router/backbone_agent.hpp"
  35
  36 #include <assert.h>
  37 #include <net/if.h>
  38
  39 #include <openthread/backbone_router_ftd.h>
  40
  41 #include "common/code_utils.hpp"
  42
  43 namespace otbr {
  44 namespace BackboneRouter {
  45
  46 BackboneAgent::BackboneAgent(otbr::Ncp::ControllerOpenThread &aNcp)
  47     : mNcp(aNcp)
  48     , mBackboneRouterState(OT_BACKBONE_ROUTER_STATE_DISABLED)
  49     , mNdProxyManager(aNcp)
  50 {
  51 }
  52
  53 void BackboneAgent::Init(void)
  54 {
  55     mNcp.On(Ncp::kEventBackboneRouterState, HandleBackboneRouterState, this);
  56     mNcp.On(Ncp::kEventBackboneRouterDomainPrefixEvent, HandleBackboneRouterDomainPrefixEvent, this);
  57     mNcp.On(Ncp::kEventBackboneRouterNdProxyEvent, HandleBackboneRouterNdProxyEvent, this);
  58
  59     mNdProxyManager.Init();
  60
  61     HandleBackboneRouterState();
  62 }
  63
  64 void BackboneAgent::HandleBackboneRouterState(void *aContext, int aEvent, va_list aArguments)
  65 {
  66     OT_UNUSED_VARIABLE(aEvent);
  67     OT_UNUSED_VARIABLE(aArguments);
  68
  69     assert(aEvent == Ncp::kEventBackboneRouterState);
  70
  71     static_cast<BackboneAgent *>(aContext)->HandleBackboneRouterState();
  72 }
  73
  74 void BackboneAgent::HandleBackboneRouterState(void)
  75 {
  76     otBackboneRouterState state      = otBackboneRouterGetState(mNcp.GetInstance());
  77     bool                  wasPrimary = (mBackboneRouterState == OT_BACKBONE_ROUTER_STATE_PRIMARY);
  78
  79     otbrLog(OTBR_LOG_DEBUG, "BackboneAgent: HandleBackboneRouterState: state=%d, mBackboneRouterState=%d", state,
  80             mBackboneRouterState);
  81     VerifyOrExit(mBackboneRouterState != state);
  82
  83     mBackboneRouterState = state;
  84
  85     if (IsPrimary())
  86     {
  87         OnBecomePrimary();
  88     }
  89     else if (wasPrimary)
  90     {
  91         OnResignPrimary();
  92     }
  93
  94 exit:
  95     return;
  96 }
  97
  98 void BackboneAgent::OnBecomePrimary(void)
  99 {
 100     otbrLog(OTBR_LOG_NOTICE, "BackboneAgent: Backbone Router becomes Primary!");
 101
 102     if (mDomainPrefix.IsValid())
 103     {
 104         mNdProxyManager.Enable(mDomainPrefix);
 105     }
 106 }
 107
 108 void BackboneAgent::OnResignPrimary(void)
 109 {
 110     otbrLog(OTBR_LOG_NOTICE, "BackboneAgent: Backbone Router resigns Primary to %s!",
 111             StateToString(mBackboneRouterState));
 112
 113     mNdProxyManager.Disable();
 114 }
 115
 116 const char *BackboneAgent::StateToString(otBackboneRouterState aState)
 117 {
 118     const char *ret = "Unknown";
 119
 120     switch (aState)
 121     {
 122     case OT_BACKBONE_ROUTER_STATE_DISABLED:
 123         ret = "Disabled";
 124         break;
 125     case OT_BACKBONE_ROUTER_STATE_SECONDARY:
 126         ret = "Secondary";
 127         break;
 128     case OT_BACKBONE_ROUTER_STATE_PRIMARY:
 129         ret = "Primary";
 130         break;
 131     }
 132
 133     return ret;
 134 }
 135 void BackboneAgent::UpdateFdSet(fd_set & aReadFdSet,
 136                                 fd_set & aWriteFdSet,
 137                                 fd_set & aErrorFdSet,
 138                                 int &    aMaxFd,
 139                                 timeval &aTimeout) const
 140 {
 141     mNdProxyManager.UpdateFdSet(aReadFdSet, aWriteFdSet, aErrorFdSet, aMaxFd, aTimeout);
 142 }
 143
 144 void BackboneAgent::Process(const fd_set &aReadFdSet, const fd_set &aWriteFdSet, const fd_set &aErrorFdSet)
 145 {
 146     mNdProxyManager.Process(aReadFdSet, aWriteFdSet, aErrorFdSet);
 147 }
 148
 149 void BackboneAgent::HandleBackboneRouterDomainPrefixEvent(void *aContext, int aEvent, va_list aArguments)
 150 {
 151     OT_UNUSED_VARIABLE(aEvent);
 152
 153     otBackboneRouterDomainPrefixEvent event;
 154     const otIp6Prefix *               domainPrefix;
 155
 156     assert(aEvent == Ncp::kEventBackboneRouterDomainPrefixEvent);
 157
 158     event        = static_cast<otBackboneRouterDomainPrefixEvent>(va_arg(aArguments, int));
 159     domainPrefix = va_arg(aArguments, const otIp6Prefix *);
 160     static_cast<BackboneAgent *>(aContext)->HandleBackboneRouterDomainPrefixEvent(event, domainPrefix);
 161 }
 162
 163 void BackboneAgent::HandleBackboneRouterDomainPrefixEvent(otBackboneRouterDomainPrefixEvent aEvent,
 164                                                           const otIp6Prefix *               aDomainPrefix)
 165 {
 166     if (aEvent == OT_BACKBONE_ROUTER_DOMAIN_PREFIX_REMOVED)
 167     {
 168         mDomainPrefix.Clear();
 169     }
 170     else
 171     {
 172         assert(aDomainPrefix != nullptr);
 173         mDomainPrefix.Set(*aDomainPrefix);
 174         assert(mDomainPrefix.IsValid());
 175     }
 176
 177     VerifyOrExit(IsPrimary() && aEvent != OT_BACKBONE_ROUTER_DOMAIN_PREFIX_REMOVED);
 178
 179     mNdProxyManager.Disable();
 180     mNdProxyManager.Enable(mDomainPrefix);
 181 exit:
 182     return;
 183 }
 184
 185 void BackboneAgent::HandleBackboneRouterNdProxyEvent(void *aContext, int aEvent, va_list aArguments)
 186 {
 187     OT_UNUSED_VARIABLE(aEvent);
 188
 189     otBackboneRouterNdProxyEvent event;
 190     const otIp6Address *         address;
 191
 192     assert(aEvent == Ncp::kEventBackboneRouterNdProxyEvent);
 193
 194     event   = static_cast<otBackboneRouterNdProxyEvent>(va_arg(aArguments, int));
 195     address = va_arg(aArguments, const otIp6Address *);
 196     static_cast<BackboneAgent *>(aContext)->HandleBackboneRouterNdProxyEvent(event, address);
 197 }
 198
 199 void BackboneAgent::HandleBackboneRouterNdProxyEvent(otBackboneRouterNdProxyEvent aEvent, const otIp6Address *aDua)
 200 {
 201     mNdProxyManager.HandleBackboneRouterNdProxyEvent(aEvent, aDua);
 202 }
 203
 204 } // namespace BackboneRouter
 205 } // namespace otbr