udp.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
// end of udp.h file tag
 
 
#ifndef _NB_UDP_H_
#define _NB_UDP_H_
 
#include <predef.h>
#include <ip.h>
 
 
// Start of groupNBAPI-UDP
 
 
#ifdef IPV6
struct IPv6FrameProcessingStruct;   // Forward declaration
#endif
 
#ifdef IPV6
struct IP6FRAME;
#endif
 
/*
 * brief Internal UDP socket data structure
 * 
 * Maintains UDP socket state including receive queue, port bindings, and interface association.
 * This structure encapsulates all the state information needed to manage a UDP socket in the
 * NetBurner system, including both BSD socket compatibility (fd) and RTOS-native features (FIFO).
 * 
 * @warning This is an internal structure - use public API functions instead of direct access
 * @warning Direct manipulation of these fields may cause socket corruption or memory leaks
 * @warning Always use CreateRxUdpSocket(), CreateRxTxUdpSocket(), and related functions
 * 
 * @note This structure bridges BSD sockets and NetBurner's RTOS architecture
 * @note Each UDP socket maintains its own FIFO for packet queuing
 * @note The structure supports both connected and unconnected UDP sockets
 * @note Interface binding allows multi-homed device support
 * 
 * @par Internal Architecture:
 * The structure combines several addressing and queuing mechanisms:
 * - **FIFO Queue**: OS_FIFO for asynchronous packet reception
 * - **BSD Socket**: File descriptor for select()/poll() compatibility
 * - **Address Binding**: Local IP address for multi-interface systems
 * - **Port Management**: Separate receive, local, and remote ports
 * - **Interface Control**: Specific network interface binding
 * - **I/O Tracking**: Counter for monitoring socket activity
 * 
 * @par Port Field Meanings:
 * | Field | Purpose | Typical Value |
 * |-------|---------|---------------|
 * | rxport | Port where packets are received | 1024-65535 or 0 for any |
 * | lport | Local port for socket operations | Same as rxport typically |
 * | rport | Remote port (connected sockets only) | 0 for unconnected sockets |
 * 
 * @par Socket States:
 * The structure represents different socket states through its fields:
 * - **Uninitialized**: fd = 0, rxport = 0
 * - **Bound**: rxport set, address may be bound
 * - **Connected**: rport set (connected UDP socket)
 * - **Interface-specific**: ifn != -1
 * 
 * @par Multi-Interface Support:
 * The `ifn` field enables binding to specific network interfaces:
 * - **-1**: Listen on all interfaces (default)
 * - **0, 1, 2...**: Specific interface number
 * - Useful for dual Ethernet, WiFi + Ethernet, etc.
 * 
 * @par Thread Safety:
 * - The OS_FIFO is thread-safe for packet queuing
 * - Other fields should not be modified from multiple threads
 * - Socket operations are internally synchronized by the stack
 * 
 * @see CreateRxUdpSocket(), CreateRxTxUdpSocket(), RegisterUDPFifo()
 */
struct UdpSocketDataSet
{
    OS_FIFO the_fifo;       
    int fd = 0;             
    IPADDR address;         
    int ifn;                
    uint16_t rxport = 0;    
    uint16_t lport = 0;     
    uint16_t rport = 0;     
    uint16_t io_counter=0;  
};
 
class UDPPacket
{
   protected:
    PoolPtr m_p;
    PUDPPKT m_pPkt;
 
#ifdef IPV6
    IP6FRAME *m_pIP6f;
#endif
 
#ifdef UDP_FRAGMENTS
    BOOL m_bIsFragBuffer;
#endif
 
    PIPPKT GetIpPacket();
    int BuildHeaders4(IPADDR4 destIP, IPADDR4 *srcIP, uint8_t ttl);
    friend PoolPtr CreateDnsResponse4(IPADDR4 serverIp, IPADDR4 clientIp, uint16_t serverPort, uint16_t clientPort, const char *name, IPADDR hostIp, uint32_t ttl);
    UDPPacket(UDPPacket *pkt,bool clone);
 
   public:
    UDPPacket(OS_FIFO *pFifo, TickTimeout timeout);
    UDPPacket(OS_FIFO *pFifo, uint32_t timeout);
 
     UDPPacket(int sock);
 
#ifdef IPV6
    UDPPacket(IPv6FrameProcessingStruct &p6);
    void Fix_6_Sb_4();
#endif
 
