src/posix/platform/mdns_socket.cpp - third_party/openthread - Git at Google

 /*
  *  Copyright (c) 2024, 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.
  */

 #include "mdns_socket.hpp"

 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE

 #include <arpa/inet.h>
 #include <errno.h>
 #include <net/if.h>
 #include <netinet/in.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include "ip6_utils.hpp"
 #include "platform-posix.h"
 #include "common/code_utils.hpp"

 extern "C" otError otPlatMdnsSetListeningEnabled(otInstance *aInstance, bool aEnable, uint32_t aInfraIfIndex)
 {
     return ot::Posix::MdnsSocket::Get().SetListeningEnabled(aInstance, aEnable, aInfraIfIndex);
 }

 extern "C" void otPlatMdnsSendMulticast(otInstance *aInstance, otMessage *aMessage, uint32_t aInfraIfIndex)
 {
     OT_UNUSED_VARIABLE(aInstance);
     return ot::Posix::MdnsSocket::Get().SendMulticast(aMessage, aInfraIfIndex);
 }

 extern "C" void otPlatMdnsSendUnicast(otInstance *aInstance, otMessage *aMessage, const otPlatMdnsAddressInfo *aAddress)
 {
     OT_UNUSED_VARIABLE(aInstance);
     return ot::Posix::MdnsSocket::Get().SendUnicast(aMessage, aAddress);
 }

 namespace ot {
 namespace Posix {

 using namespace ot::Posix::Ip6Utils;

 const char MdnsSocket::kLogModuleName[] = "MdnsSocket";

 MdnsSocket &MdnsSocket::Get(void)
 {
     static MdnsSocket sInstance;

     return sInstance;
 }

 void MdnsSocket::Init(void)
 {
     mEnabled      = false;
     mInfraIfIndex = 0;
     mFd6          = -1;
     mFd4          = -1;
     mPendingIp6Tx = 0;
     mPendingIp4Tx = 0;

     // mDNS multicast IPv6 address "ff02::fb"
     memset(&mMulticastIp6Address, 0, sizeof(otIp6Address));
     mMulticastIp6Address.mFields.m8[0]  = 0xff;
     mMulticastIp6Address.mFields.m8[1]  = 0x02;
     mMulticastIp6Address.mFields.m8[15] = 0xfb;

     // mDNS multicast IPv4 address "224.0.0.251"
     memset(&mMulticastIp4Address, 0, sizeof(otIp4Address));
     mMulticastIp4Address.mFields.m8[0] = 224;
     mMulticastIp4Address.mFields.m8[3] = 251;

     memset(&mTxQueue, 0, sizeof(mTxQueue));
 }

 void MdnsSocket::SetUp(void)
 {
     otMessageQueueInit(&mTxQueue);
     Mainloop::Manager::Get().Add(*this);
 }

 void MdnsSocket::TearDown(void)
 {
     Mainloop::Manager::Get().Remove(*this);

     if (mEnabled)
     {
         ClearTxQueue();
         mEnabled = false;
     }
 }

 void MdnsSocket::Deinit(void)
 {
     CloseIp4Socket();
     CloseIp6Socket();
 }

 void MdnsSocket::Update(otSysMainloopContext &aContext)
 {
     VerifyOrExit(mEnabled);

     FD_SET(mFd6, &aContext.mReadFdSet);
     FD_SET(mFd4, &aContext.mReadFdSet);

     if (mPendingIp6Tx > 0)
     {
         FD_SET(mFd6, &aContext.mWriteFdSet);
     }

     if (mPendingIp4Tx > 0)
     {
         FD_SET(mFd4, &aContext.mWriteFdSet);
     }

     if (aContext.mMaxFd < mFd6)
     {
         aContext.mMaxFd = mFd6;
     }

     if (aContext.mMaxFd < mFd4)
     {
         aContext.mMaxFd = mFd4;
     }

 exit:
     return;
 }

 void MdnsSocket::Process(const otSysMainloopContext &aContext)
 {
     VerifyOrExit(mEnabled);

     if (FD_ISSET(mFd6, &aContext.mWriteFdSet))
     {
         SendQueuedMessages(kIp6Msg);
     }

     if (FD_ISSET(mFd4, &aContext.mWriteFdSet))
     {
         SendQueuedMessages(kIp4Msg);
     }

     if (FD_ISSET(mFd6, &aContext.mReadFdSet))
     {
         ReceiveMessage(kIp6Msg);
     }

     if (FD_ISSET(mFd4, &aContext.mReadFdSet))
     {
         ReceiveMessage(kIp4Msg);
     }

 exit:
     return;
 }

 otError MdnsSocket::SetListeningEnabled(otInstance *aInstance, bool aEnable, uint32_t aInfraIfIndex)
 {
     otError error = OT_ERROR_NONE;

     VerifyOrExit(aEnable != mEnabled);
     mInstance = aInstance;

     if (aEnable)
     {
         error = Enable(aInfraIfIndex);
     }
     else
     {
         Disable(aInfraIfIndex);
     }

 exit:
     return error;
 }

 otError MdnsSocket::Enable(uint32_t aInfraIfIndex)
 {
     otError error;

     SuccessOrExit(error = OpenIp4Socket(aInfraIfIndex));
     SuccessOrExit(error = JoinOrLeaveIp4MulticastGroup(/* aJoin */ true, aInfraIfIndex));

     SuccessOrExit(error = OpenIp6Socket(aInfraIfIndex));
     SuccessOrExit(error = JoinOrLeaveIp6MulticastGroup(/* aJoin */ true, aInfraIfIndex));

     mEnabled      = true;
     mInfraIfIndex = aInfraIfIndex;

     LogInfo("Enabled");

 exit:
     if (error != OT_ERROR_NONE)
     {
         CloseIp4Socket();
         CloseIp6Socket();
     }

     return error;
 }

 void MdnsSocket::Disable(uint32_t aInfraIfIndex)
 {
     ClearTxQueue();

     IgnoreError(JoinOrLeaveIp4MulticastGroup(/* aJoin */ false, aInfraIfIndex));
     IgnoreError(JoinOrLeaveIp6MulticastGroup(/* aJoin */ false, aInfraIfIndex));
     CloseIp4Socket();
     CloseIp6Socket();

     mEnabled = false;

     LogInfo("Disabled");
 }

 void MdnsSocket::SendMulticast(otMessage *aMessage, uint32_t aInfraIfIndex)
 {
     Metadata metadata;
     uint16_t length;

     VerifyOrExit(mEnabled);
     VerifyOrExit(aInfraIfIndex == mInfraIfIndex);

     length = otMessageGetLength(aMessage);

     if (length > kMaxMessageLength)
     {
         LogWarn("Multicast msg length %u is longer than max %u", length, kMaxMessageLength);
         ExitNow();
     }

     metadata.mIp6Address = mMulticastIp6Address;
     metadata.mIp6Port    = kMdnsPort;
     metadata.mIp4Address = mMulticastIp4Address;
     metadata.mIp4Port    = kMdnsPort;

     SuccessOrExit(otMessageAppend(aMessage, &metadata, sizeof(Metadata)));

     mPendingIp4Tx++;
     mPendingIp6Tx++;

     otMessageQueueEnqueue(&mTxQueue, aMessage);
     aMessage = NULL;

 exit:
     if (aMessage != NULL)
     {
         otMessageFree(aMessage);
     }
 }

 void MdnsSocket::SendUnicast(otMessage *aMessage, const otPlatMdnsAddressInfo *aAddress)
 {
     bool     isIp4 = false;
     Metadata metadata;
     uint16_t length;

     VerifyOrExit(mEnabled);
     VerifyOrExit(aAddress->mInfraIfIndex == mInfraIfIndex);

     length = otMessageGetLength(aMessage);

     if (length > kMaxMessageLength)
     {
         LogWarn("Unicast msg length %u is longer than max %u", length, kMaxMessageLength);
         ExitNow();
     }

     memset(&metadata, 0, sizeof(Metadata));

     if (otIp4FromIp4MappedIp6Address(&aAddress->mAddress, &metadata.mIp4Address) == OT_ERROR_NONE)
     {
         isIp4             = true;
         metadata.mIp4Port = aAddress->mPort;
         metadata.mIp6Port = 0;
     }
     else
     {
         metadata.mIp6Address = aAddress->mAddress;
         metadata.mIp4Port    = 0;
         metadata.mIp6Port    = aAddress->mPort;
     }

     SuccessOrExit(otMessageAppend(aMessage, &metadata, sizeof(Metadata)));

     if (isIp4)
     {
         mPendingIp4Tx++;
     }
     else
     {
         mPendingIp6Tx++;
     }

     otMessageQueueEnqueue(&mTxQueue, aMessage);
     aMessage = NULL;

 exit:
     if (aMessage != NULL)
     {
         otMessageFree(aMessage);
     }
 }

 void MdnsSocket::ClearTxQueue(void)
 {
     otMessage *message;

     while ((message = otMessageQueueGetHead(&mTxQueue)) != NULL)
     {
         otMessageQueueDequeue(&mTxQueue, message);
         otMessageFree(message);
     }

     mPendingIp4Tx = 0;
     mPendingIp6Tx = 0;
 }

 void MdnsSocket::SendQueuedMessages(MsgType aMsgType)
 {
     switch (aMsgType)
     {
     case kIp6Msg:
         VerifyOrExit(mPendingIp6Tx > 0);
         break;
     case kIp4Msg:
         VerifyOrExit(mPendingIp4Tx > 0);
         break;
     }

     for (otMessage *message = otMessageQueueGetHead(&mTxQueue); message != NULL;
          message            = otMessageQueueGetNext(&mTxQueue, message))
     {
         bool                isTxPending = false;
         uint16_t            length;
         uint16_t            offset;
         int                 bytesSent;
         Metadata            metadata;
         uint8_t             buffer[kMaxMessageLength];
         struct sockaddr_in6 addr6;
         struct sockaddr_in  addr;

         length = otMessageGetLength(message);

         offset = length - sizeof(Metadata);
         length -= sizeof(Metadata);

         otMessageRead(message, offset, &metadata, sizeof(Metadata));

         switch (aMsgType)
         {
         case kIp6Msg:
             isTxPending = (metadata.mIp6Port != 0);
             break;
         case kIp4Msg:
             isTxPending = (metadata.mIp4Port != 0);
             break;
         }

         if (!isTxPending)
         {
             continue;
         }

         otMessageRead(message, 0, buffer, length);

         switch (aMsgType)
         {
         case kIp6Msg:
             memset(&addr6, 0, sizeof(addr6));
             addr6.sin6_family = AF_INET6;
             addr6.sin6_port   = htons(metadata.mIp6Port);
             CopyIp6AddressTo(metadata.mIp6Address, &addr6.sin6_addr);
             bytesSent = sendto(mFd6, buffer, length, 0, reinterpret_cast<struct sockaddr *>(&addr6), sizeof(addr6));
             VerifyOrExit(bytesSent == length);
             metadata.mIp6Port = 0;
             mPendingIp6Tx--;
             break;

         case kIp4Msg:
             memset(&addr, 0, sizeof(addr));
             addr.sin_family = AF_INET;
             addr.sin_port   = htons(metadata.mIp4Port);
             memcpy(&addr.sin_addr.s_addr, &metadata.mIp4Address, sizeof(otIp4Address));
             bytesSent = sendto(mFd4, buffer, length, 0, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr));
             VerifyOrExit(bytesSent == length);
             metadata.mIp4Port = 0;
             mPendingIp4Tx--;
             break;
         }

         if (metadata.CanFreeMessage())
         {
             otMessageQueueDequeue(&mTxQueue, message);
             otMessageFree(message);
         }
         else
         {
             otMessageWrite(message, offset, &metadata, sizeof(Metadata));
         }
     }

 exit:
     return;
 }

 void MdnsSocket::ReceiveMessage(MsgType aMsgType)
 {
     otMessage            *message = nullptr;
     uint8_t               buffer[kMaxMessageLength];
     otPlatMdnsAddressInfo addrInfo;
     uint16_t              length = 0;
     struct sockaddr_in6   sockaddr6;
     struct sockaddr_in    sockaddr;
     socklen_t             len = sizeof(sockaddr6);
     ssize_t               rval;

     memset(&addrInfo, 0, sizeof(addrInfo));

     switch (aMsgType)
     {
     case kIp6Msg:
         len = sizeof(sockaddr6);
         memset(&sockaddr6, 0, sizeof(sockaddr6));
         rval = recvfrom(mFd6, reinterpret_cast<char *>(&buffer), sizeof(buffer), 0,
                         reinterpret_cast<struct sockaddr *>(&sockaddr6), &len);
         VerifyOrExit(rval >= 0, LogCrit("recvfrom() for IPv6 socket failed, errno: %s", strerror(errno)));
         length = static_cast<uint16_t>(rval);
         ReadIp6AddressFrom(&sockaddr6.sin6_addr, addrInfo.mAddress);
         break;

     case kIp4Msg:
         len = sizeof(sockaddr);
         memset(&sockaddr, 0, sizeof(sockaddr));
         rval = recvfrom(mFd4, reinterpret_cast<char *>(&buffer), sizeof(buffer), 0,
                         reinterpret_cast<struct sockaddr *>(&sockaddr), &len);
         VerifyOrExit(rval >= 0, LogCrit("recvfrom() for IPv4 socket failed, errno: %s", strerror(errno)));
         length = static_cast<uint16_t>(rval);
         otIp4ToIp4MappedIp6Address((otIp4Address *)(&sockaddr.sin_addr.s_addr), &addrInfo.mAddress);
         break;
     }

     VerifyOrExit(length > 0);

     message = otIp6NewMessage(mInstance, nullptr);
     VerifyOrExit(message != nullptr);
     SuccessOrExit(otMessageAppend(message, buffer, length));

     addrInfo.mPort         = kMdnsPort;
     addrInfo.mInfraIfIndex = mInfraIfIndex;

     otPlatMdnsHandleReceive(mInstance, message, /* aInUnicast */ false, &addrInfo);
     message = nullptr;

 exit:
     if (message != nullptr)
     {
         otMessageFree(message);
     }
 }

 //---------------------------------------------------------------------------------------------------------------------
 // Socket helpers

 otError MdnsSocket::OpenIp4Socket(uint32_t aInfraIfIndex)
 {
     otError            error = OT_ERROR_FAILED;
     struct sockaddr_in addr;
     int                fd;

     fd = socket(AF_INET, SOCK_DGRAM, 0);
     VerifyOrExit(fd >= 0, LogCrit("Failed to create IPv4 socket"));

 #ifdef __linux__
     {
         char        nameBuffer[IF_NAMESIZE];
         const char *ifname;

         ifname = if_indextoname(aInfraIfIndex, nameBuffer);
         VerifyOrExit(ifname != NULL, LogCrit("if_indextoname() failed"));

         error = SetSocketOptionValue(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname), "SO_BINDTODEVICE");
         SuccessOrExit(error);
     }
 #else
     {
         int ifindex = static_cast<int>(aInfraIfIndex);

         SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IP, IP_BOUND_IF, ifindex, "IP_BOUND_IF"));
     }
 #endif

     SuccessOrExit(error = SetSocketOption<uint8_t>(fd, IPPROTO_IP, IP_MULTICAST_TTL, 255, "IP_MULTICAST_TTL"));
     SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IP, IP_TTL, 255, "IP_TTL"));
     SuccessOrExit(error = SetSocketOption<uint8_t>(fd, IPPROTO_IP, IP_MULTICAST_LOOP, 1, "IP_MULTICAST_LOOP"));
     SuccessOrExit(error = SetReuseAddrPortOptions(fd));

     {
         struct ip_mreqn mreqn;

         memset(&mreqn, 0, sizeof(mreqn));
         mreqn.imr_multiaddr.s_addr = inet_addr("224.0.0.251");
         mreqn.imr_ifindex          = aInfraIfIndex;

         SuccessOrExit(
             error = SetSocketOptionValue(fd, IPPROTO_IP, IP_MULTICAST_IF, &mreqn, sizeof(mreqn), "IP_MULTICAST_IF"));
     }

     memset(&addr, 0, sizeof(addr));
     addr.sin_family      = AF_INET;
     addr.sin_addr.s_addr = htonl(INADDR_ANY);
     addr.sin_port        = htons(kMdnsPort);

     if (bind(fd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) < 0)
     {
         LogCrit("bind() to mDNS port for IPv4 socket failed, errno: %s", strerror(errno));
         error = OT_ERROR_FAILED;
         ExitNow();
     }

     mFd4 = fd;

     LogInfo("Successfully opened IPv4 socket");

 exit:
     return error;
 }

 otError MdnsSocket::JoinOrLeaveIp4MulticastGroup(bool aJoin, uint32_t aInfraIfIndex)
 {
     struct ip_mreqn mreqn;

     memset(&mreqn, 0, sizeof(mreqn));
     memcpy(&mreqn.imr_multiaddr.s_addr, &mMulticastIp4Address, sizeof(otIp4Address));
     mreqn.imr_ifindex = aInfraIfIndex;

     if (aJoin)
     {
         // Suggested workaround for netif not dropping
         // a previous multicast membership.
         setsockopt(mFd4, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreqn, sizeof(mreqn));
     }

     return SetSocketOption(mFd4, IPPROTO_IP, aJoin ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP, mreqn,
                            "IP_ADD/DROP_MEMBERSHIP");
 }

 void MdnsSocket::CloseIp4Socket(void)
 {
     if (mFd4 >= 0)
     {
         close(mFd4);
         mFd4 = -1;
     }
 }

 otError MdnsSocket::OpenIp6Socket(uint32_t aInfraIfIndex)
 {
     otError             error = OT_ERROR_FAILED;
     struct sockaddr_in6 addr6;
     int                 fd;
     int                 ifindex = static_cast<int>(aInfraIfIndex);

     fd = socket(AF_INET6, SOCK_DGRAM, 0);
     VerifyOrExit(fd >= 0, LogCrit("Failed to create IPv4 socket"));

 #ifdef __linux__
     {
         char        nameBuffer[IF_NAMESIZE];
         const char *ifname;

         ifname = if_indextoname(aInfraIfIndex, nameBuffer);
         VerifyOrExit(ifname != NULL, LogCrit("if_indextoname() failed"));

         error = SetSocketOptionValue(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname), "SO_BINDTODEVICE");
         SuccessOrExit(error);
     }
 #else
     {
         SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_BOUND_IF, ifindex, "IPV6_BOUND_IF"));
     }
 #endif

     SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, 255, "IPV6_MULTICAST_HOPS"));
     SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, 255, "IPV6_UNICAST_HOPS"));
     SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_V6ONLY, 1, "IPV6_V6ONLY"));
     SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, ifindex, "IPV6_MULTICAST_IF"));
     SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, 1, "IPV6_MULTICAST_LOOP"));
     SuccessOrExit(error = SetReuseAddrPortOptions(fd));

     memset(&addr6, 0, sizeof(addr6));
     addr6.sin6_family = AF_INET6;
     addr6.sin6_port   = htons(kMdnsPort);

     if (bind(fd, reinterpret_cast<struct sockaddr *>(&addr6), sizeof(addr6)) < 0)
     {
         LogCrit("bind() to mDNS port for IPv6 socket failed, errno: %s", strerror(errno));
         error = OT_ERROR_FAILED;
         ExitNow();
     }

     mFd6 = fd;

     LogInfo("Successfully opened IPv6 socket");

 exit:
     return error;
 }

 #ifndef IPV6_ADD_MEMBERSHIP
 #ifdef IPV6_JOIN_GROUP
 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
 #endif
 #endif

 #ifndef IPV6_DROP_MEMBERSHIP
 #ifdef IPV6_LEAVE_GROUP
 #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
 #endif
 #endif

 otError MdnsSocket::JoinOrLeaveIp6MulticastGroup(bool aJoin, uint32_t aInfraIfIndex)
 {
     struct ipv6_mreq mreq6;

     memset(&mreq6, 0, sizeof(mreq6));
     Ip6Utils::CopyIp6AddressTo(mMulticastIp6Address, &mreq6.ipv6mr_multiaddr);

     mreq6.ipv6mr_interface = static_cast<int>(aInfraIfIndex);

     if (aJoin)
     {
         // Suggested workaround for netif not dropping
         // a previous multicast membership.
         setsockopt(mFd6, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6));
     }

     return SetSocketOptionValue(mFd6, IPPROTO_IPV6, aJoin ? IPV6_ADD_MEMBERSHIP : IPV6_DROP_MEMBERSHIP, &mreq6,
                                 sizeof(mreq6), "IP6_ADD/DROP_MEMBERSHIP");
 }

 void MdnsSocket::CloseIp6Socket(void)
 {
     if (mFd6 >= 0)
     {
         close(mFd6);
         mFd6 = -1;
     }
 }

 otError MdnsSocket::SetReuseAddrPortOptions(int aFd)
 {
     otError error;

     SuccessOrExit(error = SetSocketOption<int>(aFd, SOL_SOCKET, SO_REUSEADDR, 1, "SO_REUSEADDR"));
     SuccessOrExit(error = SetSocketOption<int>(aFd, SOL_SOCKET, SO_REUSEPORT, 1, "SO_REUSEPORT"));

 exit:
     return error;
 }

 otError MdnsSocket::SetSocketOptionValue(int         aFd,
                                          int         aLevel,
                                          int         aOption,
                                          const void *aValue,
                                          uint32_t    aValueLength,
                                          const char *aOptionName)
 {
     otError error = OT_ERROR_NONE;

     if (setsockopt(aFd, aLevel, aOption, aValue, aValueLength) != 0)
     {
         error = OT_ERROR_FAILED;
         LogCrit("Failed to setsockopt(%s) - errno: %s", aOptionName, strerror(errno));
     }

     return error;
 }

 } // namespace Posix
 } // namespace ot

 #endif // OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
	/*
	* Copyright (c) 2024, 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.
	*/

	#include "mdns_socket.hpp"

	#if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE

	#include <arpa/inet.h>
	#include <errno.h>
	#include <net/if.h>
	#include <netinet/in.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include "ip6_utils.hpp"
	#include "platform-posix.h"
	#include "common/code_utils.hpp"

	extern "C" otError otPlatMdnsSetListeningEnabled(otInstance *aInstance, bool aEnable, uint32_t aInfraIfIndex)
	{
	return ot::Posix::MdnsSocket::Get().SetListeningEnabled(aInstance, aEnable, aInfraIfIndex);
	}

	extern "C" void otPlatMdnsSendMulticast(otInstance aInstance, otMessage aMessage, uint32_t aInfraIfIndex)
	{
	OT_UNUSED_VARIABLE(aInstance);
	return ot::Posix::MdnsSocket::Get().SendMulticast(aMessage, aInfraIfIndex);
	}

	extern "C" void otPlatMdnsSendUnicast(otInstance aInstance, otMessage aMessage, const otPlatMdnsAddressInfo *aAddress)
	{
	OT_UNUSED_VARIABLE(aInstance);
	return ot::Posix::MdnsSocket::Get().SendUnicast(aMessage, aAddress);
	}

	namespace ot {
	namespace Posix {

	using namespace ot::Posix::Ip6Utils;

	const char MdnsSocket::kLogModuleName[] = "MdnsSocket";

	MdnsSocket &MdnsSocket::Get(void)
	{
	static MdnsSocket sInstance;

	return sInstance;
	}

	void MdnsSocket::Init(void)
	{
	mEnabled = false;
	mInfraIfIndex = 0;
	mFd6 = -1;
	mFd4 = -1;
	mPendingIp6Tx = 0;
	mPendingIp4Tx = 0;

	// mDNS multicast IPv6 address "ff02::fb"
	memset(&mMulticastIp6Address, 0, sizeof(otIp6Address));
	mMulticastIp6Address.mFields.m8[0] = 0xff;
	mMulticastIp6Address.mFields.m8[1] = 0x02;
	mMulticastIp6Address.mFields.m8[15] = 0xfb;

	// mDNS multicast IPv4 address "224.0.0.251"
	memset(&mMulticastIp4Address, 0, sizeof(otIp4Address));
	mMulticastIp4Address.mFields.m8[0] = 224;
	mMulticastIp4Address.mFields.m8[3] = 251;

	memset(&mTxQueue, 0, sizeof(mTxQueue));
	}

	void MdnsSocket::SetUp(void)
	{
	otMessageQueueInit(&mTxQueue);
	Mainloop::Manager::Get().Add(*this);
	}

	void MdnsSocket::TearDown(void)
	{
	Mainloop::Manager::Get().Remove(*this);

	if (mEnabled)
	{
	ClearTxQueue();
	mEnabled = false;
	}
	}

	void MdnsSocket::Deinit(void)
	{
	CloseIp4Socket();
	CloseIp6Socket();
	}

	void MdnsSocket::Update(otSysMainloopContext &aContext)
	{
	VerifyOrExit(mEnabled);

	FD_SET(mFd6, &aContext.mReadFdSet);
	FD_SET(mFd4, &aContext.mReadFdSet);

	if (mPendingIp6Tx > 0)
	{
	FD_SET(mFd6, &aContext.mWriteFdSet);
	}

	if (mPendingIp4Tx > 0)
	{
	FD_SET(mFd4, &aContext.mWriteFdSet);
	}

	if (aContext.mMaxFd < mFd6)
	{
	aContext.mMaxFd = mFd6;
	}

	if (aContext.mMaxFd < mFd4)
	{
	aContext.mMaxFd = mFd4;
	}

	exit:
	return;
	}

	void MdnsSocket::Process(const otSysMainloopContext &aContext)
	{
	VerifyOrExit(mEnabled);

	if (FD_ISSET(mFd6, &aContext.mWriteFdSet))
	{
	SendQueuedMessages(kIp6Msg);
	}

	if (FD_ISSET(mFd4, &aContext.mWriteFdSet))
	{
	SendQueuedMessages(kIp4Msg);
	}

	if (FD_ISSET(mFd6, &aContext.mReadFdSet))
	{
	ReceiveMessage(kIp6Msg);
	}

	if (FD_ISSET(mFd4, &aContext.mReadFdSet))
	{
	ReceiveMessage(kIp4Msg);
	}

	exit:
	return;
	}

	otError MdnsSocket::SetListeningEnabled(otInstance *aInstance, bool aEnable, uint32_t aInfraIfIndex)
	{
	otError error = OT_ERROR_NONE;

	VerifyOrExit(aEnable != mEnabled);
	mInstance = aInstance;

	if (aEnable)
	{
	error = Enable(aInfraIfIndex);
	}
	else
	{
	Disable(aInfraIfIndex);
	}

	exit:
	return error;
	}

	otError MdnsSocket::Enable(uint32_t aInfraIfIndex)
	{
	otError error;

	SuccessOrExit(error = OpenIp4Socket(aInfraIfIndex));
	SuccessOrExit(error = JoinOrLeaveIp4MulticastGroup(/* aJoin */ true, aInfraIfIndex));

	SuccessOrExit(error = OpenIp6Socket(aInfraIfIndex));
	SuccessOrExit(error = JoinOrLeaveIp6MulticastGroup(/* aJoin */ true, aInfraIfIndex));

	mEnabled = true;
	mInfraIfIndex = aInfraIfIndex;

	LogInfo("Enabled");

	exit:
	if (error != OT_ERROR_NONE)
	{
	CloseIp4Socket();
	CloseIp6Socket();
	}

	return error;
	}

	void MdnsSocket::Disable(uint32_t aInfraIfIndex)
	{
	ClearTxQueue();

	IgnoreError(JoinOrLeaveIp4MulticastGroup(/* aJoin */ false, aInfraIfIndex));
	IgnoreError(JoinOrLeaveIp6MulticastGroup(/* aJoin */ false, aInfraIfIndex));
	CloseIp4Socket();
	CloseIp6Socket();

	mEnabled = false;

	LogInfo("Disabled");
	}

	void MdnsSocket::SendMulticast(otMessage *aMessage, uint32_t aInfraIfIndex)
	{
	Metadata metadata;
	uint16_t length;

	VerifyOrExit(mEnabled);
	VerifyOrExit(aInfraIfIndex == mInfraIfIndex);

	length = otMessageGetLength(aMessage);

	if (length > kMaxMessageLength)
	{
	LogWarn("Multicast msg length %u is longer than max %u", length, kMaxMessageLength);
	ExitNow();
	}

	metadata.mIp6Address = mMulticastIp6Address;
	metadata.mIp6Port = kMdnsPort;
	metadata.mIp4Address = mMulticastIp4Address;
	metadata.mIp4Port = kMdnsPort;

	SuccessOrExit(otMessageAppend(aMessage, &metadata, sizeof(Metadata)));

	mPendingIp4Tx++;
	mPendingIp6Tx++;

	otMessageQueueEnqueue(&mTxQueue, aMessage);
	aMessage = NULL;

	exit:
	if (aMessage != NULL)
	{
	otMessageFree(aMessage);
	}
	}

	void MdnsSocket::SendUnicast(otMessage aMessage, const otPlatMdnsAddressInfo aAddress)
	{
	bool isIp4 = false;
	Metadata metadata;
	uint16_t length;

	VerifyOrExit(mEnabled);
	VerifyOrExit(aAddress->mInfraIfIndex == mInfraIfIndex);

	length = otMessageGetLength(aMessage);

	if (length > kMaxMessageLength)
	{
	LogWarn("Unicast msg length %u is longer than max %u", length, kMaxMessageLength);
	ExitNow();
	}

	memset(&metadata, 0, sizeof(Metadata));

	if (otIp4FromIp4MappedIp6Address(&aAddress->mAddress, &metadata.mIp4Address) == OT_ERROR_NONE)
	{
	isIp4 = true;
	metadata.mIp4Port = aAddress->mPort;
	metadata.mIp6Port = 0;
	}
	else
	{
	metadata.mIp6Address = aAddress->mAddress;
	metadata.mIp4Port = 0;
	metadata.mIp6Port = aAddress->mPort;
	}

	SuccessOrExit(otMessageAppend(aMessage, &metadata, sizeof(Metadata)));

	if (isIp4)
	{
	mPendingIp4Tx++;
	}
	else
	{
	mPendingIp6Tx++;
	}

	otMessageQueueEnqueue(&mTxQueue, aMessage);
	aMessage = NULL;

	exit:
	if (aMessage != NULL)
	{
	otMessageFree(aMessage);
	}
	}

	void MdnsSocket::ClearTxQueue(void)
	{
	otMessage *message;

	while ((message = otMessageQueueGetHead(&mTxQueue)) != NULL)
	{
	otMessageQueueDequeue(&mTxQueue, message);
	otMessageFree(message);
	}

	mPendingIp4Tx = 0;
	mPendingIp6Tx = 0;
	}

	void MdnsSocket::SendQueuedMessages(MsgType aMsgType)
	{
	switch (aMsgType)
	{
	case kIp6Msg:
	VerifyOrExit(mPendingIp6Tx > 0);
	break;
	case kIp4Msg:
	VerifyOrExit(mPendingIp4Tx > 0);
	break;
	}

	for (otMessage *message = otMessageQueueGetHead(&mTxQueue); message != NULL;
	message = otMessageQueueGetNext(&mTxQueue, message))
	{
	bool isTxPending = false;
	uint16_t length;
	uint16_t offset;
	int bytesSent;
	Metadata metadata;
	uint8_t buffer[kMaxMessageLength];
	struct sockaddr_in6 addr6;
	struct sockaddr_in addr;

	length = otMessageGetLength(message);

	offset = length - sizeof(Metadata);
	length -= sizeof(Metadata);

	otMessageRead(message, offset, &metadata, sizeof(Metadata));

	switch (aMsgType)
	{
	case kIp6Msg:
	isTxPending = (metadata.mIp6Port != 0);
	break;
	case kIp4Msg:
	isTxPending = (metadata.mIp4Port != 0);
	break;
	}

	if (!isTxPending)
	{
	continue;
	}

	otMessageRead(message, 0, buffer, length);

	switch (aMsgType)
	{
	case kIp6Msg:
	memset(&addr6, 0, sizeof(addr6));
	addr6.sin6_family = AF_INET6;
	addr6.sin6_port = htons(metadata.mIp6Port);
	CopyIp6AddressTo(metadata.mIp6Address, &addr6.sin6_addr);
	bytesSent = sendto(mFd6, buffer, length, 0, reinterpret_cast<struct sockaddr *>(&addr6), sizeof(addr6));
	VerifyOrExit(bytesSent == length);
	metadata.mIp6Port = 0;
	mPendingIp6Tx--;
	break;

	case kIp4Msg:
	memset(&addr, 0, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(metadata.mIp4Port);
	memcpy(&addr.sin_addr.s_addr, &metadata.mIp4Address, sizeof(otIp4Address));
	bytesSent = sendto(mFd4, buffer, length, 0, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr));
	VerifyOrExit(bytesSent == length);
	metadata.mIp4Port = 0;
	mPendingIp4Tx--;
	break;
	}

	if (metadata.CanFreeMessage())
	{
	otMessageQueueDequeue(&mTxQueue, message);
	otMessageFree(message);
	}
	else
	{
	otMessageWrite(message, offset, &metadata, sizeof(Metadata));
	}
	}

	exit:
	return;
	}

	void MdnsSocket::ReceiveMessage(MsgType aMsgType)
	{
	otMessage *message = nullptr;
	uint8_t buffer[kMaxMessageLength];
	otPlatMdnsAddressInfo addrInfo;
	uint16_t length = 0;
	struct sockaddr_in6 sockaddr6;
	struct sockaddr_in sockaddr;
	socklen_t len = sizeof(sockaddr6);
	ssize_t rval;

	memset(&addrInfo, 0, sizeof(addrInfo));

	switch (aMsgType)
	{
	case kIp6Msg:
	len = sizeof(sockaddr6);
	memset(&sockaddr6, 0, sizeof(sockaddr6));
	rval = recvfrom(mFd6, reinterpret_cast<char *>(&buffer), sizeof(buffer), 0,
	reinterpret_cast<struct sockaddr *>(&sockaddr6), &len);
	VerifyOrExit(rval >= 0, LogCrit("recvfrom() for IPv6 socket failed, errno: %s", strerror(errno)));
	length = static_cast<uint16_t>(rval);
	ReadIp6AddressFrom(&sockaddr6.sin6_addr, addrInfo.mAddress);
	break;

	case kIp4Msg:
	len = sizeof(sockaddr);
	memset(&sockaddr, 0, sizeof(sockaddr));
	rval = recvfrom(mFd4, reinterpret_cast<char *>(&buffer), sizeof(buffer), 0,
	reinterpret_cast<struct sockaddr *>(&sockaddr), &len);
	VerifyOrExit(rval >= 0, LogCrit("recvfrom() for IPv4 socket failed, errno: %s", strerror(errno)));
	length = static_cast<uint16_t>(rval);
	otIp4ToIp4MappedIp6Address((otIp4Address *)(&sockaddr.sin_addr.s_addr), &addrInfo.mAddress);
	break;
	}

	VerifyOrExit(length > 0);

	message = otIp6NewMessage(mInstance, nullptr);
	VerifyOrExit(message != nullptr);
	SuccessOrExit(otMessageAppend(message, buffer, length));

	addrInfo.mPort = kMdnsPort;
	addrInfo.mInfraIfIndex = mInfraIfIndex;

	otPlatMdnsHandleReceive(mInstance, message, /* aInUnicast */ false, &addrInfo);
	message = nullptr;

	exit:
	if (message != nullptr)
	{
	otMessageFree(message);
	}
	}

	//---------------------------------------------------------------------------------------------------------------------
	// Socket helpers

	otError MdnsSocket::OpenIp4Socket(uint32_t aInfraIfIndex)
	{
	otError error = OT_ERROR_FAILED;
	struct sockaddr_in addr;
	int fd;

	fd = socket(AF_INET, SOCK_DGRAM, 0);
	VerifyOrExit(fd >= 0, LogCrit("Failed to create IPv4 socket"));

	#ifdef __linux__
	{
	char nameBuffer[IF_NAMESIZE];
	const char *ifname;

	ifname = if_indextoname(aInfraIfIndex, nameBuffer);
	VerifyOrExit(ifname != NULL, LogCrit("if_indextoname() failed"));

	error = SetSocketOptionValue(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname), "SO_BINDTODEVICE");
	SuccessOrExit(error);
	}
	#else
	{
	int ifindex = static_cast<int>(aInfraIfIndex);

	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IP, IP_BOUND_IF, ifindex, "IP_BOUND_IF"));
	}
	#endif

	SuccessOrExit(error = SetSocketOption<uint8_t>(fd, IPPROTO_IP, IP_MULTICAST_TTL, 255, "IP_MULTICAST_TTL"));
	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IP, IP_TTL, 255, "IP_TTL"));
	SuccessOrExit(error = SetSocketOption<uint8_t>(fd, IPPROTO_IP, IP_MULTICAST_LOOP, 1, "IP_MULTICAST_LOOP"));
	SuccessOrExit(error = SetReuseAddrPortOptions(fd));

	{
	struct ip_mreqn mreqn;

	memset(&mreqn, 0, sizeof(mreqn));
	mreqn.imr_multiaddr.s_addr = inet_addr("224.0.0.251");
	mreqn.imr_ifindex = aInfraIfIndex;

	SuccessOrExit(
	error = SetSocketOptionValue(fd, IPPROTO_IP, IP_MULTICAST_IF, &mreqn, sizeof(mreqn), "IP_MULTICAST_IF"));
	}

	memset(&addr, 0, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = htonl(INADDR_ANY);
	addr.sin_port = htons(kMdnsPort);

	if (bind(fd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) < 0)
	{
	LogCrit("bind() to mDNS port for IPv4 socket failed, errno: %s", strerror(errno));
	error = OT_ERROR_FAILED;
	ExitNow();
	}

	mFd4 = fd;

	LogInfo("Successfully opened IPv4 socket");

	exit:
	return error;
	}

	otError MdnsSocket::JoinOrLeaveIp4MulticastGroup(bool aJoin, uint32_t aInfraIfIndex)
	{
	struct ip_mreqn mreqn;

	memset(&mreqn, 0, sizeof(mreqn));
	memcpy(&mreqn.imr_multiaddr.s_addr, &mMulticastIp4Address, sizeof(otIp4Address));
	mreqn.imr_ifindex = aInfraIfIndex;

	if (aJoin)
	{
	// Suggested workaround for netif not dropping
	// a previous multicast membership.
	setsockopt(mFd4, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreqn, sizeof(mreqn));
	}

	return SetSocketOption(mFd4, IPPROTO_IP, aJoin ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP, mreqn,
	"IP_ADD/DROP_MEMBERSHIP");
	}

	void MdnsSocket::CloseIp4Socket(void)
	{
	if (mFd4 >= 0)
	{
	close(mFd4);
	mFd4 = -1;
	}
	}

	otError MdnsSocket::OpenIp6Socket(uint32_t aInfraIfIndex)
	{
	otError error = OT_ERROR_FAILED;
	struct sockaddr_in6 addr6;
	int fd;
	int ifindex = static_cast<int>(aInfraIfIndex);

	fd = socket(AF_INET6, SOCK_DGRAM, 0);
	VerifyOrExit(fd >= 0, LogCrit("Failed to create IPv4 socket"));

	#ifdef __linux__
	{
	char nameBuffer[IF_NAMESIZE];
	const char *ifname;

	ifname = if_indextoname(aInfraIfIndex, nameBuffer);
	VerifyOrExit(ifname != NULL, LogCrit("if_indextoname() failed"));

	error = SetSocketOptionValue(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname), "SO_BINDTODEVICE");
	SuccessOrExit(error);
	}
	#else
	{
	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_BOUND_IF, ifindex, "IPV6_BOUND_IF"));
	}
	#endif

	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, 255, "IPV6_MULTICAST_HOPS"));
	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, 255, "IPV6_UNICAST_HOPS"));
	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_V6ONLY, 1, "IPV6_V6ONLY"));
	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, ifindex, "IPV6_MULTICAST_IF"));
	SuccessOrExit(error = SetSocketOption<int>(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, 1, "IPV6_MULTICAST_LOOP"));
	SuccessOrExit(error = SetReuseAddrPortOptions(fd));

	memset(&addr6, 0, sizeof(addr6));
	addr6.sin6_family = AF_INET6;
	addr6.sin6_port = htons(kMdnsPort);

	if (bind(fd, reinterpret_cast<struct sockaddr *>(&addr6), sizeof(addr6)) < 0)
	{
	LogCrit("bind() to mDNS port for IPv6 socket failed, errno: %s", strerror(errno));
	error = OT_ERROR_FAILED;
	ExitNow();
	}

	mFd6 = fd;

	LogInfo("Successfully opened IPv6 socket");

	exit:
	return error;
	}

	#ifndef IPV6_ADD_MEMBERSHIP
	#ifdef IPV6_JOIN_GROUP
	#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
	#endif
	#endif

	#ifndef IPV6_DROP_MEMBERSHIP
	#ifdef IPV6_LEAVE_GROUP
	#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
	#endif
	#endif

	otError MdnsSocket::JoinOrLeaveIp6MulticastGroup(bool aJoin, uint32_t aInfraIfIndex)
	{
	struct ipv6_mreq mreq6;

	memset(&mreq6, 0, sizeof(mreq6));
	Ip6Utils::CopyIp6AddressTo(mMulticastIp6Address, &mreq6.ipv6mr_multiaddr);

	mreq6.ipv6mr_interface = static_cast<int>(aInfraIfIndex);

	if (aJoin)
	{
	// Suggested workaround for netif not dropping
	// a previous multicast membership.
	setsockopt(mFd6, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6));
	}

	return SetSocketOptionValue(mFd6, IPPROTO_IPV6, aJoin ? IPV6_ADD_MEMBERSHIP : IPV6_DROP_MEMBERSHIP, &mreq6,
	sizeof(mreq6), "IP6_ADD/DROP_MEMBERSHIP");
	}

	void MdnsSocket::CloseIp6Socket(void)
	{
	if (mFd6 >= 0)
	{
	close(mFd6);
	mFd6 = -1;
	}
	}

	otError MdnsSocket::SetReuseAddrPortOptions(int aFd)
	{
	otError error;

	SuccessOrExit(error = SetSocketOption<int>(aFd, SOL_SOCKET, SO_REUSEADDR, 1, "SO_REUSEADDR"));
	SuccessOrExit(error = SetSocketOption<int>(aFd, SOL_SOCKET, SO_REUSEPORT, 1, "SO_REUSEPORT"));

	exit:
	return error;
	}

	otError MdnsSocket::SetSocketOptionValue(int aFd,
	int aLevel,
	int aOption,
	const void *aValue,
	uint32_t aValueLength,
	const char *aOptionName)
	{
	otError error = OT_ERROR_NONE;

	if (setsockopt(aFd, aLevel, aOption, aValue, aValueLength) != 0)
	{
	error = OT_ERROR_FAILED;
	LogCrit("Failed to setsockopt(%s) - errno: %s", aOptionName, strerror(errno));
	}

	return error;
	}

	} // namespace Posix
	} // namespace ot

	#endif // OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE