/*
 *
 *    Copyright (c) 2013-2017 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
 *      This file implements the <tt>nl::Inet::UDPEndPoint</tt>
 *      class, where the Nest Inet Layer encapsulates methods for
 *      interacting with UDP transport endpoints (SOCK_DGRAM sockets
 *      on Linux and BSD-derived systems) or LwIP UDP protocol
 *      control blocks, as the system is configured accordingly.
 *
 */

#define __APPLE_USE_RFC_3542

#include <string.h>

// TODO: remove me
#include <stdio.h>

#include <InetLayer/UDPEndPoint.h>
#include <InetLayer/InetLayer.h>
#include <InetLayer/InetFaultInjection.h>

#include <Weave/Support/CodeUtils.h>
#include <Weave/Support/logging/WeaveLogging.h>

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
#include <lwip/udp.h>
#include <lwip/tcpip.h>
#include <lwip/ip.h>
#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS
#include <sys/select.h>
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif // HAVE_SYS_SOCKET_H
#include <errno.h>
#include <unistd.h>
#include <net/if.h>
#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

// SOCK_CLOEXEC not defined on all platforms, e.g. iOS/MacOS:
#ifdef SOCK_CLOEXEC
#define SOCK_FLAGS SOCK_CLOEXEC
#else
#define SOCK_FLAGS 0
#endif