    UDPPacket(PoolPtr p);
 
    UDPPacket(UDPPacket &pkt);
 
#ifdef IPV6
    UDPPacket(bool bIsIpv6 = false);
#else
    UDPPacket();
#endif
 
    ~UDPPacket();
 
    inline bool Receive(OS_FIFO *pFifo, uint32_t wait_ticks)
    {
        if (m_p != 0)
        {
#ifdef UDP_FRAGMENTS
            FragFreeBuffer(m_p);
#else
            FreeBuffer(m_p);
#endif
            m_p = NULL;
        }
 
        m_p = OSPoolFifoPend(pFifo, wait_ticks);
 
        if (m_p)
        {
#ifdef UDP_FRAGMENTS
            puint8_t pb = (puint8_t)m_p;
            if ((((puint8_t)m_p) >= pFragmentBuffers) && (((puint8_t)m_p) < pMaxFragmentBuffer))
            {
                m_bIsFragBuffer = TRUE;
                m_pPkt = (PUDPPKT)(((PIPPKT)(pb + 4))->DATA);
            }
            else
            {
                m_bIsFragBuffer = FALSE;
                m_pPkt = GetUdpPkt(m_p);
                if (m_p)
                {
#ifdef UDP_FRAGMENTS
                    puint8_t pb = (puint8_t)m_p;
                    if ((((puint8_t)m_p) >= pFragmentBuffers) && (((puint8_t)m_p) < pMaxFragmentBuffer))
                    {
                        m_bIsFragBuffer = TRUE;
                        m_pPkt = (PUDPPKT)(((PIPPKT)(pb + 4))->DATA);
                    }
                    else
                    {
                        m_bIsFragBuffer = FALSE;
                        m_pPkt = GetUdpPkt(m_p);
                    }
#else
                    SetUpUdpPkt(m_p);
#endif
                }
                else
                {
                    m_pPkt = NULL;
                }
            }
#else
            SetUpUdpPkt(m_p);
#endif
        }
        else
        {
            m_pPkt = NULL;
        }
 
        if (m_p == NULL) return false;
        return true;
    };
 
    void SetSourcePort(uint16_t port);
 
    uint16_t GetSourcePort(void) const;
 
    IPADDR4 GetSourceAddress4(void);
    IPADDR4 GetDestinationAddress4();
 
    MACADR GetMacSource();
 
#ifdef IPV6
    IPADDR GetSourceAddress6(void);
    IPADDR GetDestinationAddress6();
    void SetUpUdpPkt(PoolPtr pp);
    PUDPPKT InitUdpPkt(bool IpV6 = false);
 
    inline IPADDR GetSourceAddress(void) { return GetSourceAddress6(); }
 
    inline IPADDR GetDestinationAddress(void) { return GetDestinationAddress6(); }
 
    inline bool bIsIPV6() const { return (m_pIP6f != NULL); }
#else
    inline IPADDR4 GetSourceAddress(void) { return GetSourceAddress4(); };
    inline IPADDR4 GetDestinationAddress() { return GetDestinationAddress4(); }
    inline PUDPPKT GetUdpPkt(PoolPtr p) { return ::GetUdpPkt(GetIpPkt(p)); };
    inline void SetUpUdpPkt(PoolPtr pp) { m_pPkt = GetUdpPkt(pp); };
    inline PUDPPKT GetInitUdpPkt(PIPPKT pIp)
    {
        pIp->bVerHdrLen = 0x45;
        return (PUDPPKT)pIp->DATA;
    }
    inline PUDPPKT GetInitUdpPkt(PoolPtr p) { return GetInitUdpPkt(GetIpPkt(p)); };
#endif
 
    void SetDestinationPort(uint16_t port);
 
    uint16_t GetDestinationPort(void) const;
 
    uint16_t GetPacketId(void);
 
    void SetDSCP(uint8_t dscp);
 
    uint8_t GetDSCP(void) const;
 
    puint8_t GetDataBuffer(bool bReAllocateIfNeeded = false);
 
    void SetDataSize(uint16_t numBytes);
 
    uint16_t GetDataSize(void) const;
 
    void AddData(puint8_t pData, uint16_t len);
 
    void AddData(PCSTR pData);
 
