tcp.h

Go to the documentation of this file.

/*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
 
 
/* TCP socket status and results */
#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);
 
/*
 *
 * Interval in ticks since last received packet
 *
 *    Parameters:
 *       socket
 *
 *    Return:
 *       Interval is ticks from now until the last received packet
 *
 *    Notes:
 *       Will handle one rollover approx. 6 years but not more than one which
 *       given the timeliness of the use of this function should not matter.
 *
 */
 
uint32_t TcpGetLastRxInterval(int fd);
 
int GetTcpRtxCount(int fd); /* return the number of retransmit counts*/
 
uint8_t SetOutOfOrderbuffers(int fd, uint8_t max);
 
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);
 
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);
 
/*---------------------------------------------------------------------------
 
      Expanded file descriptor callback
 
         Parameters:
            tcpFd             - Actual connection file descriptor
            notifyHandler     - Notification callback
 
         Return:
            None
 
         Notes:
            Data arrival or an connection error state calls this routine.
 
*---------------------------------------------------------------------------*/
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 */