namespace nl {
namespace Inet {

using Weave::System::PacketBuffer;

Weave::System::ObjectPool<UDPEndPoint, INET_CONFIG_NUM_UDP_ENDPOINTS> UDPEndPoint::sPool;

INET_ERROR UDPEndPoint::Bind(IPAddressType addrType, IPAddress addr, uint16_t port, InterfaceId intfId)
{
    INET_ERROR res = INET_NO_ERROR;

    if (mState != kState_Ready && mState != kState_Bound)
        return INET_ERROR_INCORRECT_STATE;

    if (addr != IPAddress::Any && addr.Type() != kIPAddressType_Any && addr.Type() != addrType)
        return INET_ERROR_WRONG_ADDRESS_TYPE;

#if WEAVE_SYSTEM_CONFIG_USE_LWIP

    // Lock LwIP stack
    LOCK_TCPIP_CORE();

    // Make sure we have the appropriate type of PCB.
    res = GetPCB(addrType);

    // Bind the PCB to the specified address/port.
    if (res == INET_NO_ERROR)
    {
#if LWIP_VERSION_MAJOR > 1
        ip_addr_t ipAddr = addr.ToLwIPAddr();
        res = Weave::System::MapErrorLwIP(udp_bind(mUDP, &ipAddr, port));
#else // LWIP_VERSION_MAJOR <= 1
        if (addrType == kIPAddressType_IPv6)
        {
            ip6_addr_t ipv6Addr = addr.ToIPv6();
            res = Weave::System::MapErrorLwIP(udp_bind_ip6(mUDP, &ipv6Addr, port));
        }
#if INET_CONFIG_ENABLE_IPV4
        else if (addrType == kIPAddressType_IPv4)
        {
            ip4_addr_t ipv4Addr = addr.ToIPv4();
            res = Weave::System::MapErrorLwIP(udp_bind(mUDP, &ipv4Addr, port));
        }
#endif // INET_CONFIG_ENABLE_IPV4
        else
            res = INET_ERROR_WRONG_ADDRESS_TYPE;
#endif // LWIP_VERSION_MAJOR <= 1
    }

    if (res == INET_NO_ERROR)
    {
        if (!IsInterfaceIdPresent(intfId))
            mUDP->intf_filter = NULL;
        else
        {
            struct netif *p;
            for (p = netif_list; p != NULL && p != intfId; p = p->next);
            if (p == NULL)
                res = INET_ERROR_UNKNOWN_INTERFACE;
            else
                mUDP->intf_filter = p;
        }
    }

    // Unlock LwIP stack
    UNLOCK_TCPIP_CORE();

#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    // Make sure we have the appropriate type of socket.
    res = GetSocket(addrType);

    if (res == INET_NO_ERROR)
    {
        if (addrType == kIPAddressType_IPv6)
        {
            struct sockaddr_in6 sa;
            memset(&sa, 0, sizeof(sa));
            sa.sin6_family = AF_INET6;
            sa.sin6_port = htons(port);
            sa.sin6_flowinfo = 0;
            sa.sin6_addr = addr.ToIPv6();
            sa.sin6_scope_id = intfId;

            if (res == INET_NO_ERROR && bind(mSocket, (const sockaddr *) &sa, (unsigned) sizeof(sa)) != 0)
                res = Weave::System::MapErrorPOSIX(errno);

            // Instruct the kernel that any messages to multicast destinations should be
            // sent down the interface specified by the caller.
#ifdef IPV6_MULTICAST_IF
            if (res == INET_NO_ERROR)
                setsockopt(mSocket, IPPROTO_IPV6, IPV6_MULTICAST_IF, &intfId, sizeof(intfId));
#endif // defined(IPV6_MULTICAST_IF)
        }
#if INET_CONFIG_ENABLE_IPV4
        else if (addrType == kIPAddressType_IPv4)
        {
            struct sockaddr_in sa;
            memset(&sa, 0, sizeof(sa));
            sa.sin_family = AF_INET;
            sa.sin_port = htons(port);
            sa.sin_addr = addr.ToIPv4();

            if (bind(mSocket, (const sockaddr *) &sa, (unsigned) sizeof(sa)) != 0)
                res = Weave::System::MapErrorPOSIX(errno);

            // Instruct the kernel that any messages to multicast destinations should be
            // sent down the interface to which the specified IPv4 address is bound.
#ifdef IP_MULTICAST_IF
            if (res == INET_NO_ERROR)
                setsockopt(mSocket, IPPROTO_IP, IP_MULTICAST_IF, &sa, sizeof(sa));
#endif // defined(IP_MULTICAST_IF)
        }
#endif // INET_CONFIG_ENABLE_IPV4
        else
            res = INET_ERROR_WRONG_ADDRESS_TYPE;

        if (res == INET_NO_ERROR)
        {
            mBoundPort = port;
            mBoundIntfId = intfId;
        }
    }

#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    if (res == INET_NO_ERROR)
        mState = kState_Bound;

    return res;
}

INET_ERROR UDPEndPoint::Listen()
{
    INET_ERROR res = INET_NO_ERROR;

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS
    Weave::System::Layer& lSystemLayer = SystemLayer();
#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    if (mState == kState_Listening)
        return INET_NO_ERROR;

    if (mState != kState_Bound)
        return INET_ERROR_INCORRECT_STATE;

#if WEAVE_SYSTEM_CONFIG_USE_LWIP

    // Lock LwIP stack
    LOCK_TCPIP_CORE();

#if LWIP_VERSION_MAJOR > 1
    udp_recv(mUDP, LwIPReceiveUDPMessage, this);
#else // LWIP_VERSION_MAJOR <= 1
    if (PCB_ISIPV6(mUDP))
        udp_recv_ip6(mUDP, LwIPReceiveUDPMessage, this);
    else
        udp_recv(mUDP, LwIPReceiveUDPMessage, this);
#endif // LWIP_VERSION_MAJOR <= 1

    // Unlock LwIP stack
    UNLOCK_TCPIP_CORE();

#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    // Wake the thread calling select so that it recognizes the new socket.
    lSystemLayer.WakeSelect();

#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    if (res == INET_NO_ERROR)
        mState = kState_Listening;

    return res;
}

void UDPEndPoint::Close()
{
    if (mState != kState_Closed)
    {
#if WEAVE_SYSTEM_CONFIG_USE_LWIP

        // Lock LwIP stack
        LOCK_TCPIP_CORE();

        // Since UDP PCB is released synchronously here, but UDP endpoint itself might have to wait
        // for destruction asynchronously, there could be more allocated UDP endpoints than UDP PCBs.
        if (mUDP != NULL)
            udp_remove(mUDP);
        mUDP = NULL;

        // Unlock LwIP stack
        UNLOCK_TCPIP_CORE();

#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

# if WEAVE_SYSTEM_CONFIG_USE_SOCKETS

        if (mSocket != INET_INVALID_SOCKET_FD)
        {
            Weave::System::Layer& lSystemLayer = SystemLayer();

            // Wake the thread calling select so that it recognizes the socket is closed.
            lSystemLayer.WakeSelect();

            close(mSocket);
            mSocket = INET_INVALID_SOCKET_FD;
        }

        // Clear any results from select() that indicate pending I/O for the socket.
        mPendingIO.Clear();

#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

        mState = kState_Closed;
    }
}

void UDPEndPoint::Free()
{
    Close();

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
    DeferredFree(kReleaseDeferralErrorTactic_Die);
#else // !WEAVE_SYSTEM_CONFIG_USE_LWIP
    Release();
#endif // !WEAVE_SYSTEM_CONFIG_USE_LWIP
}

INET_ERROR UDPEndPoint::SendTo(IPAddress addr, uint16_t port, PacketBuffer *msg, uint16_t sendFlags)
{
    return SendTo(addr, port, INET_NULL_INTERFACEID, msg, sendFlags);
}

INET_ERROR UDPEndPoint::SendTo(IPAddress addr, uint16_t port, InterfaceId intfId, PacketBuffer *msg, uint16_t sendFlags)
{
    INET_ERROR res = INET_NO_ERROR;

    INET_FAULT_INJECT(FaultInjection::kFault_Send,
            if ((sendFlags & kSendFlag_RetainBuffer) == 0)
                PacketBuffer::Free(msg);
            return INET_ERROR_UNKNOWN_INTERFACE;
            );
    INET_FAULT_INJECT(FaultInjection::kFault_SendNonCritical,
            if ((sendFlags & kSendFlag_RetainBuffer) == 0)
                PacketBuffer::Free(msg);
            return INET_ERROR_NO_MEMORY;
            );

#if WEAVE_SYSTEM_CONFIG_USE_LWIP

    if (sendFlags & kSendFlag_RetainBuffer)
    {
        // when retaining a buffer, the caller expects the msg to be
        // unmodified.  LwIP stack will normally prepend the packet
        // headers as the packet traverses the UDP/IP/netif layers,
        // which normally modifies the packet.  We prepend a small
        // pbuf to the beginning of the pbuf chain, s.t. all headers
        // are added to the temporary space, just large enough to hold
        // the transport headers. Careful reader will note:
        //
        // * we're actually oversizing the reserved space, the
        //   transport header is large enough for the TCP header which
        //   is larger than the UDP header, but it seemed cleaner than
        //   the combination of PBUF_IP for reserve space, UDP_HLEN
        //   for payload, and post allocation adjustment of the header
        //   space).
        //
        // * the code deviates from the existing PacketBuffer
        //   abstractions and needs to reach into the underlying pbuf
        //   code.  The code in PacketBuffer also forces us to perform
        //   (effectively) a reinterpret_cast rather than a
        //   static_cast.  JIRA WEAV-811 is filed to track the
        //   re-architecting of the memory management.

        pbuf *msgCopy = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_RAM);

        if (msgCopy == NULL)
        {
            return INET_ERROR_NO_MEMORY;
        }

        pbuf_chain(msgCopy, (pbuf *) msg);
        msg = (PacketBuffer *)msgCopy;
    }

