tcp.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _NB_TCP_H
#define _NB_TCP_H
 
#include <predef.h>
#include <ip.h>
#include <nettypes.h>
#include <tcp_private.h>
 
#ifndef IPV6
#ifndef IPV4ONLY
#error Must select an IP version in tcp.h
#endif
#endif
 
#ifdef IPV6
#ifdef IPV4ONLY
#error Must select IPV4ONLY or IPV6 but not both
#endif
#endif
 
 
#define TCP_ERR_NORMAL           (0)    
#define TCP_ERR_TIMEOUT         (-1)    
#define TCP_ERR_NOCON           (-2)    
#define TCP_ERR_CLOSING         (-3)    
#define TCP_ERR_NOSUCH_SOCKET   (-4)    
#define TCP_ERR_NONE_AVAIL      (-5)    
#define TCP_ERR_CON_RESET       (-6)    
#define TCP_ERR_CON_ABORT       (-7)    
 int accept(int listening_socket, IPADDR *address, uint16_t *port, uint16_t timeout);
 
#ifdef IPV6
int accept4(int listening_socket, IPADDR4 *address, uint16_t *port, uint16_t timeout);
#define accept6 accept
#else
#define accept4 accept
#endif
 
 
int accept(int listening_socket, IPADDR *address, uint16_t *port, TickTimeout &timeout);
 
 
 
inline int connect(const IPADDR &ipAddress, uint16_t remotePort, uint32_t timeout)
{
    TickTimeout tt(timeout);
    return CoreConnect(ipAddress, 0, remotePort, tt, IPADDR::NullIP(), -1);
};
 
 
 
 
inline int connectvia(const IPADDR &ipAddress, uint16_t remotePort, uint32_t timeout, const IPADDR &localIpAddress)
{
    TickTimeout tt(timeout);
    return CoreConnect(ipAddress, 0, remotePort, tt, localIpAddress, -1);
};
 
inline int connectvia(const IPADDR &ipAddress, uint16_t remotePort, uint32_t timeout, int ifnum)
{
    TickTimeout tt(timeout);
    return CoreConnect(ipAddress, 0, remotePort, tt, IPADDR::NullIP(), ifnum);
};
 
 
 
inline int connectwlocal(const IPADDR &ipAddress,
                         uint16_t localPort,
                         uint16_t remotePort,
                         uint32_t timeout,
                         const IPADDR &localIpAddress = IPADDR::NullIP(),
                         int intf = -1)
{
    TickTimeout tt(timeout);
    return CoreConnect(ipAddress, localPort, remotePort, tt, localIpAddress, intf);
};
 
 
 
#ifdef IPV6
    inline int connect6(const IPADDR &ipAddress, uint16_t remotePort, uint32_t timeout)
    {
        TickTimeout tt(timeout);
        return CoreConnect(ipAddress, 0, remotePort, tt, IPADDR::NullIP(), -1);
    };
    inline int connectvia6(const IPADDR &ipAddress, uint16_t remotePort, uint32_t timeout, const IPADDR &localIpAddress)
    {
        TickTimeout tt(timeout);
        return CoreConnect(ipAddress, 0, remotePort, tt, localIpAddress, -1);
    };
    inline int connectvia6(const IPADDR &ipAddress, uint16_t remotePort, uint32_t timeout, int ifnum)
    {
        TickTimeout tt(timeout);
        return CoreConnect(ipAddress, 0, remotePort, tt, IPADDR::NullIP(), ifnum);
    };
    inline int connectwlocal6(const IPADDR &ipAddress,
                            uint16_t localPort,
                            uint16_t remotePort,
                            uint32_t timeout,
                            const IPADDR &localIpAddress = IPADDR::NullIP(),
                            int ifn = -1)
    {
        TickTimeout tt(timeout);
        return CoreConnect(ipAddress, localPort, remotePort, tt, localIpAddress, ifn);
    };
 
    inline int connect4(IPADDR4 ipAddress, uint16_t remotePort, uint32_t timeout)
    {
        TickTimeout tt(timeout);
        return CoreConnect4(ipAddress, 0, remotePort, tt, IPADDR4::NullIP(), -1);
    };
    inline int connectvia4(IPADDR4 ipAddress, uint16_t remotePort, uint32_t timeout, IPADDR4 localIpAddress)
    {
        TickTimeout tt(timeout);
        return CoreConnect4(ipAddress, 0, remotePort, tt, localIpAddress, -1);
    };
    inline int connectvia4(IPADDR4 ipAddress, uint16_t remotePort, uint32_t timeout, int ifnum)
    {
        TickTimeout tt(timeout);
        return CoreConnect4(ipAddress, 0, remotePort, tt, IPADDR4::NullIP(), ifnum);
    };
    inline int connectwlocal4(IPADDR4 ipAddress,
                            uint16_t localPort,
                            uint16_t remotePort,
                            uint32_t timeout,
                            IPADDR4 localIpAddress = IPADDR4::NullIP(),
                            int ifn = -1)
    {
        TickTimeout tt(timeout);
        return CoreConnect4(ipAddress, localPort, remotePort, tt, localIpAddress, ifn);
    };
