socket.h

Go to the documentation of this file.

 
#ifndef _SOCKET_H
#define _SOCKET_H
 
//Forward declaration of Socket structure
struct _Socket;
#define Socket struct _Socket
 
//Dependencies
#include "core/net.h"
#include "core/ethernet.h"
#include "core/ip.h"
#include "core/tcp.h"
 
//Number of sockets that can be opened simultaneously
#ifndef SOCKET_MAX_COUNT
   #define SOCKET_MAX_COUNT 16
#elif (SOCKET_MAX_COUNT < 1)
   #error SOCKET_MAX_COUNT parameter is not valid
#endif
 
//Maximum number of multicast groups joined
#ifndef SOCKET_MAX_MULTICAST_GROUPS
   #define SOCKET_MAX_MULTICAST_GROUPS 1
#elif (SOCKET_MAX_MULTICAST_GROUPS < 1)
   #error SOCKET_MAX_MULTICAST_GROUPS parameter is not valid
#endif
 
//Dynamic port range (lower limit)
#ifndef SOCKET_EPHEMERAL_PORT_MIN
   #define SOCKET_EPHEMERAL_PORT_MIN 49152
#elif (SOCKET_EPHEMERAL_PORT_MIN < 1024)
   #error SOCKET_EPHEMERAL_PORT_MIN parameter is not valid
#endif
 
//Dynamic port range (upper limit)
#ifndef SOCKET_EPHEMERAL_PORT_MAX
   #define SOCKET_EPHEMERAL_PORT_MAX 65535
#elif (SOCKET_EPHEMERAL_PORT_MAX <= SOCKET_EPHEMERAL_PORT_MIN || SOCKET_EPHEMERAL_PORT_MAX > 65535)
   #error SOCKET_EPHEMERAL_PORT_MAX parameter is not valid
#endif
 