    // Lock LwIP stack
    LOCK_TCPIP_CORE();

    // Make sure we have the appropriate type of PCB based on the destination address.
    res = GetPCB(addr.Type());

    // Send the message to the specified address/port.
    if (res == INET_NO_ERROR)
    {
        err_t lwipErr = ERR_VAL;

#if LWIP_VERSION_MAJOR > 1
        ip_addr_t ipAddr = addr.ToLwIPAddr();
        if (intfId != INET_NULL_INTERFACEID)
            lwipErr = udp_sendto_if(mUDP, (pbuf *)msg, &ipAddr, port, intfId);
        else
            lwipErr = udp_sendto(mUDP, (pbuf *)msg, &ipAddr, port);
#else // LWIP_VERSION_MAJOR <= 1
        if (PCB_ISIPV6(mUDP))
        {
            ip6_addr_t ipv6Addr = addr.ToIPv6();
            if (intfId != INET_NULL_INTERFACEID)
                lwipErr = udp_sendto_if_ip6(mUDP, (pbuf *)msg, &ipv6Addr, port, intfId);
            else
                lwipErr = udp_sendto_ip6(mUDP, (pbuf *)msg, &ipv6Addr, port);
        }
#if INET_CONFIG_ENABLE_IPV4
        else
        {
            ip4_addr_t ipv4Addr = addr.ToIPv4();
            if (intfId != INET_NULL_INTERFACEID)
                lwipErr = udp_sendto_if(mUDP, (pbuf *)msg, &ipv4Addr, port, intfId);
            else
                lwipErr = udp_sendto(mUDP, (pbuf *)msg, &ipv4Addr, port);
        }
#endif // INET_CONFIG_ENABLE_IPV4
#endif // LWIP_VERSION_MAJOR <= 1

        if (lwipErr != ERR_OK)
            res = Weave::System::MapErrorLwIP(lwipErr);
    }

    // Unlock LwIP stack
    UNLOCK_TCPIP_CORE();

    PacketBuffer::Free(msg);

#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    // Make sure we have the appropriate type of socket based on the destination address.
    res = GetSocket(addr.Type());

    // For now the entire message must fit within a single buffer.
    if (res == INET_NO_ERROR && msg->Next() != NULL)
        res = INET_ERROR_MESSAGE_TOO_LONG;

