udp.h

Go to the documentation of this file.

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _NB_UDP_H_
#define _NB_UDP_H_
#include <predef.h>
#include <ip.h>
 
#ifdef IPV6
struct IPv6FrameProcessingStruct;   // Forward
#endif
 
#ifdef IPV6
struct IP6FRAME;
#endif
 
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();
 
    // Returns true if it was able to receive another packet into this UDP object.
    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   // Do a fragment test
            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   // Do a fragment test
                    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() { return (m_pIP6f != NULL); };
#else
    inline IPADDR4 GetSourceAddress(void) { return GetSourceAddress4(); };
    inline IPADDR4 GetDestinationAddress() { return GetDestinationAddress4(); }
 
    /* Get UDP Packet pointer from network buffer pool buffer */
    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);
 
    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);   // Check the Checksum
 
    void ResetData(void);   // Zero the data buffer and return.
 
    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); }
    // Send destroys the data in the packet.
    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
    // Send and keep makes a copy of this UDP packet and sends it.
    inline void SendAndKeepViaIfAddr(IPADDR4 to, IPADDR4 from_ip, uint8_t ttl = 0) { SendAndKeepViaIfAddr4(to, &from_ip, ttl); }
    // Send destroys the data in the packet.
    inline void SendViaIfAddr(IPADDR4 to, IPADDR4 from_ip, uint8_t ttl = 0) { SendViaIfAddr4(to, &from_ip, ttl); };
#endif   //
#endif   // Multi home
 
    bool process_all_udp();
 
    // Uncomment when C++11 is enabled.
    // UDPPacket & operator = (const UDPPacket & pf) =delete;
 
    // Destructive Copy constructor destroys other UdpPacket
    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);
 
};   // end of UDPPacket Class
 
#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);
 
// INTERNAL FUNCTIONS. Used by the ip.cpp process packet functions
 
void process_udp4(PoolPtr pp, PIPPKT pIP, uint16_t csum);
 
#ifdef IPV6
struct IPv6FrameProcessingStruct;   // Forward
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)    
   // end of groupUDP
 
//----- Wrappers to create a UDP socket interface -----
 
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);
 
// If address is IPV4 you get a IPV4 encoded in IPV6 ie ::FFFF.x.x.x.x
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
 
/* Send a large fragmented UDP packet to is the destination address source_port is the source port dest_port
 * is the destination port data is the data to send length is the length to send.
 *
 * returns 0 on failure, length on success
 */
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
 
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
 
#endif /* #ifndef _NB_UDP_H_ */