//C++ guard
#ifdef __cplusplus
extern "C" {
#endif
 
 
typedef enum
{
   SOCKET_TYPE_UNUSED  = 0,
   SOCKET_TYPE_STREAM  = 1,
   SOCKET_TYPE_DGRAM   = 2,
   SOCKET_TYPE_RAW_IP  = 3,
   SOCKET_TYPE_RAW_ETH = 4
} SocketType;
 
 
typedef enum
{
   SOCKET_IP_PROTO_ICMP   = 1,
   SOCKET_IP_PROTO_IGMP   = 2,
   SOCKET_IP_PROTO_TCP    = 6,
   SOCKET_IP_PROTO_UDP    = 17,
   SOCKET_IP_PROTO_ICMPV6 = 58
} SocketIpProtocol;
 
 
typedef enum
{
   SOCKET_ETH_PROTO_ALL  = 0x0000,
   SOCKET_ETH_PROTO_LLC  = 0x05DC,
   SOCKET_ETH_PROTO_IPV4 = 0x0800,
   SOCKET_ETH_PROTO_ARP  = 0x0806,
   SOCKET_ETH_PROTO_IPV6 = 0x86DD
} SocketEthProtocol;
 
 
typedef enum
{
   SOCKET_FLAG_PEEK       = 0x0200,
   SOCKET_FLAG_DONT_ROUTE = 0x0400,
   SOCKET_FLAG_WAIT_ALL   = 0x0800,
   SOCKET_FLAG_DONT_WAIT  = 0x0100,
   SOCKET_FLAG_BREAK_CHAR = 0x1000,
   SOCKET_FLAG_BREAK_CRLF = 0x100A,
   SOCKET_FLAG_WAIT_ACK   = 0x2000,
   SOCKET_FLAG_NO_DELAY   = 0x4000,
   SOCKET_FLAG_DELAY      = 0x8000
} SocketFlags;
 
 
//The SOCKET_FLAG_BREAK macro causes the I/O functions to stop reading
//data whenever the specified break character is encountered
#define SOCKET_FLAG_BREAK(c) (SOCKET_FLAG_BREAK_CHAR | LSB(c))
 
 
typedef enum
{
   SOCKET_SD_RECEIVE = 0,
   SOCKET_SD_SEND    = 1,
   SOCKET_SD_BOTH    = 2
} SocketShutdownFlags;
 
 
typedef enum
{
   SOCKET_EVENT_NONE         = 0x0000,
   SOCKET_EVENT_ACCEPT       = 0x0001,
   SOCKET_EVENT_CONNECTED    = 0x0002,
   SOCKET_EVENT_CLOSED       = 0x0004,
   SOCKET_EVENT_TX_READY     = 0x0008,
   SOCKET_EVENT_TX_DONE      = 0x0010,
   SOCKET_EVENT_TX_ACKED     = 0x0020,
   SOCKET_EVENT_TX_SHUTDOWN  = 0x0040,
   SOCKET_EVENT_RX_READY     = 0x0080,
   SOCKET_EVENT_RX_SHUTDOWN  = 0x0100,
   SOCKET_EVENT_LINK_UP      = 0x0200,
   SOCKET_EVENT_LINK_DOWN    = 0x0400
} SocketEvent;
 
 
typedef enum
{
   SOCKET_OPTION_REUSE_ADDR              = 0x0001,
   SOCKET_OPTION_BROADCAST               = 0x0002,
   SOCKET_OPTION_IPV4_MULTICAST_LOOP     = 0x0004,
   SOCKET_OPTION_IPV4_PKT_INFO           = 0x0008,
   SOCKET_OPTION_IPV4_RECV_TOS           = 0x0010,
   SOCKET_OPTION_IPV4_RECV_TTL           = 0x0020,
   SOCKET_OPTION_IPV6_MULTICAST_LOOP     = 0x0040,
   SOCKET_OPTION_IPV6_ONLY               = 0x0080,
   SOCKET_OPTION_IPV6_PKT_INFO           = 0x0100,
   SOCKET_OPTION_IPV6_RECV_TRAFFIC_CLASS = 0x0200,
   SOCKET_OPTION_IPV6_RECV_HOP_LIMIT     = 0x0400,
   SOCKET_OPTION_TCP_NO_DELAY            = 0x0800
} SocketOptions;
 
 
typedef enum
{
   HOST_TYPE_ANY  = 0,
   HOST_TYPE_IPV4 = 16,
   HOST_TYPE_IPV6 = 32
} HostType;
 
 
typedef enum
{
   HOST_NAME_RESOLVER_ANY   = 0,
   HOST_NAME_RESOLVER_DNS   = 1,
   HOST_NAME_RESOLVER_MDNS  = 2,
   HOST_NAME_RESOLVER_NBNS  = 4,
   HOST_NAME_RESOLVER_LLMNR = 8
} HostnameResolver;
 
 
typedef struct
{
   void *data;              
   size_t size;             
   size_t length;           
   uint8_t ttl;             
   uint8_t tos;             
   NetInterface *interface; 
   IpAddr srcIpAddr;        
   uint16_t srcPort;        
   IpAddr destIpAddr;       
   uint16_t destPort;       
#if (ETH_SUPPORT == ENABLED)
   MacAddr srcMacAddr;      
   MacAddr destMacAddr;     
   uint16_t ethType;        
#endif
#if (ETH_PORT_TAGGING_SUPPORT == ENABLED)
   uint8_t switchPort;      
#endif
#if (ETH_TIMESTAMP_SUPPORT == ENABLED)
   int32_t timestampId;     
   NetTimestamp timestamp;  
#endif
} SocketMsg;
 
 
typedef struct _SocketQueueItem
{
   struct _SocketQueueItem *next;
   NetInterface *interface;
   IpAddr srcIpAddr;
   uint16_t srcPort;
   IpAddr destIpAddr;
   NetBuffer *buffer;
   size_t offset;
   NetRxAncillary ancillary;
} SocketQueueItem;
 
 
struct _Socket
{
   uint_t descriptor;
   uint_t type;
   uint_t protocol;
   NetInterface *interface;
   IpAddr localIpAddr;
   uint16_t localPort;
   IpAddr remoteIpAddr;
   uint16_t remotePort;
   uint32_t options;              
   systime_t timeout;
   uint8_t tos;                   
   uint8_t ttl;                   
   uint8_t multicastTtl;          
   IpAddr multicastGroups[SOCKET_MAX_MULTICAST_GROUPS]; 
#if (ETH_VLAN_SUPPORT == ENABLED)
   int8_t vlanPcp;                
   int8_t vlanDei;                
#endif
#if (ETH_VMAN_SUPPORT == ENABLED)
   int8_t vmanPcp;                
   int8_t vmanDei;                
#endif
   int_t errnoCode;
   OsEvent event;
   uint_t eventMask;
   uint_t eventFlags;
   OsEvent *userEvent;
 
//TCP specific variables
#if (TCP_SUPPORT == ENABLED)
   TcpState state;                
   bool_t ownedFlag;              
   bool_t closedFlag;             
   bool_t resetFlag;              
 
   uint16_t mss;                  
   uint16_t smss;                 
   uint16_t rmss;                 
   uint32_t iss;                  
   uint32_t irs;                  
 
   uint32_t sndUna;               
   uint32_t sndNxt;               
   uint16_t sndUser;              
   uint16_t sndWnd;               
   uint16_t maxSndWnd;            
   uint32_t sndWl1;               
   uint32_t sndWl2;               
 
   uint32_t rcvNxt;               
   uint16_t rcvUser;              
   uint16_t rcvWnd;               
 
   bool_t rttBusy;                
   uint32_t rttSeqNum;            
   systime_t rttStartTime;        
   systime_t srtt;                
   systime_t rttvar;              
   systime_t rto;                 
 
#if (TCP_CONGEST_CONTROL_SUPPORT == ENABLED)
   TcpCongestState congestState;  
   uint16_t cwnd;                 
   uint16_t ssthresh;             
   uint_t dupAckCount;            
   uint_t n;                      
   uint32_t recover;              
#endif
 
#if (TCP_KEEP_ALIVE_SUPPORT == ENABLED)
   bool_t keepAliveEnabled;       
   systime_t keepAliveIdle;       
   systime_t keepAliveInterval;   
   uint_t keepAliveMaxProbes;     
   uint_t keepAliveProbeCount;    
   systime_t keepAliveTimestamp;  
#endif
 
#if (TCP_SACK_SUPPORT == ENABLED)
   bool_t sackPermitted;          
#endif
 
   TcpSackBlock sackBlock[TCP_MAX_SACK_BLOCKS]; 
   uint_t sackBlockCount;                       
 
   TcpTxBuffer txBuffer;          
   size_t txBufferSize;           
   TcpRxBuffer rxBuffer;          
   size_t rxBufferSize;           
 
   TcpQueueItem *retransmitQueue; 
   NetTimer retransmitTimer;      
   uint_t retransmitCount;        
 
   TcpSynQueueItem *synQueue;     
   uint_t synQueueSize;           
 
   uint_t wndProbeCount;          
   systime_t wndProbeInterval;    
 
   NetTimer persistTimer;         
   NetTimer overrideTimer;        
   NetTimer finWait2Timer;        
   NetTimer timeWaitTimer;        
#endif
 
//UDP specific variables
#if (UDP_SUPPORT == ENABLED || RAW_SOCKET_SUPPORT == ENABLED)
   SocketQueueItem *receiveQueue;
#endif
};
 
 
typedef struct
{
   Socket *socket;    
   uint_t eventMask;  
   uint_t eventFlags; 
} SocketEventDesc;
 
 
//Global constants
extern const SocketMsg SOCKET_DEFAULT_MSG;
 
//Global variables
extern Socket socketTable[SOCKET_MAX_COUNT];
 
//Socket related functions
error_t socketInit(void);
 
Socket *socketOpen(uint_t type, uint_t protocol);
 
error_t socketSetTimeout(Socket *socket, systime_t timeout);
 
error_t socketSetTtl(Socket *socket, uint8_t ttl);
error_t socketSetMulticastTtl(Socket *socket, uint8_t ttl);
 
error_t socketSetDscp(Socket *socket, uint8_t dscp);
 
error_t socketSetVlanPcp(Socket *socket, uint8_t pcp);
error_t socketSetVlanDei(Socket *socket, bool_t dei);
error_t socketSetVmanPcp(Socket *socket, uint8_t pcp);
error_t socketSetVmanDei(Socket *socket, bool_t dei);
 
error_t socketEnableBroadcast(Socket *socket, bool_t enabled);
error_t socketJoinMulticastGroup(Socket *socket, const IpAddr *groupAddr);
error_t socketLeaveMulticastGroup(Socket *socket, const IpAddr *groupAddr);
 
error_t socketEnableKeepAlive(Socket *socket, bool_t enabled);
 
error_t socketSetKeepAliveParams(Socket *socket, systime_t idle,
   systime_t interval, uint_t maxProbes);
 
error_t socketSetMaxSegmentSize(Socket *socket, size_t mss);
 
error_t socketSetTxBufferSize(Socket *socket, size_t size);
error_t socketSetRxBufferSize(Socket *socket, size_t size);
 
error_t socketSetInterface(Socket *socket, NetInterface *interface);
NetInterface *socketGetInterface(Socket *socket);
 
error_t socketBind(Socket *socket, const IpAddr *localIpAddr,
   uint16_t localPort);
 
error_t socketConnect(Socket *socket, const IpAddr *remoteIpAddr,
   uint16_t remotePort);
 
error_t socketListen(Socket *socket, uint_t backlog);
 
Socket *socketAccept(Socket *socket, IpAddr *clientIpAddr,
   uint16_t *clientPort);
 
error_t socketSend(Socket *socket, const void *data, size_t length,
   size_t *written, uint_t flags);
 
error_t socketSendTo(Socket *socket, const IpAddr *destIpAddr, uint16_t destPort,
   const void *data, size_t length, size_t *written, uint_t flags);
 
error_t socketSendMsg(Socket *socket, const SocketMsg *message, uint_t flags);
 
error_t socketReceive(Socket *socket, void *data,
   size_t size, size_t *received, uint_t flags);
 
error_t socketReceiveFrom(Socket *socket, IpAddr *srcIpAddr, uint16_t *srcPort,
   void *data, size_t size, size_t *received, uint_t flags);
 
error_t socketReceiveEx(Socket *socket, IpAddr *srcIpAddr, uint16_t *srcPort,
   IpAddr *destIpAddr, void *data, size_t size, size_t *received, uint_t flags);
 
error_t socketReceiveMsg(Socket *socket, SocketMsg *message, uint_t flags);
 
error_t socketGetLocalAddr(Socket *socket, IpAddr *localIpAddr,
   uint16_t *localPort);
 
error_t socketGetRemoteAddr(Socket *socket, IpAddr *remoteIpAddr,
   uint16_t *remotePort);
 
error_t socketShutdown(Socket *socket, uint_t how);
void socketClose(Socket *socket);
 
error_t socketPoll(SocketEventDesc *eventDesc, uint_t size, OsEvent *extEvent,
   systime_t timeout);
 
error_t getHostByName(NetInterface *interface, const char_t *name,
   IpAddr *ipAddr, uint_t flags);
 
//C++ guard
#ifdef __cplusplus
}
#endif
 
#endif