    if (res == INET_NO_ERROR)
    {
        struct iovec msgIOV;
        union
        {
            sockaddr any;
            sockaddr_in in;
            sockaddr_in6 in6;
        } peerSockAddr;
        uint8_t controlData[256];
        struct msghdr msgHeader;

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

        msgIOV.iov_base = msg->Start();
        msgIOV.iov_len = msg->DataLength();
        msgHeader.msg_iov = &msgIOV;
        msgHeader.msg_iovlen = 1;

        memset(&peerSockAddr, 0, sizeof(peerSockAddr));
        msgHeader.msg_name = &peerSockAddr;
        if (mAddrType == kIPAddressType_IPv6)
        {
            peerSockAddr.in6.sin6_family = AF_INET6;
            peerSockAddr.in6.sin6_port = htons(port);
            peerSockAddr.in6.sin6_flowinfo = 0;
            peerSockAddr.in6.sin6_addr = addr.ToIPv6();
            peerSockAddr.in6.sin6_scope_id = intfId;
            msgHeader.msg_namelen = sizeof(sockaddr_in6);
        }
#if INET_CONFIG_ENABLE_IPV4
        else
        {
            peerSockAddr.in.sin_family = AF_INET;
            peerSockAddr.in.sin_port = htons(port);
            peerSockAddr.in.sin_addr = addr.ToIPv4();
            msgHeader.msg_namelen = sizeof(sockaddr_in);
        }
#endif // INET_CONFIG_ENABLE_IPV4

        // If the endpoint has been bound to a particular interface, and the caller didn't supply
        // a specific interface to send on, use the bound interface. This appears to be necessary
        // for messages to multicast addresses, which under linux don't seem to get sent out the
        // correct inferface, despite the socket being bound.
        if (intfId == INET_NULL_INTERFACEID)
            intfId = mBoundIntfId;

        if (intfId != INET_NULL_INTERFACEID && false)
        {
#if defined(IP_PKTINFO) || defined(IPV6_PKTINFO)
            memset(controlData, 0, sizeof(controlData));
            msgHeader.msg_control = controlData;
            msgHeader.msg_controllen = sizeof(controlData);

            struct cmsghdr *controlHdr = CMSG_FIRSTHDR(&msgHeader);

#if INET_CONFIG_ENABLE_IPV4
#if defined(IP_PKTINFO)
            if (mAddrType == kIPAddressType_IPv4)
            {
                controlHdr->cmsg_level = IPPROTO_IP;
                controlHdr->cmsg_type = IP_PKTINFO;
                controlHdr->cmsg_len = CMSG_LEN(sizeof(in_pktinfo));

                struct in_pktinfo *pktInfo = (struct in_pktinfo *)CMSG_DATA(controlHdr);
                pktInfo->ipi_ifindex = intfId;

                msgHeader.msg_controllen = CMSG_SPACE(sizeof(in_pktinfo));
            }
#endif // defined(IP_PKTINFO)
#endif // INET_CONFIG_ENABLE_IPV4

#if defined(IPV6_PKTINFO)
            if (mAddrType == kIPAddressType_IPv6)
            {
                controlHdr->cmsg_level = IPPROTO_IP;
                controlHdr->cmsg_type = IPV6_PKTINFO;
                controlHdr->cmsg_len = CMSG_LEN(sizeof(in6_pktinfo));

                struct in6_pktinfo *pktInfo = (struct in6_pktinfo *)CMSG_DATA(controlHdr);
                pktInfo->ipi6_ifindex = intfId;

                msgHeader.msg_controllen = CMSG_SPACE(sizeof(in6_pktinfo));
            }
#endif // defined(IPV6_PKTINFO)
#else // !(defined(IP_PKTINFO) && defined(IPV6_PKTINFO))
            res = INET_ERROR_NOT_IMPLEMENTED
#endif // !(defined(IP_PKTINFO) && defined(IPV6_PKTINFO))
        }

        if (res == INET_NO_ERROR)
        {
            // Send UDP packet.
//            ssize_t lenSent = sendmsg(mSocket, &msgHeader, 0);

            ssize_t lenSent = sendto(mSocket, msgHeader.msg_iov[0].iov_base, msgHeader.msg_iov[0].iov_len, 0, &peerSockAddr.any, msgHeader.msg_namelen);
            if (lenSent == -1)
                res = Weave::System::MapErrorPOSIX(errno);
            else if (lenSent != msg->DataLength())
                res = INET_ERROR_OUTBOUND_MESSAGE_TRUNCATED;
        }
    }

    if ((sendFlags & kSendFlag_RetainBuffer) == 0)
        PacketBuffer::Free(msg);

#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    WEAVE_SYSTEM_FAULT_INJECT_ASYNC_EVENT();

