src/adaptations/device-layer/LwIP/WarmSupport.cpp - third_party/openweave-core - Git at Google

 /*
  *
  *    Copyright (c) 2018 Nest Labs, Inc.
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 /**
  *    @file
  *          Provides implementations of platform functions for the Weave
  *          Addressing and Routing Module (WARM) for use on LwIP-based
  *          platforms.
  */

 #include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
 #include <Weave/DeviceLayer/ConnectivityManager.h>
 #include <Weave/DeviceLayer/LwIP/WarmSupport.h>
 #include <lwip/netif.h>
 #include <lwip/ip6_route_table.h>
 #if LWIP_IPV6_MLD
 #include "lwip/mld6.h"
 #endif /* LWIP_IPV6_MLD */

 #if WARM_CONFIG_SUPPORT_THREAD
 #include <Weave/DeviceLayer/ThreadStackManager.h>
 #include <Weave/DeviceLayer/OpenThread/OpenThreadUtils.h>
 #include <openthread/ip6.h>
 #endif // WARM_CONFIG_SUPPORT_THREAD


 using namespace ::nl::Weave::DeviceLayer;
 using namespace ::nl::Weave::DeviceLayer::Internal;

 using namespace ::nl;
 using namespace ::nl::Weave;
 using namespace ::nl::Weave::Warm;

 // ==================== WARM Platform Functions ====================

 namespace nl {
 namespace Weave {
 namespace Warm {
 namespace Platform {

 WEAVE_ERROR Init(WarmFabricStateDelegate * inFabricStateDelegate)
 {
     // Nothing to do.
     return WEAVE_NO_ERROR;
 }

 void CriticalSectionEnter(void)
 {
     // No-op on this platform since all interaction with WARM core happens on the Weave event thread.
 }

 void CriticalSectionExit(void)
 {
     // No-op on this platform since all interaction with WARM core happens on the Weave event thread.
 }

 void RequestInvokeActions(void)
 {
     ::nl::Weave::Warm::InvokeActions();
 }

 PlatformResult AddRemoveHostAddress(InterfaceType inInterfaceType, const Inet::IPAddress & inAddress, uint8_t inPrefixLength, bool inAdd)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     err_t lwipErr;
     struct netif * netif;
     ip6_addr_t ip6addr = inAddress.ToIPv6();
     bool lockHeld = false;

     // If an address is being added/removed from the tunnel interface, and the address in question
     // is a ULA referring to the Weave Primary WiFi subnet, substitute the Thread Mesh subnet id.
     // This works around a limitation in the current Nest service, which presumes that all devices
     // have a Thread radio, and therefore a Thread subnet Weave ULA to which packets can be routed.
     if (inInterfaceType == kInterfaceTypeTunnel && inAddress.IsIPv6ULA() && inAddress.Subnet() == kWeaveSubnetId_PrimaryWiFi)
     {
         Inet::IPAddress altAddr = Inet::IPAddress::MakeULA(inAddress.GlobalId(), kWeaveSubnetId_ThreadMesh, inAddress.InterfaceId());
         ip6addr = altAddr.ToIPv6();
     }

     LOCK_TCPIP_CORE();
     lockHeld = true;

     err = GetLwIPNetifForWarmInterfaceType(inInterfaceType, netif);
     SuccessOrExit(err);

     if (inAdd)
     {
         s8_t addrIdx;
         lwipErr = netif_add_ip6_address_with_route(netif, &ip6addr, inPrefixLength, &addrIdx);
         err = System::MapErrorLwIP(lwipErr);
         if (err != WEAVE_NO_ERROR)
         {
             WeaveLogError(DeviceLayer, "netif_add_ip6_address_with_route() failed for %s interface: %s",
                     WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
             ExitNow();
         }
         netif_ip6_addr_set_state(netif, addrIdx, IP6_ADDR_PREFERRED);

 #if LWIP_IPV6_MLD
         // If the interface supports IPv6 MLD, join the solicited-node multicast group associated
         // with the assigned address.
         if (LwIPNetifSupportsMLD(netif))
         {
             ip6_addr_t solNodeAddr;
             ip6_addr_set_solicitednode(&solNodeAddr, ip6addr.addr[3]);
             lwipErr = mld6_joingroup_netif(netif, &solNodeAddr);
             err = System::MapErrorLwIP(lwipErr);
             if (err != WEAVE_NO_ERROR)
             {
                 WeaveLogError(DeviceLayer, "mld6_joingroup_netif() failed for %s interface: %s",
                         WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
                 ExitNow();
             }
         }
 #endif /* LWIP_IPV6_MLD */
     }
     else
     {
         lwipErr = netif_remove_ip6_address_with_route(netif, &ip6addr, inPrefixLength);
         // There are two possible errors from netif_remove_ip6_address: ERR_ARG
         // if call was made with wrong arguments, or ERR_VAL if the action could
         // not be performed (e.g. the address was already removed).  We squash
         // ERR_VAL, and return SUCCESS so that WARM can set its state correctly.
         if (lwipErr == ERR_VAL)
         {
             WeaveLogProgress(DeviceLayer, "netif_remove_ip6_address_with_route: Already removed");
             lwipErr = ERR_OK;
         }
         err = System::MapErrorLwIP(lwipErr);
         if (err != WEAVE_NO_ERROR)
         {
             WeaveLogError(DeviceLayer, "netif_remove_ip6_address_with_route() failed for %s interface: %s",
                      WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
             ExitNow();
         }

 #if LWIP_IPV6_MLD
         // Leave the solicited-node multicast group associated with the removed address.
         {
             ip6_addr_t solNodeAddr;
             ip6_addr_set_solicitednode(&solNodeAddr, ip6addr.addr[3]);
             mld6_leavegroup_netif(netif, &solNodeAddr);
         }
 #endif /* LWIP_IPV6_MLD */
     }

     UNLOCK_TCPIP_CORE();
     lockHeld = false;

 #if WEAVE_PROGRESS_LOGGING
     {
         char interfaceName[4];
         GetInterfaceName(netif, interfaceName, sizeof(interfaceName));
         char ipAddrStr[INET6_ADDRSTRLEN];
         inAddress.ToString(ipAddrStr, sizeof(ipAddrStr));
         WeaveLogProgress(DeviceLayer, "%s %s %s LwIP %s interface (%s): %s/%" PRId8,
                  (inAdd) ? "Adding" : "Removing",
                  CharacterizeIPv6Address(inAddress),
                  (inAdd) ? "to" : "from",
                  WarmInterfaceTypeToStr(inInterfaceType),
                  interfaceName,
                  ipAddrStr, inPrefixLength);
     }
 #endif // WEAVE_PROGRESS_LOGGING

 exit:
     if (lockHeld)
     {
         UNLOCK_TCPIP_CORE();
     }

     if (err != WEAVE_NO_ERROR)
     {
         WeaveLogError(DeviceLayer, "AddRemoveHostAddress() failed: %s", ::nl::ErrorStr(err));
     }

     return (err == WEAVE_NO_ERROR) ? kPlatformResultSuccess : kPlatformResultFailure;
 }

 PlatformResult AddRemoveHostRoute(InterfaceType inInterfaceType, const Inet::IPPrefix & inPrefix, RoutePriority inPriority, bool inAdd)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     struct netif * netif;
     bool lockHeld = false;

     LOCK_TCPIP_CORE();
     lockHeld = true;

     err = GetLwIPNetifForWarmInterfaceType(inInterfaceType, netif);
     SuccessOrExit(err);

     // if requested, set/unset the default route...
     if (inPrefix.Length == 0)
     {
         // Only bother to set the default route.
         if (inAdd)
         {
             netif_set_default(netif);
         }
     }

     // otherwise a more specific route is being added/removed, so...
     else
     {
 #if WARM_CONFIG_SUPPORT_WIFI || WARM_CONFIG_SUPPORT_CELLULAR

         // On platforms that support WiFi and/or cellular, this code supports full manipulation of the
         // local routing table.  Note that this requires a custom version of LwIP that support the
         // LWIP_IPV6_ROUTE_TABLE_SUPPORT extension.

         struct ip6_prefix lwipIP6prefix;
         lwipIP6prefix.addr = inPrefix.IPAddr.ToIPv6();
         lwipIP6prefix.prefix_len = inPrefix.Length;

         if (inAdd)
         {
             err_t lwipErr = ip6_add_route_entry(&lwipIP6prefix, netif, NULL, NULL);
             err = System::MapErrorLwIP(lwipErr);
             if (err != WEAVE_NO_ERROR)
             {
                 WeaveLogError(DeviceLayer, "ip6_add_route_entry() failed for %s interface: %s",
                          WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
                 ExitNow();
             }
         }
         else
         {
             ip6_remove_route_entry(&lwipIP6prefix);
         }

 #elif WARM_CONFIG_SUPPORT_THREAD

         // On platforms that only support Thread there is only one interface, and thus no need
         // for a generalized routing table or adding/removing routes. In this situation, WARM
         // will only call this function to set the default route.  Since that case was handled
         // above, we fail with an error here.

         ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

 #endif // WARM_CONFIG_SUPPORT_THREAD
     }

     UNLOCK_TCPIP_CORE();
     lockHeld = false;

 #if WEAVE_PROGRESS_LOGGING
     {
         char interfaceName[4];
         GetInterfaceName(netif, interfaceName, sizeof(interfaceName));
         if (inPrefix.Length != 0)
         {
             char prefixAddrStr[INET6_ADDRSTRLEN];
             inPrefix.IPAddr.ToString(prefixAddrStr, sizeof(prefixAddrStr));
             const char * prefixDesc = CharacterizeIPv6Prefix(inPrefix);
             WeaveLogProgress(DeviceLayer, "IPv6 route%s%s %s LwIP %s interface (%s): %s/%" PRId8,
                      (prefixDesc != NULL) ? " for " : "",
                      (prefixDesc != NULL) ? prefixDesc : "",
                      (inAdd) ? "added to" : "removed from",
                      WarmInterfaceTypeToStr(inInterfaceType),
                      interfaceName,
                      prefixAddrStr, inPrefix.Length);
         }
         else
         {
             WeaveLogProgress(DeviceLayer, "LwIP default interface set to %s interface (%s)",
                      WarmInterfaceTypeToStr(inInterfaceType),
                      interfaceName);
         }
     }
 #endif // WEAVE_PROGRESS_LOGGING

 exit:
     if (lockHeld)
     {
         UNLOCK_TCPIP_CORE();
     }

     if (err != WEAVE_NO_ERROR)
     {
         WeaveLogError(DeviceLayer, "AddRemoveHostRoute() failed: %s", ::nl::ErrorStr(err));
     }

     return (err == WEAVE_NO_ERROR) ? kPlatformResultSuccess : kPlatformResultFailure;
 }

 #if WARM_CONFIG_SUPPORT_THREAD

 PlatformResult AddRemoveThreadAddress(InterfaceType inInterfaceType, const Inet::IPAddress &inAddress, bool inAdd)
 {
     otError otErr;
     otNetifAddress otAddress;

     memset(&otAddress, 0, sizeof(otAddress));
     otAddress.mAddress = ToOpenThreadIP6Address(inAddress);
     otAddress.mPrefixLength = 64;
     otAddress.mValid = true;
     otAddress.mPreferred = true;

     ThreadStackMgrImpl().LockThreadStack();

     if (inAdd)
     {
         otErr = otIp6AddUnicastAddress(ThreadStackMgrImpl().OTInstance(), &otAddress);
     }
     else
     {
         otErr = otIp6RemoveUnicastAddress(ThreadStackMgrImpl().OTInstance(), &otAddress.mAddress);
         // There are two possible errors from otIp6RemoveUnicastAddress:
         // OT_ERROR_INVALID_ARGS if the address was a multicast address, and
         // OT_ERROR_NOT_FOUND if the address does not exist on the thread
         // interface.  We squash the OT_ERROR_NOT_FOUND so that WARM sets its
         // state correctly.
         if (otErr == OT_ERROR_NOT_FOUND)
         {
             WeaveLogProgress(DeviceLayer, "otIp6RemoveUnicastAddress: already removed");
             otErr = OT_ERROR_NONE;
         }
     }

     ThreadStackMgrImpl().UnlockThreadStack();

     if (otErr == OT_ERROR_NONE)
     {
 #if WEAVE_PROGRESS_LOGGING
         char ipAddrStr[INET6_ADDRSTRLEN];
         inAddress.ToString(ipAddrStr, sizeof(ipAddrStr));
         WeaveLogProgress(DeviceLayer, "%s %s %s OpenThread stack: %s/64",
                  (inAdd) ? "Adding" : "Removing",
                  CharacterizeIPv6Address(inAddress),
                  (inAdd) ? "to" : "from",
                  ipAddrStr);
 #endif // WEAVE_PROGRESS_LOGGING
     }
     else
     {
         WeaveLogError(DeviceLayer, "AddRemoveThreadAddress() failed: %s", ::nl::ErrorStr(MapOpenThreadError(otErr)));
     }

     return (otErr == OT_ERROR_NONE) ? kPlatformResultSuccess : kPlatformResultFailure;
 }

 #endif // WARM_CONFIG_SUPPORT_THREAD

 #if WARM_CONFIG_SUPPORT_THREAD_ROUTING

 #error "Weave Thread router support not implemented"

 PlatformResult StartStopThreadAdvertisement(InterfaceType inInterfaceType, const Inet::IPPrefix &inPrefix, bool inStart)
 {
     // TODO: implement me
 }

 #endif // WARM_CONFIG_SUPPORT_THREAD_ROUTING

 #if WARM_CONFIG_SUPPORT_BORDER_ROUTING

 #error "Weave border router support not implemented"

 PlatformResult AddRemoveThreadRoute(InterfaceType inInterfaceType, const Inet::IPPrefix &inPrefix, RoutePriority inPriority, bool inAdd)
 {
     // TODO: implement me
 }

 PlatformResult SetThreadRoutePriority(InterfaceType inInterfaceType, const Inet::IPPrefix &inPrefix, RoutePriority inPriority)
 {
     // TODO: implement me
 }

 #endif // WARM_CONFIG_SUPPORT_BORDER_ROUTING

 } // namespace Platform
 } // namespace Warm
 } // namespace Weave
 } // namespace nl

 // ==================== WARM Utility Functions ====================

 namespace nl {
 namespace Weave {
 namespace DeviceLayer {
 namespace Internal {

 WEAVE_ERROR GetLwIPNetifForWarmInterfaceType(InterfaceType inInterfaceType, struct netif *& netif)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     for (netif = netif_list; netif != NULL; netif = netif->next)
     {
         if (inInterfaceType == kInterfaceTypeWiFi &&
             netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[0] &&
             netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[1])
         {
             ExitNow(err = WEAVE_NO_ERROR);
         }

         if (inInterfaceType == kInterfaceTypeTunnel &&
             netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_SERVICE_TUN_IF_NAME[0] &&
             netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_SERVICE_TUN_IF_NAME[1])
         {
             ExitNow(err = WEAVE_NO_ERROR);
         }

         if (inInterfaceType == kInterfaceTypeThread &&
             netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_THREAD_IF_NAME[0] &&
             netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_THREAD_IF_NAME[1])
         {
             ExitNow(err = WEAVE_NO_ERROR);
         }
     }

     ExitNow(err = INET_ERROR_UNKNOWN_INTERFACE);

 exit:
     return err;
 }

 bool LwIPNetifSupportsMLD(struct netif * netif)
 {
     // Determine if the given netif supports IPv6 MLD.  Unfortunately, the LwIP MLD6 netif flag
     // is an unreliable indication of MLD support in older versions of LwIP.
     return (((netif->flags & NETIF_FLAG_MLD6) != 0) ||
             (netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[0] &&
              netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[1]));
 }

 const char * WarmInterfaceTypeToStr(InterfaceType inInterfaceType)
 {
     switch (inInterfaceType)
     {
     case kInterfaceTypeLegacy6LoWPAN:
         return "Legacy 6LoWPAN";
     case kInterfaceTypeThread:
         return "Thread";
     case kInterfaceTypeWiFi:
         return "WiFi station";
     case kInterfaceTypeTunnel:
         return "Tunnel";
     case kInterfaceTypeCellular:
         return "Cellular";
     default:
         return "(unknown)";
     }
 }

 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace Weave
 } // namespace nl
	/*
	*
	* Copyright (c) 2018 Nest Labs, Inc.
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @file
	* Provides implementations of platform functions for the Weave
	* Addressing and Routing Module (WARM) for use on LwIP-based
	* platforms.
	*/

	#include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
	#include <Weave/DeviceLayer/ConnectivityManager.h>
	#include <Weave/DeviceLayer/LwIP/WarmSupport.h>
	#include <lwip/netif.h>
	#include <lwip/ip6_route_table.h>
	#if LWIP_IPV6_MLD
	#include "lwip/mld6.h"
	#endif /* LWIP_IPV6_MLD */

	#if WARM_CONFIG_SUPPORT_THREAD
	#include <Weave/DeviceLayer/ThreadStackManager.h>
	#include <Weave/DeviceLayer/OpenThread/OpenThreadUtils.h>
	#include <openthread/ip6.h>
	#endif // WARM_CONFIG_SUPPORT_THREAD


	using namespace ::nl::Weave::DeviceLayer;
	using namespace ::nl::Weave::DeviceLayer::Internal;

	using namespace ::nl;
	using namespace ::nl::Weave;
	using namespace ::nl::Weave::Warm;

	// ==================== WARM Platform Functions ====================

	namespace nl {
	namespace Weave {
	namespace Warm {
	namespace Platform {

	WEAVE_ERROR Init(WarmFabricStateDelegate * inFabricStateDelegate)
	{
	// Nothing to do.
	return WEAVE_NO_ERROR;
	}

	void CriticalSectionEnter(void)
	{
	// No-op on this platform since all interaction with WARM core happens on the Weave event thread.
	}

	void CriticalSectionExit(void)
	{
	// No-op on this platform since all interaction with WARM core happens on the Weave event thread.
	}

	void RequestInvokeActions(void)
	{
	::nl::Weave::Warm::InvokeActions();
	}

	PlatformResult AddRemoveHostAddress(InterfaceType inInterfaceType, const Inet::IPAddress & inAddress, uint8_t inPrefixLength, bool inAdd)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	err_t lwipErr;
	struct netif * netif;
	ip6_addr_t ip6addr = inAddress.ToIPv6();
	bool lockHeld = false;

	// If an address is being added/removed from the tunnel interface, and the address in question
	// is a ULA referring to the Weave Primary WiFi subnet, substitute the Thread Mesh subnet id.
	// This works around a limitation in the current Nest service, which presumes that all devices
	// have a Thread radio, and therefore a Thread subnet Weave ULA to which packets can be routed.
	if (inInterfaceType == kInterfaceTypeTunnel && inAddress.IsIPv6ULA() && inAddress.Subnet() == kWeaveSubnetId_PrimaryWiFi)
	{
	Inet::IPAddress altAddr = Inet::IPAddress::MakeULA(inAddress.GlobalId(), kWeaveSubnetId_ThreadMesh, inAddress.InterfaceId());
	ip6addr = altAddr.ToIPv6();
	}

	LOCK_TCPIP_CORE();
	lockHeld = true;

	err = GetLwIPNetifForWarmInterfaceType(inInterfaceType, netif);
	SuccessOrExit(err);

	if (inAdd)
	{
	s8_t addrIdx;
	lwipErr = netif_add_ip6_address_with_route(netif, &ip6addr, inPrefixLength, &addrIdx);
	err = System::MapErrorLwIP(lwipErr);
	if (err != WEAVE_NO_ERROR)
	{
	WeaveLogError(DeviceLayer, "netif_add_ip6_address_with_route() failed for %s interface: %s",
	WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
	ExitNow();
	}
	netif_ip6_addr_set_state(netif, addrIdx, IP6_ADDR_PREFERRED);

	#if LWIP_IPV6_MLD
	// If the interface supports IPv6 MLD, join the solicited-node multicast group associated
	// with the assigned address.
	if (LwIPNetifSupportsMLD(netif))
	{
	ip6_addr_t solNodeAddr;
	ip6_addr_set_solicitednode(&solNodeAddr, ip6addr.addr[3]);
	lwipErr = mld6_joingroup_netif(netif, &solNodeAddr);
	err = System::MapErrorLwIP(lwipErr);
	if (err != WEAVE_NO_ERROR)
	{
	WeaveLogError(DeviceLayer, "mld6_joingroup_netif() failed for %s interface: %s",
	WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
	ExitNow();
	}
	}
	#endif /* LWIP_IPV6_MLD */
	}
	else
	{
	lwipErr = netif_remove_ip6_address_with_route(netif, &ip6addr, inPrefixLength);
	// There are two possible errors from netif_remove_ip6_address: ERR_ARG
	// if call was made with wrong arguments, or ERR_VAL if the action could
	// not be performed (e.g. the address was already removed). We squash
	// ERR_VAL, and return SUCCESS so that WARM can set its state correctly.
	if (lwipErr == ERR_VAL)
	{
	WeaveLogProgress(DeviceLayer, "netif_remove_ip6_address_with_route: Already removed");
	lwipErr = ERR_OK;
	}
	err = System::MapErrorLwIP(lwipErr);
	if (err != WEAVE_NO_ERROR)
	{
	WeaveLogError(DeviceLayer, "netif_remove_ip6_address_with_route() failed for %s interface: %s",
	WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
	ExitNow();
	}

	#if LWIP_IPV6_MLD
	// Leave the solicited-node multicast group associated with the removed address.
	{
	ip6_addr_t solNodeAddr;
	ip6_addr_set_solicitednode(&solNodeAddr, ip6addr.addr[3]);
	mld6_leavegroup_netif(netif, &solNodeAddr);
	}
	#endif /* LWIP_IPV6_MLD */
	}

	UNLOCK_TCPIP_CORE();
	lockHeld = false;

	#if WEAVE_PROGRESS_LOGGING
	{
	char interfaceName[4];
	GetInterfaceName(netif, interfaceName, sizeof(interfaceName));
	char ipAddrStr[INET6_ADDRSTRLEN];
	inAddress.ToString(ipAddrStr, sizeof(ipAddrStr));
	WeaveLogProgress(DeviceLayer, "%s %s %s LwIP %s interface (%s): %s/%" PRId8,
	(inAdd) ? "Adding" : "Removing",
	CharacterizeIPv6Address(inAddress),
	(inAdd) ? "to" : "from",
	WarmInterfaceTypeToStr(inInterfaceType),
	interfaceName,
	ipAddrStr, inPrefixLength);
	}
	#endif // WEAVE_PROGRESS_LOGGING

	exit:
	if (lockHeld)
	{
	UNLOCK_TCPIP_CORE();
	}

	if (err != WEAVE_NO_ERROR)
	{
	WeaveLogError(DeviceLayer, "AddRemoveHostAddress() failed: %s", ::nl::ErrorStr(err));
	}

	return (err == WEAVE_NO_ERROR) ? kPlatformResultSuccess : kPlatformResultFailure;
	}

	PlatformResult AddRemoveHostRoute(InterfaceType inInterfaceType, const Inet::IPPrefix & inPrefix, RoutePriority inPriority, bool inAdd)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	struct netif * netif;
	bool lockHeld = false;

	LOCK_TCPIP_CORE();
	lockHeld = true;

	err = GetLwIPNetifForWarmInterfaceType(inInterfaceType, netif);
	SuccessOrExit(err);

	// if requested, set/unset the default route...
	if (inPrefix.Length == 0)
	{
	// Only bother to set the default route.
	if (inAdd)
	{
	netif_set_default(netif);
	}
	}

	// otherwise a more specific route is being added/removed, so...
	else
	{
	#if WARM_CONFIG_SUPPORT_WIFI \|\| WARM_CONFIG_SUPPORT_CELLULAR

	// On platforms that support WiFi and/or cellular, this code supports full manipulation of the
	// local routing table. Note that this requires a custom version of LwIP that support the
	// LWIP_IPV6_ROUTE_TABLE_SUPPORT extension.

	struct ip6_prefix lwipIP6prefix;
	lwipIP6prefix.addr = inPrefix.IPAddr.ToIPv6();
	lwipIP6prefix.prefix_len = inPrefix.Length;

	if (inAdd)
	{
	err_t lwipErr = ip6_add_route_entry(&lwipIP6prefix, netif, NULL, NULL);
	err = System::MapErrorLwIP(lwipErr);
	if (err != WEAVE_NO_ERROR)
	{
	WeaveLogError(DeviceLayer, "ip6_add_route_entry() failed for %s interface: %s",
	WarmInterfaceTypeToStr(inInterfaceType), nl::ErrorStr(err));
	ExitNow();
	}
	}
	else
	{
	ip6_remove_route_entry(&lwipIP6prefix);
	}

	#elif WARM_CONFIG_SUPPORT_THREAD

	// On platforms that only support Thread there is only one interface, and thus no need
	// for a generalized routing table or adding/removing routes. In this situation, WARM
	// will only call this function to set the default route. Since that case was handled
	// above, we fail with an error here.

	ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

	#endif // WARM_CONFIG_SUPPORT_THREAD
	}

	UNLOCK_TCPIP_CORE();
	lockHeld = false;

	#if WEAVE_PROGRESS_LOGGING
	{
	char interfaceName[4];
	GetInterfaceName(netif, interfaceName, sizeof(interfaceName));
	if (inPrefix.Length != 0)
	{
	char prefixAddrStr[INET6_ADDRSTRLEN];
	inPrefix.IPAddr.ToString(prefixAddrStr, sizeof(prefixAddrStr));
	const char * prefixDesc = CharacterizeIPv6Prefix(inPrefix);
	WeaveLogProgress(DeviceLayer, "IPv6 route%s%s %s LwIP %s interface (%s): %s/%" PRId8,
	(prefixDesc != NULL) ? " for " : "",
	(prefixDesc != NULL) ? prefixDesc : "",
	(inAdd) ? "added to" : "removed from",
	WarmInterfaceTypeToStr(inInterfaceType),
	interfaceName,
	prefixAddrStr, inPrefix.Length);
	}
	else
	{
	WeaveLogProgress(DeviceLayer, "LwIP default interface set to %s interface (%s)",
	WarmInterfaceTypeToStr(inInterfaceType),
	interfaceName);
	}
	}
	#endif // WEAVE_PROGRESS_LOGGING

	exit:
	if (lockHeld)
	{
	UNLOCK_TCPIP_CORE();
	}

	if (err != WEAVE_NO_ERROR)
	{
	WeaveLogError(DeviceLayer, "AddRemoveHostRoute() failed: %s", ::nl::ErrorStr(err));
	}

	return (err == WEAVE_NO_ERROR) ? kPlatformResultSuccess : kPlatformResultFailure;
	}

	#if WARM_CONFIG_SUPPORT_THREAD

	PlatformResult AddRemoveThreadAddress(InterfaceType inInterfaceType, const Inet::IPAddress &inAddress, bool inAdd)
	{
	otError otErr;
	otNetifAddress otAddress;

	memset(&otAddress, 0, sizeof(otAddress));
	otAddress.mAddress = ToOpenThreadIP6Address(inAddress);
	otAddress.mPrefixLength = 64;
	otAddress.mValid = true;
	otAddress.mPreferred = true;

	ThreadStackMgrImpl().LockThreadStack();

	if (inAdd)
	{
	otErr = otIp6AddUnicastAddress(ThreadStackMgrImpl().OTInstance(), &otAddress);
	}
	else
	{
	otErr = otIp6RemoveUnicastAddress(ThreadStackMgrImpl().OTInstance(), &otAddress.mAddress);
	// There are two possible errors from otIp6RemoveUnicastAddress:
	// OT_ERROR_INVALID_ARGS if the address was a multicast address, and
	// OT_ERROR_NOT_FOUND if the address does not exist on the thread
	// interface. We squash the OT_ERROR_NOT_FOUND so that WARM sets its
	// state correctly.
	if (otErr == OT_ERROR_NOT_FOUND)
	{
	WeaveLogProgress(DeviceLayer, "otIp6RemoveUnicastAddress: already removed");
	otErr = OT_ERROR_NONE;
	}
	}

	ThreadStackMgrImpl().UnlockThreadStack();

	if (otErr == OT_ERROR_NONE)
	{
	#if WEAVE_PROGRESS_LOGGING
	char ipAddrStr[INET6_ADDRSTRLEN];
	inAddress.ToString(ipAddrStr, sizeof(ipAddrStr));
	WeaveLogProgress(DeviceLayer, "%s %s %s OpenThread stack: %s/64",
	(inAdd) ? "Adding" : "Removing",
	CharacterizeIPv6Address(inAddress),
	(inAdd) ? "to" : "from",
	ipAddrStr);
	#endif // WEAVE_PROGRESS_LOGGING
	}
	else
	{
	WeaveLogError(DeviceLayer, "AddRemoveThreadAddress() failed: %s", ::nl::ErrorStr(MapOpenThreadError(otErr)));
	}

	return (otErr == OT_ERROR_NONE) ? kPlatformResultSuccess : kPlatformResultFailure;
	}

	#endif // WARM_CONFIG_SUPPORT_THREAD

	#if WARM_CONFIG_SUPPORT_THREAD_ROUTING

	#error "Weave Thread router support not implemented"

	PlatformResult StartStopThreadAdvertisement(InterfaceType inInterfaceType, const Inet::IPPrefix &inPrefix, bool inStart)
	{
	// TODO: implement me
	}

	#endif // WARM_CONFIG_SUPPORT_THREAD_ROUTING

	#if WARM_CONFIG_SUPPORT_BORDER_ROUTING

	#error "Weave border router support not implemented"

	PlatformResult AddRemoveThreadRoute(InterfaceType inInterfaceType, const Inet::IPPrefix &inPrefix, RoutePriority inPriority, bool inAdd)
	{
	// TODO: implement me
	}

	PlatformResult SetThreadRoutePriority(InterfaceType inInterfaceType, const Inet::IPPrefix &inPrefix, RoutePriority inPriority)
	{
	// TODO: implement me
	}

	#endif // WARM_CONFIG_SUPPORT_BORDER_ROUTING

	} // namespace Platform
	} // namespace Warm
	} // namespace Weave
	} // namespace nl

	// ==================== WARM Utility Functions ====================

	namespace nl {
	namespace Weave {
	namespace DeviceLayer {
	namespace Internal {

	WEAVE_ERROR GetLwIPNetifForWarmInterfaceType(InterfaceType inInterfaceType, struct netif *& netif)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	for (netif = netif_list; netif != NULL; netif = netif->next)
	{
	if (inInterfaceType == kInterfaceTypeWiFi &&
	netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[0] &&
	netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[1])
	{
	ExitNow(err = WEAVE_NO_ERROR);
	}

	if (inInterfaceType == kInterfaceTypeTunnel &&
	netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_SERVICE_TUN_IF_NAME[0] &&
	netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_SERVICE_TUN_IF_NAME[1])
	{
	ExitNow(err = WEAVE_NO_ERROR);
	}

	if (inInterfaceType == kInterfaceTypeThread &&
	netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_THREAD_IF_NAME[0] &&
	netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_THREAD_IF_NAME[1])
	{
	ExitNow(err = WEAVE_NO_ERROR);
	}
	}

	ExitNow(err = INET_ERROR_UNKNOWN_INTERFACE);

	exit:
	return err;
	}

	bool LwIPNetifSupportsMLD(struct netif * netif)
	{
	// Determine if the given netif supports IPv6 MLD. Unfortunately, the LwIP MLD6 netif flag
	// is an unreliable indication of MLD support in older versions of LwIP.
	return (((netif->flags & NETIF_FLAG_MLD6) != 0) \|\|
	(netif->name[0] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[0] &&
	netif->name[1] == WEAVE_DEVICE_CONFIG_LWIP_WIFI_STATION_IF_NAME[1]));
	}

	const char * WarmInterfaceTypeToStr(InterfaceType inInterfaceType)
	{
	switch (inInterfaceType)
	{
	case kInterfaceTypeLegacy6LoWPAN:
	return "Legacy 6LoWPAN";
	case kInterfaceTypeThread:
	return "Thread";
	case kInterfaceTypeWiFi:
	return "WiFi station";
	case kInterfaceTypeTunnel:
	return "Tunnel";
	case kInterfaceTypeCellular:
	return "Cellular";
	default:
	return "(unknown)";
	}
	}

	} // namespace Internal
	} // namespace DeviceLayer
	} // namespace Weave
	} // namespace nl