#else
    #define connect4 connect
    #define connectvia4 connectvia
    #define connectwlocal4 connectwlocal
#endif
 
inline int connect(const IPADDR &ipAddress, uint16_t remotePort, TickTimeout &timeout)
{
    return CoreConnect(ipAddress, 0, remotePort, timeout, IPADDR::NullIP(), -1);
};
 
 
inline int connectvia(const IPADDR &ipAddress, uint16_t remotePort, TickTimeout &timeout, const IPADDR &localIpAddress)
{
    return CoreConnect(ipAddress, 0, remotePort, timeout, localIpAddress, -1);
};
 
 
inline int connectvia(const IPADDR &ipAddress, uint16_t remotePort, TickTimeout &timeout, int ifnum)
{
    return CoreConnect(ipAddress, 0, remotePort, timeout, IPADDR::NullIP(), ifnum);
};
 
 
inline int connectwlocal(const IPADDR &ipAddress,
                         uint16_t localPort,
                         uint16_t remotePort,
                         TickTimeout timeout,
                         const IPADDR &localIpAddress = IPADDR::NullIP(),
                         int intf = -1)
{
    return CoreConnect(ipAddress, localPort, remotePort, timeout, localIpAddress, intf);
};
 
 
#ifdef IPV6
    inline int connect6(const IPADDR &ipAddress, uint16_t remotePort, TickTimeout &timeout)
    {
        return CoreConnect(ipAddress, 0, remotePort, timeout, IPADDR::NullIP(), -1);
    };
    inline int connectvia6(const IPADDR &ipAddress, uint16_t remotePort, TickTimeout &timeout, const IPADDR &localIpAddress)
    {
        return CoreConnect(ipAddress, 0, remotePort, timeout, localIpAddress, -1);
    };
    inline int connectvia6(const IPADDR &ipAddress, uint16_t remotePort, TickTimeout &timeout, int ifnum)
    {
        return CoreConnect(ipAddress, 0, remotePort, timeout, IPADDR::NullIP(), ifnum);
    };
    inline int connectwlocal6(const IPADDR &ipAddress,
                            uint16_t localPort,
                            uint16_t remotePort,
                            TickTimeout &timeout,
                            const IPADDR &localIpAddress = IPADDR::NullIP(),
                            int ifn = -1)
    {
        return CoreConnect(ipAddress, localPort, remotePort, timeout, localIpAddress, ifn);
    };
 
    inline int connect4(IPADDR4 ipAddress, uint16_t remotePort, TickTimeout &timeout)
    {
        return CoreConnect4(ipAddress, 0, remotePort, timeout, IPADDR4::NullIP(), -1);
    };
    inline int connectvia4(IPADDR4 ipAddress, uint16_t remotePort, TickTimeout &timeout, IPADDR4 localIpAddress)
    {
        return CoreConnect4(ipAddress, 0, remotePort, timeout, localIpAddress, -1);
    };
    inline int connectvia4(IPADDR4 ipAddress, uint16_t remotePort, TickTimeout &timeout, int ifnum)
    {
        return CoreConnect4(ipAddress, 0, remotePort, timeout, IPADDR4::NullIP(), ifnum);
    };
    inline int connectwlocal4(IPADDR4 ipAddress,
                            uint16_t localPort,
                            uint16_t remotePort,
                            TickTimeout &timeout,
                            IPADDR4 localIpAddress = IPADDR4::NullIP(),
                            int ifn = -1)
    {
        return CoreConnect4(ipAddress, localPort, remotePort, timeout, localIpAddress, ifn);
    };
#endif
 