    return res;
}

//A lock is required because the LwIP thread may be referring to intf_filter,
//while this code running in the Inet application is potentially modifying it.
//NOTE: this only supports LwIP interfaces whose number is no bigger than 9.
INET_ERROR UDPEndPoint::BindInterface(IPAddressType addrType, InterfaceId intf)
{
    INET_ERROR err = INET_NO_ERROR;

    if (mState != kState_Ready && mState != kState_Bound)
        return INET_ERROR_INCORRECT_STATE;

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
    LOCK_TCPIP_CORE();

    // Make sure we have the appropriate type of PCB.
    err = GetPCB(addrType);
    if (err == INET_NO_ERROR)
    {
        if ( !IsInterfaceIdPresent(intf) )
        { //Stop interface-based filtering.
            mUDP->intf_filter = NULL;
        }
        else
        {
            struct netif *netifPtr;
            for (netifPtr = netif_list; netifPtr != NULL; netifPtr = netifPtr->next)
            {
                if (netifPtr == intf)
                {
                    break;
                }
            }
            if (netifPtr == NULL)
            {
                err = INET_ERROR_UNKNOWN_INTERFACE;
            }
            else
            {
                mUDP->intf_filter = netifPtr;
            }
        }
    }

    UNLOCK_TCPIP_CORE();

#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS
#if HAVE_SO_BINDTODEVICE

    // Make sure we have the appropriate type of socket.
    err = GetSocket(addrType);

    if (err == INET_NO_ERROR)
    {
        if (intf == INET_NULL_INTERFACEID)
        {//Stop interface-based filtering.
            if (setsockopt(mSocket, SOL_SOCKET, SO_BINDTODEVICE, "", 0) == -1)
            {
                err = Weave::System::MapErrorPOSIX(errno);
            }
        }
        else
        {    //Start filtering on the passed interface.
            char intfName[IF_NAMESIZE];
            if (if_indextoname(intf, intfName) == NULL)
            {
                err = Weave::System::MapErrorPOSIX(errno);
            }

            if (err == INET_NO_ERROR && setsockopt(mSocket, SOL_SOCKET, SO_BINDTODEVICE, intfName, strlen(intfName)) == -1)
            {
                err = Weave::System::MapErrorPOSIX(errno);
            }
        }
    }

    if (err == INET_NO_ERROR)
        mBoundIntfId = intf;

#else // !HAVE_SO_BINDTODEVICE

    err = INET_ERROR_NOT_IMPLEMENTED;

#endif // HAVE_SO_BINDTODEVICE
#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    if (err == INET_NO_ERROR)
        mState = kState_Bound;

    return err;
}

void UDPEndPoint::Init(InetLayer *inetLayer)
{
    InitEndPointBasis(*inetLayer);

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS
    mBoundIntfId = INET_NULL_INTERFACEID;
#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS
}

InterfaceId UDPEndPoint::GetBoundInterface (void)
{
#if WEAVE_SYSTEM_CONFIG_USE_LWIP
    return mUDP->intf_filter;
#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS
    return mBoundIntfId;
#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS
}

#if WEAVE_SYSTEM_CONFIG_USE_LWIP

void UDPEndPoint::HandleDataReceived(PacketBuffer *msg)
{
    if (mState == kState_Listening && OnMessageReceived != NULL)
    {
        IPPacketInfo *pktInfo = GetPacketInfo(msg);
        if (pktInfo != NULL)
        {
            IPPacketInfo pktInfoCopy = *pktInfo; // copy the address info so that the app can free the
                                                  // PacketBuffer without affecting access to address info.
            OnMessageReceived(this, msg, &pktInfoCopy);
        }
        else
        {
            if (OnReceiveError != NULL)
                OnReceiveError(this, INET_ERROR_INBOUND_MESSAGE_TOO_BIG, NULL);
            PacketBuffer::Free(msg);
        }
    }
    else
        PacketBuffer::Free(msg);
}

INET_ERROR UDPEndPoint::GetPCB(IPAddressType addrType)
{
    // IMMPORTANT: This method MUST be called with the LwIP stack LOCKED!

#if LWIP_VERSION_MAJOR > 1
    if (mUDP == NULL)
    {
        switch (addrType)
        {
        case kIPAddressType_IPv6:
#if INET_CONFIG_ENABLE_IPV4
        case kIPAddressType_IPv4:
#endif // INET_CONFIG_ENABLE_IPV4
            mUDP = udp_new();
            break;

        default:
            return INET_ERROR_WRONG_ADDRESS_TYPE;
        }

        if (mUDP == NULL)
        {
            WeaveLogError(Inet, "udp_new failed");
            return INET_ERROR_NO_MEMORY;
        }
    }
    else
    {
        switch (IP_GET_TYPE(&mUDP->local_ip))
        {
        case IPADDR_TYPE_V6:
            if (addrType != kIPAddressType_IPv6)
                return INET_ERROR_WRONG_ADDRESS_TYPE;
            break;

#if INET_CONFIG_ENABLE_IPV4
        case IPADDR_TYPE_V4:
            if (addrType != kIPAddressType_IPv4)
                return INET_ERROR_WRONG_ADDRESS_TYPE;
            break;
#endif // INET_CONFIG_ENABLE_IPV4

        default:
            break;
        }
    }
#else // LWIP_VERSION_MAJOR <= 1
    if (mUDP == NULL)
    {
        if (addrType == kIPAddressType_IPv6)
        {
            mUDP = udp_new_ip6();
            if (mUDP != NULL)
                ip_set_option(mUDP, SOF_REUSEADDR);
        }
#if INET_CONFIG_ENABLE_IPV4
        else if (addrType == kIPAddressType_IPv4) {
            mUDP = udp_new();
        }
#endif // INET_CONFIG_ENABLE_IPV4
        else
            return INET_ERROR_WRONG_ADDRESS_TYPE;

        if (mUDP == NULL) {
            WeaveLogError(Inet, "udp_new failed");
            return INET_ERROR_NO_MEMORY;
        }
    }
    else
    {
#if INET_CONFIG_ENABLE_IPV4
        const IPAddressType pcbType = PCB_ISIPV6(mUDP) ? kIPAddressType_IPv6 : kIPAddressType_IPv4;
#else // !INET_CONFIG_ENABLE_IPV4
        const IPAddressType pcbType = kIPAddressType_IPv6;
#endif // !INET_CONFIG_ENABLE_IPV4
        if (addrType != pcbType) {
            return INET_ERROR_WRONG_ADDRESS_TYPE;
        }
    }
#endif // LWIP_VERSION_MAJOR <= 1

    return INET_NO_ERROR;
}

IPPacketInfo *UDPEndPoint::GetPacketInfo(PacketBuffer *buf)
{
    // When using LwIP information about the packet is 'hidden' in the reserved space before the start of
    // the data in the packet buffer.  This is necessary because the events in dolomite can only have two
    // arguments, which in this case are used to convey the pointer to the end point and the pointer to the
    // buffer.
    //
    // In most cases this trick of storing information before the data works because the first buffer in
    // an LwIP UDP message contains the space that was used for the Ethernet/IP/UDP headers. However, given
    // the current size of the IPPacketInfo structure (40 bytes), it is possible for there to not be enough
    // room to store the structure along with the payload in a single pbuf. In practice, this should only
    // happen for extremely large IPv4 packets that arrive without an Ethernet header.
    //
    if (!buf->EnsureReservedSize(sizeof(IPPacketInfo) + 3))
        return NULL;
    uintptr_t start = (uintptr_t)buf->Start();
    uintptr_t pktInfoStart = start - sizeof(IPPacketInfo);
    pktInfoStart = pktInfoStart & ~3;// align to 4-byte boundary
    return (IPPacketInfo *)pktInfoStart;
}

#if LWIP_VERSION_MAJOR > 1
void UDPEndPoint::LwIPReceiveUDPMessage(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
#else // LWIP_VERSION_MAJOR <= 1
void UDPEndPoint::LwIPReceiveUDPMessage(void *arg, struct udp_pcb *pcb, struct pbuf *p, ip_addr_t *addr, u16_t port)
#endif // LWIP_VERSION_MAJOR <= 1
{
    UDPEndPoint*            ep              = static_cast<UDPEndPoint*>(arg);
    PacketBuffer*           buf             = reinterpret_cast<PacketBuffer*>(static_cast<void*>(p));
    Weave::System::Layer&   lSystemLayer    = ep->SystemLayer();

    IPPacketInfo *pktInfo = GetPacketInfo(buf);
    if (pktInfo != NULL)
    {
#if LWIP_VERSION_MAJOR > 1
        pktInfo->SrcAddress = IPAddress::FromLwIPAddr(*addr);
        pktInfo->DestAddress = IPAddress::FromLwIPAddr(*ip_current_dest_addr());
#else // LWIP_VERSION_MAJOR <= 1
        if (PCB_ISIPV6(pcb))
        {
            pktInfo->SrcAddress = IPAddress::FromIPv6(*(ip6_addr_t *)addr);
            pktInfo->DestAddress = IPAddress::FromIPv6(*ip6_current_dest_addr());
        }
#if INET_CONFIG_ENABLE_IPV4
        else
        {
            pktInfo->SrcAddress = IPAddress::FromIPv4(*addr);
            pktInfo->DestAddress = IPAddress::FromIPv4(*ip_current_dest_addr());
        }
#endif // INET_CONFIG_ENABLE_IPV4
#endif // LWIP_VERSION_MAJOR <= 1

        pktInfo->Interface = ip_current_netif();
        pktInfo->SrcPort = port;
        pktInfo->DestPort = pcb->local_port;
    }

    if (lSystemLayer.PostEvent(*ep, kInetEvent_UDPDataReceived, (uintptr_t)buf) != INET_NO_ERROR)
        PacketBuffer::Free(buf);
}

#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS

INET_ERROR UDPEndPoint::GetSocket(IPAddressType addrType)
{
    if (mSocket == INET_INVALID_SOCKET_FD)
    {
        int one = 1;
        int family;
        int res;

        if (addrType == kIPAddressType_IPv6)
            family = PF_INET6;
#if INET_CONFIG_ENABLE_IPV4
        else if (addrType == kIPAddressType_IPv4)
            family = PF_INET;
#endif // INET_CONFIG_ENABLE_IPV4
        else
            return INET_ERROR_WRONG_ADDRESS_TYPE;

        mSocket = ::socket(family, SOCK_DGRAM | SOCK_FLAGS, 0);
        if (mSocket == -1)
            return Weave::System::MapErrorPOSIX(errno);
        mAddrType = addrType;

        //
        // NOTE WELL: the errors returned by setsockopt() here are not returned as Inet layer
        // Weave::System::MapErrorPOSIX(errno) codes because they are normally expected to fail on some
        // platforms where the socket option code is defined in the header files but not [yet]
        // implemented. Certainly, there is room to improve this by connecting the build
        // configuration logic up to check for implementations of these options and to provide
        // appropriate HAVE_xxxxx definitions accordingly.
        //

        res = setsockopt(mSocket, SOL_SOCKET, SO_REUSEADDR,  (void*)&one, sizeof(one));
        static_cast<void>(res);

#ifdef SO_REUSEPORT
        res = setsockopt(mSocket, SOL_SOCKET, SO_REUSEPORT,  (void*)&one, sizeof(one));
        if (res != 0)
        {
            WeaveLogError(Inet, "SO_REUSEPORT: %d", errno);
        }
#endif // defined(SO_REUSEPORT)

        // If creating an IPv6 socket, tell the kernel that it will be IPv6 only.  This makes it
        // posible to bind two sockets to the same port, one for IPv4 and one for IPv6.
#ifdef IPV6_V6ONLY
#if INET_CONFIG_ENABLE_IPV4
        if (addrType == kIPAddressType_IPv6)
#endif // INET_CONFIG_ENABLE_IPV4
        {
            res = setsockopt(mSocket, IPPROTO_IPV6, IPV6_V6ONLY, (void *) &one, sizeof(one));
            if (res != 0)
            {
                WeaveLogError(Inet, "IPV6_V6ONLY: %d", errno);
            }
        }
#endif // defined(IPV6_V6ONLY)

#if INET_CONFIG_ENABLE_IPV4
#ifdef IP_PKTINFO
        res = setsockopt(mSocket, IPPROTO_IP, IP_PKTINFO, (void *) &one, sizeof(one));
        if (res != 0)
        {
            WeaveLogError(Inet, "IP_PKTINFO: %d", errno);
        }
#endif // defined(IP_PKTINFO)
#endif // INET_CONFIG_ENABLE_IPV4

#ifdef IPV6_RECVPKTINFO
        res = setsockopt(mSocket, IPPROTO_IPV6, IPV6_RECVPKTINFO, (void *) &one, sizeof(one));
        if (res != 0)
        {
            WeaveLogError(Inet, "IPV6_PKTINFO: %d", errno);
        }
#endif // defined(IPV6_RECVPKTINFO)

        // On systems that support it, disable the delivery of SIGPIPE signals when writing to a closed
        // socket.  This is mostly needed on iOS which has the peculiar habit of sending SIGPIPEs on
        // unconnected UDP sockets.
#ifdef SO_NOSIGPIPE
        {
            one = 1;
            res = setsockopt(mSocket, SOL_SOCKET, SO_NOSIGPIPE, &one, sizeof(one));
            if (res != 0)
            {
                WeaveLogError(Inet, "SO_NOSIGPIPE: %d", errno);
            }
        }
#endif // defined(SO_NOSIGPIPE)

    }
    else if (mAddrType != addrType)
        return INET_ERROR_INCORRECT_STATE;

    return INET_NO_ERROR;
}

SocketEvents UDPEndPoint::PrepareIO()
{
    SocketEvents res;

    if (mState == kState_Listening && OnMessageReceived != NULL)
        res.SetRead();

    return res;
}

void UDPEndPoint::HandlePendingIO()
{
    INET_ERROR err = INET_NO_ERROR;

    if (mState == kState_Listening && OnMessageReceived != NULL && mPendingIO.IsReadable())
    {
        IPPacketInfo pktInfo;
        pktInfo.Clear();
        pktInfo.DestPort = mBoundPort;

        PacketBuffer *buf = PacketBuffer::New(0);

        if (buf != NULL)
        {
            struct iovec msgIOV;
            union
            {
                sockaddr any;
                sockaddr_in in;
                sockaddr_in6 in6;
            } peerSockAddr;
            uint8_t controlData[256];
            struct msghdr msgHeader;

            msgIOV.iov_base = buf->Start();
            msgIOV.iov_len = buf->AvailableDataLength();

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

            memset(&msgHeader, 0, sizeof(msgHeader));
            msgHeader.msg_name = &peerSockAddr;
            msgHeader.msg_namelen = sizeof(peerSockAddr);
            msgHeader.msg_iov = &msgIOV;
            msgHeader.msg_iovlen = 1;
            msgHeader.msg_control = controlData;
            msgHeader.msg_controllen = sizeof(controlData);

            ssize_t rcvLen = recvmsg(mSocket, &msgHeader, MSG_DONTWAIT);

            if (rcvLen < 0)
                err = Weave::System::MapErrorPOSIX(errno);

            else if (rcvLen > buf->AvailableDataLength())
                err = INET_ERROR_INBOUND_MESSAGE_TOO_BIG;

            else
            {
                buf->SetDataLength((uint16_t) rcvLen);

                if (peerSockAddr.any.sa_family == AF_INET6)
                {
                    pktInfo.SrcAddress = IPAddress::FromIPv6(peerSockAddr.in6.sin6_addr);
                    pktInfo.SrcPort = ntohs(peerSockAddr.in6.sin6_port);
                }
#if INET_CONFIG_ENABLE_IPV4
                else if (peerSockAddr.any.sa_family == AF_INET)
                {
                    pktInfo.SrcAddress = IPAddress::FromIPv4(peerSockAddr.in.sin_addr);
                    pktInfo.SrcPort = ntohs(peerSockAddr.in.sin_port);
                }
#endif // INET_CONFIG_ENABLE_IPV4
                else
                    err = INET_ERROR_INCORRECT_STATE;
            }

            if (err == INET_NO_ERROR)
            {
                for (struct cmsghdr *controlHdr = CMSG_FIRSTHDR(&msgHeader);
                     controlHdr != NULL;
                     controlHdr = CMSG_NXTHDR(&msgHeader, controlHdr))
                {
#if INET_CONFIG_ENABLE_IPV4
#ifdef IP_PKTINFO
                    if (controlHdr->cmsg_level == IPPROTO_IP && controlHdr->cmsg_type == IP_PKTINFO)
                    {
                        struct in_pktinfo *inPktInfo = (struct in_pktinfo *)CMSG_DATA(controlHdr);
                        pktInfo.Interface = inPktInfo->ipi_ifindex;
                        pktInfo.DestAddress = IPAddress::FromIPv4(inPktInfo->ipi_addr);
                        continue;
                    }
#endif // defined(IP_PKTINFO)
#endif // INET_CONFIG_ENABLE_IPV4

#ifdef IPV6_PKTINFO
                    if (controlHdr->cmsg_level == IPPROTO_IPV6 && controlHdr->cmsg_type == IPV6_PKTINFO)
                    {
                        struct in6_pktinfo *in6PktInfo = (struct in6_pktinfo *)CMSG_DATA(controlHdr);
                        pktInfo.Interface = in6PktInfo->ipi6_ifindex;
                        pktInfo.DestAddress = IPAddress::FromIPv6(in6PktInfo->ipi6_addr);
                        continue;
                    }
#endif // defined(IPV6_PKTINFO)
                }
            }
        }

        else
            err = INET_ERROR_NO_MEMORY;

        if (err == INET_NO_ERROR)
            OnMessageReceived(this, buf, &pktInfo);
        else
        {
            PacketBuffer::Free(buf);
            if (OnReceiveError != NULL
                && err != Weave::System::MapErrorPOSIX(EAGAIN)
            )
                OnReceiveError(this, err, NULL);
        }
    }

    mPendingIO.Clear();
}

#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

} // namespace Inet
} // namespace nl