    void AddDataWord(uint16_t w);
 
    void AddDataByte(uint8_t b);
 
 
    BOOL Validate(void);
 
 
    void ResetData(void);
 
    void SendAndKeep4(IPADDR4 destIP, uint8_t ttl = 0);
    void Send4(IPADDR4 destIP, uint8_t ttl = 0);
    void SendAndKeepViaInterfaceNum4(IPADDR4 to, int interface, uint8_t ttl = 0);
    void SendViaInterfaceNum4(IPADDR4 destIP, int interface, uint8_t ttl = 0);
 
#ifdef IPV6
    void SendAndKeep6(const IPADDR &to, uint8_t ttl = 0);
    void Send6(const IPADDR &to, uint8_t ttl = 0);
    void SendAndKeepViaInterfaceNum6(const IPADDR &to, int interface, uint8_t ttl = 0);
    void SendViaInterfaceNum6(const IPADDR &to, int interface, uint8_t ttl = 0);
 
inline void SendAndKeep(const IPADDR &to, uint8_t ttl = 0) { SendAndKeep6(to, ttl); }
 
inline void Send(const IPADDR &to, uint8_t ttl = 0) { Send6(to, ttl); }
 
inline void SendAndKeepViaInterfaceNum(const IPADDR &to, int interface, uint8_t ttl = 0)
{
    SendAndKeepViaInterfaceNum6(to, interface, ttl);
}
 
inline void SendViaInterfaceNum(const IPADDR &to, int interface, uint8_t ttl = 0) 
{ 
    SendViaInterfaceNum6(to, interface, ttl); 
}
#else
    inline void SendAndKeep(IPADDR4 to, uint8_t ttl = 0) { SendAndKeep4(to, ttl); };
    inline void Send(IPADDR4 to, uint8_t ttl = 0) { Send4(to, ttl); };
    inline void SendAndKeepViaInterfaceNum(IPADDR4 to, int interface, uint8_t ttl = 0) { SendAndKeepViaInterfaceNum4(to, interface, ttl); };
    inline void SendViaInterfaceNum(IPADDR4 to, int interface, uint8_t ttl = 0) { SendViaInterfaceNum4(to, interface, ttl); };
#endif
 
#ifdef UDP_FRAGMENTS
    void FragFreeBuffer(PoolPtr mp);
    void ReleaseBuffer(void);
    PoolPtr GetPoolPtr(void);
    void FixTransmitBuffers();
#else
    void ReleaseBuffer(void)
    {
        m_p = NULL;
        m_pPkt = NULL;
#ifdef IPV6
        m_pIP6f = NULL;
#endif
    };
    PoolPtr GetPoolPtr(void) { return m_p; };
#endif
 
#if defined MULTIHOME || defined AUTOIP
    void SendViaIfAddr4(IPADDR4 to, IPADDR4 *from_ip, uint8_t ttl = 0);
    void SendViaIfAddrAndNum4(IPADDR4 to, IPADDR4 *from_ip, int interface, uint8_t ttl = 0);
    void SendAndKeepViaIfAddr4(IPADDR4 to, IPADDR4 *from_ip, uint8_t ttl = 0);
 
#ifdef IPV6
    void SendAndKeepViaIfAddr6(const IPADDR &to, const IPADDR &from_ip, uint8_t ttl = 0);
 
    inline void SendAndKeepViaIfAddr(const IPADDR &to, const IPADDR &from_ip, uint8_t ttl = 0) { SendAndKeepViaIfAddr6(to, from_ip, ttl); }
 
    void SendViaIfAddr6(const IPADDR &to, const IPADDR &from_ip, uint8_t ttl = 0);
 
    inline void SendViaIfAddr(const IPADDR &to, const IPADDR &from_ip, uint8_t ttl = 0) { SendViaIfAddr(to, from_ip, ttl); };
#else
    inline void SendAndKeepViaIfAddr(IPADDR4 to, IPADDR4 from_ip, uint8_t ttl = 0) { SendAndKeepViaIfAddr4(to, &from_ip, ttl); }
    inline void SendViaIfAddr(IPADDR4 to, IPADDR4 from_ip, uint8_t ttl = 0) { SendViaIfAddr4(to, &from_ip, ttl); };
#endif
#endif
 
    bool process_all_udp();
 
    // Destructive copy - transfers ownership
    inline void CopyFrom(UDPPacket cpyfrm)
    {
        if (m_p != 0)
        {
#ifdef UDP_FRAGMENTS
            FragFreeBuffer(m_p);
#else
            FreeBuffer(m_p);
#endif
            m_p = NULL;
        }
        m_p = cpyfrm.m_p;
        m_pPkt = cpyfrm.m_pPkt;
        cpyfrm.m_p = NULL;
        cpyfrm.m_pPkt = NULL;
#ifdef IPV6
        m_pIP6f = cpyfrm.m_pIP6f;
        cpyfrm.m_pIP6f = NULL;
#endif
#ifdef UDP_FRAGMENTS
        m_bIsFragBuffer = cpyFrm.m_bIsFragBuffer;
#endif
    };
 
    void Swap(UDPPacket &rhs);
};
 
#ifdef UDP_FRAGMENTS
extern uint8_t pFragmentBuffers[UDP_FRAGMENTS * (65536 + 4)];
extern puint8_t pMaxFragmentBuffer;
#endif
 
typedef void(udp_data_notify)(OS_FIFO *pfifo, uint16_t port);
 
bool RegisterUDPFifo(uint16_t listenPort, OS_FIFO *pFifo);
 
bool RegisterUDPFifoVia(uint16_t listenPort, OS_FIFO *pFifo, int interface);
 
 
uint16_t RegisterEphemeralFifo(OS_FIFO *pfifo, int ifn = -1);
 
bool RegisterUDPFifoWithNotify(uint16_t listenPort, OS_FIFO *pFifo, udp_data_notify *pNotifyFunction);
 
bool RegisterUDPFifoWithNotifyVia(uint16_t listenPort, OS_FIFO *pFifo, udp_data_notify *pNotifyFunction, int interface);
 
void UnregisterUDPFifo(uint16_t listenPort, bool drain = false);
 
void process_udp4(PoolPtr pp, PIPPKT pIP, uint16_t csum);
 
#ifdef IPV6
struct IPv6FrameProcessingStruct;
bool process_udp6(IPv6FrameProcessingStruct &p6proc);
#endif
 
 
 
//========================================================================================================================
//========================================================================================================================
//========================================================================================================================
 
#define UDP_ERR_NOSUCH_SOCKET (-1)      
#define UDP_ERR_NOTOPEN_TO_WRITE (-2)   
#define UDP_ERR_NOTOPEN_TO_READ (-3)    
// start of groupUDPSocket
 
 
int CreateRxUdpSocket(uint16_t listening_port);
 
int CreateTxUdpSocket4(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port);
int CreateRxTxUdpSocket4(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port);
 
#ifdef IPV6
int CreateTxUdpSocket6(const IPADDR &send_to_addr, uint16_t remote_port, uint16_t local_port);
 
inline int CreateTxUdpSocket(const IPADDR &send_to_addr, uint16_t remote_port, uint16_t local_port)
{
    return CreateTxUdpSocket6(send_to_addr, remote_port, local_port);
};
#else
inline int CreateTxUdpSocket(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port)
{
    return CreateTxUdpSocket4(send_to_addr, remote_port, local_port);
};
#endif
 
#ifdef IPV6
int CreateRxTxUdpSocket6(const IPADDR &send_to_addr, uint16_t send_to_remote_port, uint16_t local_port);
 
inline int CreateRxTxUdpSocket(const IPADDR &send_to_addr, uint16_t send_to_remote_port, uint16_t local_port)
{
    return CreateRxTxUdpSocket6(send_to_addr, send_to_remote_port, local_port);
};
#else
inline int CreateRxTxUdpSocket(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port)
{
    return CreateRxTxUdpSocket4(send_to_addr, send_to_remote_port, local_port);
};
#endif
 
int sendto4(int sock, puint8_t what_to_send, int len_to_send, IPADDR4 to_addr, uint16_t remote_port);
 
#ifdef IPV6
int sendto6(int sock, puint8_t what_to_send, int len_to_send, const IPADDR &to_addr, uint16_t remote_port);
 
inline int sendto(int sock, puint8_t what_to_send, int len_to_send, const IPADDR &to_addr, uint16_t remote_port)
{
    return sendto6(sock, what_to_send, len_to_send, to_addr, remote_port);
};
#else
inline int sendto(int sock, puint8_t what_to_send, int len_to_send, IPADDR4 to_addr, uint16_t remote_port)
{
    return sendto4(sock, what_to_send, len_to_send, to_addr, remote_port);
};
#endif
 
#if defined MULTIHOME || defined AUTOIP
int sendtovia4(int sock, puint8_t what_to_send, int len_to_send, IPADDR4 to_addr, uint16_t remote_port, int intfnum);
#ifdef IPV6
int sendtovia6(int sock, puint8_t what_to_send, int len_to_send, const IPADDR &to_addr, uint16_t remote_port, int intfnum);
[[deprecated]] inline int sendto6via(int sock, puint8_t what_to_send, int len_to_send, const IPADDR &to_addr, uint16_t remote_port, int intfnum)
{
    return sendtovia6(sock, what_to_send, len_to_send, to_addr, remote_port, intfnum);
}
 
inline int sendtovia(int sock, puint8_t what_to_send, int len_to_send, const IPADDR &to_addr, uint16_t remote_port, int intfnum)
{
    return sendtovia6(sock, what_to_send, len_to_send, to_addr, remote_port, intfnum);
};
#else
inline int sendtovia(int sock, puint8_t what_to_send, int len_to_send, IPADDR4 to_addr, uint16_t remote_port, int intfnum)
{
    return sendtovia4(sock, what_to_send, len_to_send, to_addr, remote_port, intfnum);
};
#endif
#endif
 
int recvfrom4(int sock, puint8_t buffer, int len, IPADDR4 *pAddr, uint16_t *pLocal_port, uint16_t *pRemote_port);
 
#ifdef IPV6
int recvfrom6(int sock, puint8_t buffer, int len, IPADDR *pAddr, uint16_t *pLocal_port, uint16_t *pRemote_port);
 
inline int recvfrom(int sock, puint8_t buffer, int len, IPADDR *pAddr, uint16_t *pLocal_port, uint16_t *pRemote_port)
{
    return recvfrom6(sock, buffer, len, pAddr, pLocal_port, pRemote_port);
};
#else
inline int recvfrom(int sock, puint8_t buffer, int len, IPADDR4 *pAddr, uint16_t *pLocal_port, uint16_t *pRemote_port)
{
    return recvfrom4(sock, buffer, len, pAddr, pLocal_port, pRemote_port);
};
#endif
 
int SendFragmentedUdpPacket4(IPADDR4 to, uint16_t source_port, uint16_t dest_port, puint8_t data, int length);
 
#ifdef IPV6
int SendFragmentedUdpPacket6(const IPADDR &to, uint16_t source_port, uint16_t dest_port, puint8_t data, int length);
 
inline int SendFragmentedUdpPacket(const IPADDR &to, uint16_t source_port, uint16_t dest_port, puint8_t data, int length)
{
    return SendFragmentedUdpPacket6(to, source_port, dest_port, data, length);
}
#else
inline int SendFragmentedUdpPacket(IPADDR4 to, uint16_t source_port, uint16_t dest_port, puint8_t data, int length)
{
    return SendFragmentedUdpPacket4(to, source_port, dest_port, data, length);
};
#endif
 
#ifndef IPV6
#ifndef IPV4ONLY
#error Must select an IP version in udp.h
#endif
#endif
 
#ifdef IPV6
#ifdef IPV4ONLY
#error Must select IPV4ONLY or IPV6 but not both
#endif
#endif
 
int CreateRxUdpSocketVia(uint16_t listening_port, int interfacenum);
int CreateRxUdpSocketVia(uint16_t listening_port, const IPADDR interfaceIp);
 
int CreateTxUdpSocketVia4(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port, int interfacenum);
int CreateTxUdpSocketVia4(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port, const IPADDR4 interfaceIp);
int CreateRxTxUdpSocketVia4(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, int interfacenum);
int CreateRxTxUdpSocketVia4(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, const IPADDR4 interfaceIp);
 