inline int listen(const IPADDR &addr, uint16_t port, uint8_t maxpend = 5)
{
    return CoreListen(addr, port, -1, IPADDR::NullIP(), maxpend);
};
 
 
inline int listenvia(const IPADDR &addr, uint16_t port, int ifn, uint8_t maxpend = 5)
{
    return CoreListen(addr, port, ifn, IPADDR::NullIP(), maxpend);
};
 
inline int listenvia(const IPADDR &addr, uint16_t port, const IPADDR &localIpAddress, uint8_t maxpend = 5)
{
    return CoreListen(addr, port, -1, localIpAddress, maxpend);
};
 
#ifdef IPV6
    inline int listen6(const IPADDR &addr, uint16_t port, uint8_t maxpend = 5)
    {
        return CoreListen(addr, port, -1, IPADDR::NullIP(), maxpend);
    };
 
    inline int listenvia6(const IPADDR &addr, uint16_t port, int ifn, uint8_t maxpend = 5)
    {
        return CoreListen(addr, port, ifn, IPADDR::NullIP(), maxpend);
    };
 
    inline int listenvia6(const IPADDR &addr, uint16_t port, const IPADDR &localIpAddress, uint8_t maxpend = 5)
    {
        return CoreListen(addr, port, -1, localIpAddress, maxpend);
    };
 
    inline int listen4(IPADDR4 addr, uint16_t port, uint8_t maxpend = 5)
    {
        return CoreListen4(addr, port, -1, IPADDR4::NullIP(), maxpend);
    };
 
    inline int listenvia4(IPADDR4 addr, uint16_t port, int ifn, uint8_t maxpend = 5)
    {
        return CoreListen(addr, port, ifn, IPADDR4::NullIP(), maxpend);
    };
 
    inline int listenvia4(IPADDR4 addr, uint16_t port, IPADDR4 localIpAddress, uint8_t maxpend = 5)
    {
        return CoreListen4(addr, port, -1, localIpAddress, maxpend);
    };
#else
    #define listen4 listen
    #define listenvia4 listenvia
#endif
 
inline int NoBlockConnect(const IPADDR &ipAddress, uint16_t remotePort)
{
    return NoBlockCoreConnect(ipAddress, 0, remotePort, IPADDR::NullIP(), -1);
};
 
 
inline int NoBlockConnectVia(const IPADDR &ipAddress, uint16_t remotePort, const IPADDR &interfaceIpAddress = IPADDR::NullIP())
{
    return NoBlockCoreConnect(ipAddress, 0, remotePort, interfaceIpAddress, -1);
};
 
 
inline int NoBlockConnectVia(const IPADDR &ipAddress, uint16_t remotePort, int ifnum)
{
    return NoBlockCoreConnect(ipAddress, 0, remotePort, IPADDR::NullIP(), ifnum);
};
 
 
inline int NoBlockConnectwlocal(const IPADDR &ipAddress,
                                uint16_t localPort,
                                uint16_t remotePort,
                                IPADDR interfaceIpAddress = IPADDR::NullIP(),
                                int ifn = -1)
{
    return NoBlockCoreConnect(ipAddress, localPort, remotePort, interfaceIpAddress, ifn);
};
 
 
#ifdef IPV6
    inline int NoBlockConnect6(const IPADDR &ipAddress, uint16_t remotePort)
    {
        return NoBlockCoreConnect(ipAddress, 0, remotePort, IPADDR::NullIP(), -1);
    };
 
    inline int NoBlockConnectVia6(const IPADDR &ipAddress, uint16_t remotePort, const IPADDR &interfaceIpAddress = IPADDR::NullIP())
    {
        return NoBlockCoreConnect(ipAddress, 0, remotePort, interfaceIpAddress, -1);
    };
 
    inline int NoBlockConnectVia6(const IPADDR &ipAddress, uint16_t remotePort, int ifnum)
    {
        return NoBlockCoreConnect(ipAddress, 0, remotePort, IPADDR::NullIP(), ifnum);
    };
 
    inline int NoBlockConnectwlocal6(const IPADDR &ipAddress, uint16_t localPort, uint16_t remotePort, IPADDR interfaceIpAddress, int ifn = -1)
    {
        return NoBlockCoreConnect(ipAddress, localPort, remotePort, interfaceIpAddress, ifn);
    };
 
    inline int NoBlockConnect4(const IPADDR4 &ipAddress, uint16_t remotePort, uint32_t timeout)
    {
        return NoBlockCoreConnect4(ipAddress, 0, remotePort, IPADDR4::NullIP(), -1);
    };
 
    inline int NoBlockConnectVia4(const IPADDR4 &ipAddress, uint16_t remotePort, const IPADDR4 &interfaceIpAddress = IPADDR4::NullIP())
    {
        return NoBlockCoreConnect4(ipAddress, 0, remotePort, interfaceIpAddress, -1);
    };
 
    inline int NoBlockConnectVia4(const IPADDR4 &ipAddress, uint16_t remotePort, int ifn)
    {
        return NoBlockCoreConnect4(ipAddress, 0, remotePort, IPADDR4::NullIP(), ifn);
    };
 
    inline int NoBlockConnectwlocal4(const IPADDR4 &ipAddress,
                                    uint16_t localPort,
                                    uint16_t remotePort,
                                    const IPADDR4 &interfaceIpAddress,
                                    int ifn = -1)
    {
        return NoBlockCoreConnect4(ipAddress, localPort, remotePort, interfaceIpAddress, ifn);
    };
 
#else
    #define NoBlockConnect4 NoBlockConnect
    #define NoBlockConnectVia4 NoBlockConnectVia
    #define NoBlockConnectwlocal4 NoBlockConnectwlocal
 
#endif
 
int getsocketerror(int fd);
 
 
/* Socket status functions */
IPADDR4 GetSocketRemoteAddr4(int fd);
IPADDR4 GetSocketLocalAddr4(int fd);
 
#ifdef IPV6
    bool bRemoteAddrIsIpV6();
    bool bLocalAddrIsIpV6();
 
    IPADDR GetSocketRemoteAddr6(int fd);
 
    IPADDR GetSocketLocalAddr6(int fd);
 
    inline IPADDR GetSocketRemoteAddr(int fd)
    {
        return GetSocketRemoteAddr6(fd);
    };
 
    inline IPADDR GetSocketLocalAddr(int fd)
    {
        return GetSocketLocalAddr6(fd);
    };
 
#else
    inline IPADDR4 GetSocketRemoteAddr(int fd)
    {
        return GetSocketRemoteAddr4(fd);
    };
    inline IPADDR4 GetSocketLocalAddr(int fd)
    {
        return GetSocketLocalAddr4(fd);
    };
 
#endif
 
uint16_t GetSocketRemotePort(int fd);
uint16_t GetSocketLocalPort(int fd);
 
 
 
/*------------------------------- Keepalive functions --------------------------------*/
 
 
uint32_t TcpGetLastRxTime(int fd);
 
void TcpSendKeepAlive(int fd);
 
uint32_t TcpGetLastRxInterval(int fd);
 
int GetTcpRtxCount(int fd);
 
 
 
uint8_t SetOutOfOrderbuffers(int fd, uint8_t max);  // replaced with inline version below for lower case "buffers"
 
inline uint8_t SetOutOfOrderBuffers(int fd, uint8_t max)
{
    return SetOutOfOrderbuffers(fd, max);
}
 
 
#if defined MULTIHOME || defined AUTOIP
 
    int connectvia4(IPADDR4 addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, IPADDR4 ipa);
    int NoBlockconnectvia4(IPADDR4 addr, uint16_t localport, uint16_t remoteport, IPADDR4 ipa, int intfnum = -1);
    int connectvia4(IPADDR4 addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, int intfnum);
 
    #ifdef IPV6
        int connectvia6(const IPADDR &addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, const IPADDR &ipa);
        inline int connectvia(const IPADDR &addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, const IPADDR &ipa)
        {
            return connectvia6(addr, localport, remoteport, timeout, ipa);
        };
 
        int connectvia6(const IPADDR &addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, int intfnum);
        inline int connectvia(const IPADDR &addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, int intfnum)
        {
            return connectvia6(addr, localport, remoteport, timeout, intfnum);
        };
 
        int NoBlockconnectvia6(IPADDR4 addr, uint16_t localport, uint16_t remoteport, const IPADDR &ipa);
        inline int NoBlockconnectvia(IPADDR4 addr, uint16_t localport, uint16_t remoteport, const IPADDR &ipa)
        {
            return NoBlockconnectvia6(addr, localport, remoteport, ipa);
        };
 
        int NoBlockconnectvia6(IPADDR4 addr, uint16_t localport, uint16_t remoteport, int intfnum);
        inline int NoBlockconnectvia(IPADDR4 addr, uint16_t localport, uint16_t remoteport, int intfnum)
        {
            return NoBlockconnectvia6(addr, localport, remoteport, intfnum);
        };
    #else
        inline int connectvia(IPADDR4 addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, IPADDR4 ipa)
        {
            return connectvia4(addr, localport, remoteport, timeout, ipa);
        };
 
        inline int NoBlockconnectvia(IPADDR4 addr, uint16_t localport, uint16_t remoteport, IPADDR4 ipa)
        {
            return NoBlockconnectvia4(addr, localport, remoteport, ipa);
        };
 
        inline int connectvia(IPADDR4 addr, uint16_t localport, uint16_t remoteport, uint32_t timeout, int intfnum)
        {
            return connectvia4(addr, localport, remoteport, timeout, intfnum);
        };
 
        inline int NoBlockconnectvia(IPADDR4 addr, uint16_t localport, uint16_t remoteport, int intfnum)
        {
            return NoBlockconnectvia4(addr, localport, remoteport, intfnum);
        };
    #endif
#endif
 
/* Get and set the socket options */
 
#define SO_DEBUG    1     
#define SO_NONAGLE  2     
#define SO_NOPUSH   4     
int setsockoption(int fd, int option);
 
int clrsockoption(int fd, int option);
 
int getsockoption(int fd);
 
 
 
// Usae inline function below for camel case correction
int setsocketackbuffers(int fd, uint8_t val);
 
inline int SetSocketUnackBuffers(int fd, uint8_t val)
{
    return setsocketackbuffers(fd, val);
}
 
int SetSocketRxBuffers(int fd, int n);
 
int SetSocketTxBuffers(int fd, int n);
 
 
int abortsocket(int fd);
 
int SockReadWithTimeout(int fd, char *buf, int nbytes, uint32_t timeout);
 
char SocketPeek(int fd);
 
void DumpTcpDebug();
 
void EnableTcpDebug(uint16_t dbFlags);
 
 
#ifdef SPEED_TCP
    typedef void(tcp_data_handler)(int fd, puint8_t data, uint16_t len);
    void RegisterDataProcessor(int fd, tcp_data_handler *pdh);
#endif
 
 
int TcpGetSocketInterface(int fd);
 
 
 
/* TCP socket states RFC 793 (Do not change) */
 
#define TCP_STATE_CLOSED (0)            
#define TCP_STATE_LISTEN (1)            
#define TCP_STATE_SYN_SENT (2)          
#define TCP_STATE_SYN_RCVD (3)          
#define TCP_STATE_WAIT_FOR_ACCEPT (4)   
#define TCP_STATE_ESTABLISHED (5)       
#define TCP_STATE_CLOSE_WAIT (6)        
#define TCP_STATE_LAST_ACK (7)          
#define TCP_STATE_FIN_WAIT_1 (8)        
#define TCP_STATE_FIN_WAIT_2 (9)        
#define TCP_STATE_CLOSING (10)          
#define TCP_STATE_TIME_WAIT (11)        
uint8_t TcpGetSocketState(int fd);
 
uint16_t TcpGetRxBufferSpaceUsed(int fd);
 
uint16_t TcpGetTxBufferAvailSpace(int fd);
 
uint16_t TcpGetTxDataWaiting(int fd);
 
BOOL TcpAllDataAcked(int socket);
 
BOOL WaitForSocketFlush(int fd, uint32_t ticks);
 
 
 
typedef void(tcp_notify_handler)(int tcpFd);
 
void RegisterTCPReadNotify(int tcpFd, tcp_notify_handler *notifyHandler);
 
void RegisterTCPWriteNotify(int tcpFd, tcp_notify_handler *notifyHandler);
/* associate a void * with tcp */
void TCPAssociateExtraData(int tcpFd, void *pData);
void *TCPGetExtraData(int tcpFd);
 
 
 
#ifdef TCP_THROUGHPUT_INFO
    uint64_t TCPGetPayloadBytesSent(int tcpFd);
 
    uint64_t TCPGetPayloadBytesReceived(int tcpFd);
 
    uint64_t TCPGetTotalBytesSent(int tcpFd);
 
    uint64_t TCPGetTotalBytesReceived(int tcpFd);
#endif
 
#endif /* #ifndef _NB_TCP_H */