[[deprecated]] inline int CreateTxUdpSocket4Via(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port, int interfacenum)
{
    return CreateTxUdpSocketVia4(send_to_addr, remote_port, local_port, interfacenum);
}
[[deprecated]] inline int CreateTxUdpSocket4Via(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port, const IPADDR4 interfaceIp)
{
    return CreateTxUdpSocketVia4(send_to_addr, remote_port, local_port, interfaceIp);
}
[[deprecated]] inline int CreateRxTxUdpSocket4Via(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, int interfacenum)
{
    return CreateRxTxUdpSocketVia4(send_to_addr, send_to_remote_port, local_port, interfacenum);
}
[[deprecated]] inline int CreateRxTxUdpSocket4Via(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, const IPADDR4 interfaceIp)
{
    return CreateRxTxUdpSocketVia4(send_to_addr, send_to_remote_port, local_port, interfaceIp);
}
 
#ifdef IPV6
int CreateRxTxUdpSocketVia6(const IPADDR send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, int interfacenum);
int CreateRxTxUdpSocketVia6(const IPADDR send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, const IPADDR interfaceIp);
int CreateTxUdpSocketVia6(const IPADDR send_to_addr, uint16_t remote_port, uint16_t local_port, int interfacenum);
int CreateTxUdpSocketVia6(const IPADDR send_to_addr, uint16_t remote_port, uint16_t local_port, const IPADDR interfaceIp);
 
[[deprecated]] inline int CreateRxTxUdpSocket6Via(const IPADDR send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, int interfacenum)
{
    return CreateRxTxUdpSocketVia6(send_to_addr, send_to_remote_port, local_port, interfacenum);
}
[[deprecated]] inline int CreateRxTxUdpSocket6Via(const IPADDR send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, const IPADDR interfaceIp)
{
    return CreateRxTxUdpSocketVia6(send_to_addr, send_to_remote_port, local_port, interfaceIp);
}
[[deprecated]] inline int CreateTxUdpSocket6Via(const IPADDR send_to_addr, uint16_t remote_port, uint16_t local_port, int interfacenum)
{
    return CreateTxUdpSocketVia6(send_to_addr, remote_port, local_port, interfacenum);
}
[[deprecated]] inline int CreateTxUdpSocket6Via(const IPADDR send_to_addr, uint16_t remote_port, uint16_t local_port, const IPADDR interfaceIp)
{
    return CreateTxUdpSocketVia6(send_to_addr, remote_port, local_port, interfaceIp);
}
 
inline int CreateRxTxUdpSocketVia(const IPADDR send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, int interfacenum)
{
    return CreateRxTxUdpSocketVia6(send_to_addr, send_to_remote_port, local_port, interfacenum);
}
 
inline int CreateRxTxUdpSocketVia(const IPADDR send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, IPADDR interfaceIp)
{
    return CreateRxTxUdpSocketVia6(send_to_addr, send_to_remote_port, local_port, interfaceIp);
}
 
inline int CreateTxUdpSocketVia(const IPADDR send_to_addr, uint16_t remote_port, uint16_t local_port, int interfacenum)
{
    return CreateTxUdpSocketVia6(send_to_addr, remote_port, local_port, interfacenum);
}
 
inline int CreateTxUdpSocketVia(const IPADDR send_to_addr, uint16_t remote_port, uint16_t local_port, IPADDR interfaceIp)
{
    return CreateTxUdpSocketVia6(send_to_addr, remote_port, local_port, interfaceIp);
}
#else
inline int CreateRxTxUdpSocketVia(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, int interfacenum)
{
    return CreateRxTxUdpSocketVia4(send_to_addr, send_to_remote_port, local_port, interfacenum);
}
 
inline int CreateRxTxUdpSocketVia(const IPADDR4 send_to_addr, uint16_t send_to_remote_port, uint16_t local_port, IPADDR4 interfaceIp)
{
    return CreateRxTxUdpSocketVia4(send_to_addr, send_to_remote_port, local_port, interfaceIp);
}
 
inline int CreateTxUdpSocketVia(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port, int interfacenum)
{
    return CreateTxUdpSocketVia4(send_to_addr, remote_port, local_port, interfacenum);
}
 
inline int CreateTxUdpSocketVia(const IPADDR4 send_to_addr, uint16_t remote_port, uint16_t local_port, IPADDR4 interfaceIp)
{
    return CreateTxUdpSocketVia4(send_to_addr, remote_port, local_port, interfaceIp);
}
 
#endif      /* IPV6 */
 
  // groupUdpSocket  
 
   // groupNBAPI-UDP
 
#endif      /* #ifndef _NB_UDP_H_ */