Controls standard client/server sockets programming options and capabilities. More...

Functions
_i16	sl_Socket (_i16 Domain, _i16 Type, _i16 Protocol)
	Create an endpoint for communication. More...

_i16	sl_Close (_i16 sd)
	Gracefully close socket. More...

_i16	sl_Accept (_i16 sd, SlSockAddr_t addr, SlSocklen_t addrlen)
	Accept a connection on a socket. More...

_i16	sl_Bind (_i16 sd, const SlSockAddr_t *addr, _i16 addrlen)
	Assign a name to a socket. More...

_i16	sl_Listen (_i16 sd, _i16 backlog)
	Listen for connections on a socket. More...

_i16	sl_Connect (_i16 sd, const SlSockAddr_t *addr, _i16 addrlen)
	Initiate a connection on a socket. More...

_i16	sl_Select (_i16 nfds, SlFdSet_t readsds, SlFdSet_t writesds, SlFdSet_t exceptsds, struct SlTimeval_t timeout)
	Monitor socket activity. More...

_i16	sl_SetSockOpt (_i16 sd, _i16 level, _i16 optname, const void *optval, SlSocklen_t optlen)
	Set socket options-. More...

_i16	sl_GetSockOpt (_i16 sd, _i16 level, _i16 optname, void optval, SlSocklen_t optlen)
	Get socket options. More...

_i16	sl_Recv (_i16 sd, void *buf, _i16 len, _i16 flags)
	Read data from TCP socket. More...

_i16	sl_RecvFrom (_i16 sd, void buf, _i16 len, _i16 flags, SlSockAddr_t from, SlSocklen_t *fromlen)
	Read data from socket. More...

_i16	sl_Send (_i16 sd, const void *buf, _i16 len, _i16 flags)
	Write data to TCP socket. More...

_i16	sl_SendTo (_i16 sd, const void buf, _i16 len, _i16 flags, const SlSockAddr_t to, SlSocklen_t tolen)
	Write data to socket. More...

_u32	sl_Htonl (_u32 val)
	Reorder the bytes of a 32-bit unsigned value. More...

_u16	sl_Htons (_u16 val)
	Reorder the bytes of a 16-bit unsigned value. More...

Typedefs
typedef struct SlInAddr_t	SlInAddr_t

typedef struct SlIn6Addr_t	SlIn6Addr_t

typedef _i32	SlTime_t

typedef _i32	SlSuseconds_t

typedef struct SlTimeval_t	SlTimeval_t

typedef _u16	SlSocklen_t

typedef struct SlSockAddr_t	SlSockAddr_t

typedef struct SlSockAddrIn6_t	SlSockAddrIn6_t

typedef struct SlSockAddrIn_t	SlSockAddrIn_t

typedef struct SlFdSet_t	SlFdSet_t

Enumerations
enum	SlTxInhibitThreshold_e { SL_TX_INHIBIT_THRESHOLD_MIN = 1, SL_TX_INHIBIT_THRESHOLD_LOW = 2, SL_TX_INHIBIT_THRESHOLD_DEFAULT = 3, SL_TX_INHIBIT_THRESHOLD_MED = 4, SL_TX_INHIBIT_THRESHOLD_HIGH = 5, SL_TX_INHIBIT_THRESHOLD_MAX = 6 }

enum	SlSockSecureSocketFilesIndex_e { SL_BSD_SECURED_PRIVATE_KEY_IDX = 0, SL_BSD_SECURED_CERTIFICATE_IDX, SL_BSD_SECURED_CA_IDX, SL_BSD_SECURED_DH_IDX }

Detailed Description

Controls standard client/server sockets programming options and capabilities.

Function Documentation

§ sl_Accept()

_i16 sl_Accept	(	_i16	sd,
		SlSockAddr_t *	addr,
		SlSocklen_t *	addrlen
	)

Accept a connection on a socket.

This function is used with connection-based socket types (SOCK_STREAM).
It extracts the first connection request on the queue of pending connections, creates a new connected socket, and returns a new file descriptor referring to that socket.
The newly created socket is not in the listening state. The original socket sd is unaffected by this call.
The argument sd is a socket that has been created with sl_Socket(), bound to a local address with sl_Bind(), and is listening for connections after a sl_Listen(). The argument addr is a pointer to a sockaddr structure. This structure is filled in with the address of the peer socket, as known to the communications layer. The exact format of the address returned addr is determined by the socket's address family.
The addrlen argument is a value-result argument: it should initially contain the size of the structure pointed to by addr, on return it will contain the actual length (in bytes) of the address returned.

Parameters

[in]	sd	Socket descriptor (handle)
[out]	addr	The argument addr is a pointer to a sockaddr structure. This structure is filled in with the address of the peer socket, as known to the communications layer. The exact format of the address returned addr is determined by the socket's address sockaddr: - code for the address format. On this version only AF_INET is supported. - socket address, the length depends on the code format
[out]	addrlen	The addrlen argument is a value-result argument: it should initially contain the size of the structure pointed to by addr

Returns: On success, a socket handle.
On a non-blocking accept a possible negative value is SL_EAGAIN.
On failure, negative error code.
SL_POOL_IS_EMPTY may be return in case there are no resources in the system In this case try again later or increase MAX_CONCURRENT_ACTIONS

See also: sl_Socket sl_Bind sl_Listen

Note: Belongs to server_side

Warning

Definition at line 708 of file sl_socket.c.

 {
     _SlSockAcceptMsg_u       Msg;
     _SlReturnVal_t           RetVal;
     SlSocketAddrResponse_u   AsyncRsp;
 
     _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     Msg.Cmd.Sd = (_u8)sd;
 
     if((addr != NULL) && (addrlen != NULL))
     {
         /* If addr is present, addrlen has to be provided */
         Msg.Cmd.Family = (_u8)((sizeof(SlSockAddrIn_t) == *addrlen) ? SL_AF_INET : SL_AF_INET6);
     }
     else
     {
         /* In any other case, addrlen is ignored */
         Msg.Cmd.Family = (_u8)0;
     }
 
     ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, ACCEPT_ID, (_u8)sd  & SL_BSD_SOCKET_ID_MASK);
 
     if (MAX_CONCURRENT_ACTIONS == ObjIdx)
     {
         return SL_POOL_IS_EMPTY;
     }
     
     /* send the command */
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlAcceptCmdCtrl, &Msg, NULL));
     VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
 
     RetVal = Msg.Rsp.StatusOrLen;
 
     if(SL_OS_RET_CODE_OK == RetVal)
     {
 #ifndef SL_TINY    
         /* in case socket is non-blocking one, the async event should be received immediately */
         if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
         {
             SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
                                          SL_DRIVER_TIMEOUT_SHORT,
                                          SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE
                                          );
         }
         else
 #endif         
         {
             /* wait for async and get Data Read parameters */
             SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
         }
 
         VERIFY_PROTOCOL(AsyncRsp.IpV4.Sd == (_u8)sd);
 
         RetVal = AsyncRsp.IpV4.StatusOrLen;
 #if 0 /*  Kept for backup */
             _SlSocketParseAddress(&AsyncRsp, addr, addrlen);
 #else
          if((addr != NULL) && (addrlen != NULL))
          {
            addr->sa_family = AsyncRsp.IpV4.Family;
 
             if(SL_AF_INET == addr->sa_family)
             {
               if( *addrlen == (SlSocklen_t)sizeof( SlSockAddrIn_t ) )
               {
                 ((SlSockAddrIn_t *)addr)->sin_port         = AsyncRsp.IpV4.Port;
                 ((SlSockAddrIn_t *)addr)->sin_addr.s_addr  = AsyncRsp.IpV4.Address;
               }
               else
               {
                 *addrlen = 0;
               }
             }
 #ifdef SL_SUPPORT_IPV6
             else if(SL_AF_INET6 == addr->sa_family)
             {
               if( *addrlen == sizeof( SlSockAddrIn6_t ) )
               {
                 ((SlSockAddrIn6_t *)addr)->sin6_port                   = AsyncRsp.IpV6.Port    ;
                 sl_Memcpy(((SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, AsyncRsp.IpV6.Address, 16);
               }
               else
               {
                 *addrlen = 0;
               }
             }
 #endif
          }
 #endif
     }
 
     _SlDrvReleasePoolObj(ObjIdx);
     return (_i16)RetVal;
 }

§ sl_Bind()

_i16 sl_Bind	(	_i16	sd,
		const SlSockAddr_t *	addr,
		_i16	addrlen
	)

Assign a name to a socket.

This function gives the socket the local address addr. addr is addrlen bytes long. Traditionally, this is called When a socket is created with socket, it exists in a name space (address family) but has no name assigned. It is necessary to assign a local address before a SOCK_STREAM socket may receive connections.

Parameters

[in]	sd	Socket descriptor (handle)
[in]	addr	Specifies the destination addrs sockaddr: - code for the address format. On this version only SL_AF_INET is supported. - socket address, the length depends on the code format
[in]	addrlen	Contains the size of the structure pointed to by addr

Returns: Zero on success, or negative error code on failure

See also: sl_Socket sl_Accept sl_Listen

Note: belongs to basic_api

Warning

Definition at line 247 of file sl_socket.c.

 {
     _SlSockBindMsg_u    Msg;
     _SlCmdCtrl_t        CmdCtrl = {0, 0, (_SlArgSize_t)sizeof(SlSocketResponse_t)};
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     switch(addr->sa_family)
     {
         case SL_AF_INET :
             CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND;
             CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(SlSocketAddrIPv4Command_t);
             break;
 #ifndef SL_TINY
 #ifdef SL_SUPPORT_IPV6
         case SL_AF_INET6:
             CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
             CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(SlSocketAddrIPv6Command_t);
             break;
 #endif
 #endif
 
         case SL_AF_RF   :
         default:
             return SL_RET_CODE_INVALID_INPUT;
     }
 
     Msg.Cmd.IpV4.LenOrPadding = 0;
     Msg.Cmd.IpV4.Sd = (_u8)sd;
 
     _SlSocketBuildAddress(addr, &Msg.Cmd);
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
 
     return Msg.Rsp.StatusOrLen;
 }

§ sl_Close()

_i16 sl_Close ( _i16 sd )

Gracefully close socket.

This function causes the system to release resources allocated to a socket.
In case of TCP, the connection is terminated.

Parameters

[in] sd Socket handle (received in sl_Socket)

Returns: Zero on success, or negative error code on failure

See also: sl_Socket

Note: belongs to ext_api

Warning

Definition at line 187 of file sl_socket.c.

 {
     _SlSockCloseMsg_u    Msg;
     _u8 ObjIdx =         MAX_CONCURRENT_ACTIONS;
     SlSocketResponse_t   AsyncRsp;
     _SlReturnVal_t       RetVal;
     _u8 bSocketInAction = FALSE;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     Msg.Cmd.Sd = (_u8)sd;
     _SlDrvMemZero(&AsyncRsp, sizeof(SlSocketResponse_t));
 
     /* check if the socket has already action in progress */
     bSocketInAction = !!(g_pCB->ActiveActionsBitmap & (1<<sd));
 
     if (bSocketInAction == FALSE)
     {
         ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CLOSE_ID, (_u8)(sd  & SL_BSD_SOCKET_ID_MASK));
 
         if (MAX_CONCURRENT_ACTIONS == ObjIdx)
         {
             return SL_POOL_IS_EMPTY;
         }
     }
 
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSockCloseCmdCtrl, &Msg, NULL));
     
     RetVal = Msg.Rsp.StatusOrLen;
 
     if (bSocketInAction == FALSE)
     {
          if( SL_RET_CODE_OK == RetVal)
         {   
              SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
                             SL_DRIVER_TIMEOUT_LONG,
                             SL_OPCODE_SOCKET_SOCKETCLOSEASYNCEVENT
                             );
             RetVal = AsyncRsp.StatusOrLen;
         }
 
         _SlDrvReleasePoolObj(ObjIdx);
     }
 
     return RetVal;
 }

§ sl_Connect()

_i16 sl_Connect	(	_i16	sd,
		const SlSockAddr_t *	addr,
		_i16	addrlen
	)

Initiate a connection on a socket.

Function connects the socket referred to by the socket descriptor sd, to the address specified by addr. The addrlen argument specifies the size of addr. The format of the address in addr is determined by the address space of the socket. If it is of type SOCK_DGRAM, this call specifies the peer with which the socket is to be associated; this address is that to which datagrams are to be sent, and the only address from which datagrams are to be received. If the socket is of type SOCK_STREAM, this call attempts to make a connection to another socket. The other socket is specified by address, which is an address in the communications space of the socket.

Parameters

[in]	sd	Socket descriptor (handle)
[in]	addr	Specifies the destination addr sockaddr: - code for the address format. On this version only AF_INET is supported. - socket address, the length depends on the code format
[in]	addrlen	Contains the size of the structure pointed to by addr

Returns: On success, a socket handle.
On a non-blocking connect a possible negative value is SL_EALREADY. On failure, negative value.
SL_POOL_IS_EMPTY may be return in case there are no resources in the system In this case try again later or increase MAX_CONCURRENT_ACTIONS

See also: sl_Socket

Note: belongs to client_side

Warning

Definition at line 464 of file sl_socket.c.

 {
       _SlSockConnectMsg_u  Msg;
       _SlReturnVal_t       RetVal;
       _SlCmdCtrl_t         CmdCtrl = {0, (_SlArgSize_t)0, (_SlArgSize_t)sizeof(SlSocketResponse_t)};
       SlSocketResponse_t   AsyncRsp;
       _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
     _SlDrvMemZero(&AsyncRsp, sizeof(SlSocketResponse_t));
 
     switch(addr->sa_family)
     {
         case SL_AF_INET :
             CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT;
             CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(SlSocketAddrIPv4Command_t);
             /* Do nothing - cmd already initialized to this type */
             break;
 #ifdef SL_SUPPORT_IPV6
         case SL_AF_INET6:
             CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
             CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(SlSocketAddrIPv6Command_t);
             break;
 #endif
         case SL_AF_RF:
         default:
             return SL_RET_CODE_INVALID_INPUT;
     }
 
     Msg.Cmd.IpV4.LenOrPadding = 0;
     Msg.Cmd.IpV4.Sd = (_u8)sd;
 
     _SlSocketBuildAddress(addr, &Msg.Cmd);
 
     ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CONNECT_ID, (_u8)(sd  & SL_BSD_SOCKET_ID_MASK));
 
     if (MAX_CONCURRENT_ACTIONS == ObjIdx)
     {
         return SL_POOL_IS_EMPTY;
     }
 
     /* send the command */
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
     VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
 
     RetVal = Msg.Rsp.StatusOrLen;
 
     if(SL_RET_CODE_OK == RetVal)
     {
 #ifndef SL_TINY    
         /*In case socket is non-blocking one, the async event should be received immediately */
         if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
         {
             SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
                                           SL_DRIVER_TIMEOUT_SHORT,
                                           SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE
                                           );
         }
         else
 #endif         
         {
 
             /* wait for async and get Data Read parameters */
             SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
         }
 
         VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
         RetVal = AsyncRsp.StatusOrLen;
     }
 
     _SlDrvReleasePoolObj(ObjIdx);
     return RetVal;
 }

§ sl_GetSockOpt()

_i16 sl_GetSockOpt	(	_i16	sd,
		_i16	level,
		_i16	optname,
		void *	optval,
		SlSocklen_t *	optlen
	)

Get socket options.

This function manipulate the options associated with a socket. Options may exist at multiple protocol levels; they are always present at the uppermost socket level.
When manipulating socket options the level at which the option resides and the name of the option must be specified. To manipulate options at the socket level, level is specified as SOL_SOCKET. To manipulate options at any other level the protocol number of the appropriate proto- col controlling the option is supplied. For example, to indicate that an option is to be interpreted by the TCP protocol, level should be set to the protocol number of TCP;
The parameters optval and optlen are used to access optval - ues for setsockopt(). For getsockopt() they identify a buffer in which the value for the requested option(s) are to be returned. For getsockopt(), optlen is a value-result parameter, initially containing the size of the buffer pointed to by option_value, and modified on return to indicate the actual size of the value returned. If no option value is to be supplied or returned, option_value may be NULL.

Parameters

[in]	sd	Socket handle
[in]	level	Defines the protocol level for this option
[in]	optname	defines the option name to interrogate
[out]	optval	Specifies a value for the option
[out]	optlen	Specifies the length of the option value

Returns: Zero on success, or negative error code on failure

See also: sl_SetSockOpt

Note: See sl_SetSockOpt Belongs to ext_api

Warning

Definition at line 986 of file sl_socket.c.

 {
     _SlGetSockOptMsg_u    Msg;
     _SlCmdExt_t           CmdExt;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
     if (*optlen == 0)
     {
         return SL_EZEROLEN;
     }
 
     _SlDrvResetCmdExt(&CmdExt);
     CmdExt.RxPayloadLen = (_i16)(*optlen);
     CmdExt.pRxPayload = optval;
 
     Msg.Cmd.Sd = (_u8)sd;
     Msg.Cmd.Level = (_u8)level;
     Msg.Cmd.OptionLen = (_u8)(*optlen);
     Msg.Cmd.OptionName = (_u8)optname;
 
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlGetSockOptCmdCtrl, &Msg, &CmdExt));
 
     if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen) 
     {
         *optlen = Msg.Rsp.OptionLen;
         return SL_ESMALLBUF;
     }
     else
     {
         *optlen = (_u8)CmdExt.ActualRxPayloadLen;
     }
     return (_i16)Msg.Rsp.Status;
 }

§ sl_Htonl()

_u32 sl_Htonl ( _u32 val )

Reorder the bytes of a 32-bit unsigned value.

This function is used to Reorder the bytes of a 32-bit unsigned value from processor order to network order.

Parameters

[in] val Variable to reorder

Returns: Return the reorder variable,

See also: sl_SendTo sl_Bind sl_Connect sl_RecvFrom sl_Accept

Note: Belongs to send_api

Warning

Definition at line 813 of file sl_socket.c.

 {
   _u32 i = 1; 
   _i8 *p = (_i8 *)&i;  
   if (p[0] == 1) /* little endian */
   {
     p[0] = ((_i8* )&val)[3];
     p[1] = ((_i8* )&val)[2];
     p[2] = ((_i8* )&val)[1];
     p[3] = ((_i8* )&val)[0];
     return i;
   }
   else /* big endian */
   {
     return val; 
   }
 }

§ sl_Htons()

_u16 sl_Htons ( _u16 val )

Reorder the bytes of a 16-bit unsigned value.

This function is used to Reorder the bytes of a 16-bit unsigned value from processor order to network order.

Parameters

[in] val Variable to reorder

Returns: Return the reorder variable,

See also: sl_SendTo sl_Bind sl_Connect sl_RecvFrom sl_Accept

Note: Belongs to send_api

Warning

Definition at line 834 of file sl_socket.c.

 {
   _i16 i = 1; 
   _i8 *p = (_i8 *)&i;  
   if (p[0] == 1) /* little endian */
   {
     p[0] = ((_i8* )&val)[1];
     p[1] = ((_i8* )&val)[0];
     return (_u16)i;
   }
   else /* big endian */
   {
     return val; 
   }
 }

§ sl_Listen()

_i16 sl_Listen	(	_i16	sd,
		_i16	backlog
	)

Listen for connections on a socket.

The willingness to accept incoming connections and a queue limit for incoming connections are specified with listen(), and then the connections are accepted with accept. The listen() call applies only to sockets of type SOCK_STREAM The backlog parameter defines the maximum length the queue of pending connections may grow to.

Parameters

[in]	sd	Socket descriptor (handle)
[in]	backlog	Specifies the listen queue depth.

Returns: Zero on success, or negative error code on failure

See also: sl_Socket sl_Accept sl_Bind

Note: Belongs to server_side

Warning

Definition at line 672 of file sl_socket.c.

 {
     _SlListenMsg_u  Msg;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     Msg.Cmd.Sd = (_u8)sd;
     Msg.Cmd.Backlog = (_u8)backlog;
 
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlListenCmdCtrl, &Msg, NULL));
     return (_i16)Msg.Rsp.status;
 }

§ sl_Recv()

_i16 sl_Recv	(	_i16	sd,
		void *	buf,
		_i16	len,
		_i16	flags
	)

Read data from TCP socket.

Function receives a message from a connection-mode socket

Parameters

[in]	sd	Socket handle
[out]	buf	Points to the buffer where the message should be stored.
[in]	len	Specifies the length in bytes of the buffer pointed to by the buffer argument. Range: 1-16000 bytes
[in]	flags	Specifies the type of message reception. On this version, this parameter is not supported.

Returns: Return the number of bytes received, or a negative value if an error occurred.
Using a non-blocking recv a possible negative value is SL_EAGAIN.
SL_POOL_IS_EMPTY may be return in case there are no resources in the system In this case try again later or increase MAX_CONCURRENT_ACTIONS

See also: sl_RecvFrom

Note: Belongs to recv_api

Warning

Examples

Receiving data using TCP socket:
SlSockAddrIn_t Addr;
SlSockAddrIn_t LocalAddr;
_i16 AddrSize = sizeof(SlSockAddrIn_t);
_i16 SockID, newSockID;
_i16 Status;
_i8 Buf[RECV_BUF_LEN];
LocalAddr.sin_family = SL_AF_INET;
LocalAddr.sin_port = sl_Htons(5001);
LocalAddr.sin_addr.s_addr = 0;
Addr.sin_family = SL_AF_INET;
Addr.sin_port = sl_Htons(5001);
Addr.sin_addr.s_addr = sl_Htonl(SL_IPV4_VAL(10,1,1,200));
SockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, 0);
Status = sl_Bind(SockID, (SlSockAddr_t *)&LocalAddr, AddrSize);
Status = sl_Listen(SockID, 0);
newSockID = sl_Accept(SockID, (SlSockAddr_t*)&Addr, (SlSocklen_t*) &AddrSize);
Status = sl_Recv(newSockID, Buf, 1460, 0);
Rx transceiver mode using a raw socket:
_i8 buffer[1536];
_i16 sd;
_u16 size;
SlTransceiverRxOverHead_t *transHeader;
sd = sl_Socket(SL_AF_RF,SL_SOCK_RAW,11); // channel 11
while(1)
{
size = sl_Recv(sd,buffer,1536,0);
transHeader = (SlTransceiverRxOverHead_t *)buffer;
printf("RSSI is %d frame type is 0x%x size %d\n",transHeader->rssi,buffer[sizeof(SlTransceiverRxOverHead_t)],size);
}

Definition at line 892 of file sl_socket.c.

 {
     _SlRecvMsg_u    Msg;
     _SlCmdExt_t     CmdExt;
     _SlReturnVal_t status;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     _SlDrvResetCmdExt(&CmdExt);
     CmdExt.RxPayloadLen = Len;
     CmdExt.pRxPayload = (_u8 *)pBuf;
 
     Msg.Cmd.Sd = (_u8)sd;
     Msg.Cmd.StatusOrLen = (_u16)Len;
 
     /*  no size truncation in recv path */
     CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
 
     Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
 
     status = _SlDrvDataReadOp((_SlSd_t)sd, (_SlCmdCtrl_t *)&_SlRecvCmdCtrl, &Msg, &CmdExt);
     if( status != SL_OS_RET_CODE_OK )
     {
         return status;
     }
      
     /*  if the Device side sends less than expected it is not the Driver's role */
     /*  the returned value could be smaller than the requested size */
     return (_i16)Msg.Rsp.StatusOrLen;
 }

§ sl_RecvFrom()

_i16 sl_RecvFrom	(	_i16	sd,
		void *	buf,
		_i16	len,
		_i16	flags,
		SlSockAddr_t *	from,
		SlSocklen_t *	fromlen
	)

Read data from socket.

Function receives a message from a connection-mode or connectionless-mode socket

Parameters

[in]	sd	Socket handle
[out]	buf	Points to the buffer where the message should be stored.
[in]	len	Specifies the length in bytes of the buffer pointed to by the buffer argument. Range: 1-16000 bytes
[in]	flags	Specifies the type of message reception. On this version, this parameter is not supported.
[in]	from	Pointer to an address structure indicating the source address. sockaddr: - code for the address format. On this version only AF_INET is supported. - socket address, the length depends on the code format
[in]	fromlen	Source address structure size. This parameter MUST be set to the size of the structure pointed to by addr.

Returns: Return the number of bytes received, or a negative value if an error occurred.
Using a non-blocking recv a possible negative value is SL_EAGAIN. SL_RET_CODE_INVALID_INPUT (-2) will be returned if fromlen has incorrect length.
SL_POOL_IS_EMPTY may be return in case there are no resources in the system In this case try again later or increase MAX_CONCURRENT_ACTIONS

See also: sl_Recv

Note: Belongs to recv_api

Warning

Example

Receiving data:
SlSockAddrIn_t Addr;
SlSockAddrIn_t LocalAddr;
_i16 AddrSize = sizeof(SlSockAddrIn_t);
_i16 SockID;
_i16 Status;
_i8 Buf[RECV_BUF_LEN];
LocalAddr.sin_family = SL_AF_INET;
LocalAddr.sin_port = sl_Htons(5001);
LocalAddr.sin_addr.s_addr = 0;
SockID = sl_Socket(SL_AF_INET,SL_SOCK_DGRAM, 0);
Status = sl_Bind(SockID, (SlSockAddr_t *)&LocalAddr, AddrSize);
Status = sl_RecvFrom(SockID, Buf, 1472, 0, (SlSockAddr_t *)&Addr, (SlSocklen_t*)&AddrSize);

Definition at line 375 of file sl_socket.c.

 {
     _SlRecvfromMsg_u    Msg;
     _SlCmdExt_t         CmdExt;
     _i16                 RetVal;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     /* RAW transceiver use only sl_Recv  */
     if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
     {
         return SL_ERROR_BSD_SOC_ERROR;
     }
 
     _SlDrvResetCmdExt(&CmdExt);
     CmdExt.RxPayloadLen = Len;
     CmdExt.pRxPayload = (_u8 *)buf;
 
     Msg.Cmd.Sd = (_u8)sd;
     Msg.Cmd.StatusOrLen = (_u16)Len;
     
     /*  no size truncation in recv path */
     CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
 
     Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
 
     if(sizeof(SlSockAddrIn_t) == *fromlen)
     {
         Msg.Cmd.FamilyAndFlags |= (SL_AF_INET << 4);
     }
     else if (sizeof(SlSockAddrIn6_t) == *fromlen)
     {
         Msg.Cmd.FamilyAndFlags |= (SL_AF_INET6 << 4);
     }
     else
     {
         return SL_RET_CODE_INVALID_INPUT;
     }
 
     RetVal = _SlDrvDataReadOp((_SlSd_t)sd, (_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
     if( RetVal != SL_OS_RET_CODE_OK )
     {
        return RetVal;
     }
 
     RetVal = Msg.Rsp.IpV4.StatusOrLen;
 
     if(RetVal >= 0)
     {
         VERIFY_PROTOCOL(sd == (_i16)Msg.Rsp.IpV4.Sd);
 #if 0
         _SlSocketParseAddress(&Msg.Rsp, from, fromlen);
 #else
         from->sa_family = Msg.Rsp.IpV4.Family;
         if(SL_AF_INET == from->sa_family)
         {
             ((SlSockAddrIn_t *)from)->sin_port = Msg.Rsp.IpV4.Port;
             ((SlSockAddrIn_t *)from)->sin_addr.s_addr = Msg.Rsp.IpV4.Address;
             *fromlen = (SlSocklen_t)sizeof(SlSockAddrIn_t);
         }
 #ifdef SL_SUPPORT_IPV6
         else if(SL_AF_INET6 == from->sa_family)
         {
             VERIFY_PROTOCOL(*fromlen >= sizeof(SlSockAddrIn6_t));
 
             ((SlSockAddrIn6_t *)from)->sin6_port = Msg.Rsp.IpV6.Port;
             sl_Memcpy(((SlSockAddrIn6_t *)from)->sin6_addr._S6_un._S6_u32, Msg.Rsp.IpV6.Address, 16);
             *fromlen = sizeof(SlSockAddrIn6_t);
         }
 #endif
 #endif
     }
 
     return (_i16)RetVal;
 }

§ sl_Select()

_i16 sl_Select	(	_i16	nfds,
		SlFdSet_t *	readsds,
		SlFdSet_t *	writesds,
		SlFdSet_t *	exceptsds,
		struct SlTimeval_t *	timeout
	)

Monitor socket activity.

Select allow a program to monitor multiple file descriptors, waiting until one or more of the file descriptors become "ready" for some class of I/O operation. If trigger mode is enabled the active fdset is the one that was retrieved in the first triggered call. To enable the trigger mode, an handler must be statically registered as slcb_SocketTriggerEventHandler in user.h

Parameters

[in]	nfds	The highest-numbered file descriptor in any of the three sets, plus 1.
[out]	readsds	Socket descriptors list for read monitoring and accept monitoring
[out]	writesds	Socket descriptors list for connect monitoring only, write monitoring is not supported
[out]	exceptsds	Socket descriptors list for exception monitoring, not supported.
[in]	timeout	Is an upper bound on the amount of time elapsed before select() returns. Null or above 0xffff seconds means infinity timeout. The minimum timeout is 10 milliseconds, less than 10 milliseconds will be set automatically to 10 milliseconds. Max microseconds supported is 0xfffc00. In trigger mode the timout fields must be set to zero.

Returns: On success, select() returns the number of file descriptors contained in the three returned descriptor sets (that is, the total number of bits that are set in readfds, writefds, exceptfds) which may be zero if the timeout expires before anything interesting happens.
On error, a negative value is returned. readsds - return the sockets on which read request will return without delay with valid data.
writesds - return the sockets on which write request will return without delay.
exceptsds - return the sockets closed recently.
SL_POOL_IS_EMPTY may be return in case there are no resources in the system In this case try again later or increase MAX_CONCURRENT_ACTIONS

See also: sl_Socket

Note: If the timeout value set to less than 10ms it will automatically set to 10ms to prevent overload of the system
Belongs to basic_api

Several threads can call sl_Select at the same time.Calling this API while the same command is called from another thread, may result in one of the following scenarios:

The command will be executed alongside other select callers (success).
The command will wait (internal) until the previous sl_select finish, and then be executed.
There are not enough resources and SL_POOL_IS_EMPTY error will return. In this case, MAX_CONCURRENT_ACTIONS can be increased (result in memory increase) or try again later to issue the command.

In case all the user sockets are open, sl_Select will exhibit the behaviour mentioned in (2) This is due to the fact sl_select supports multiple callers by utilizing one user socket internally. User who wish to ensure multiple select calls at any given time, must reserve one socket out of the 16 given.

Warning: multiple select calls aren't supported when trigger mode is active. The two are mutually exclusive.

Definition at line 1728 of file sl_socket.c.

 {
     _SlSelectMsg_u            Msg;
     SlSelectAsyncResponse_t   AsyncRsp;
     _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler)))
     _u8 IsNonBlocking = FALSE;
 #endif
 
     /* verify that this API is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler)))
     if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
     {
         if( NULL != timeout )
         {
             /* Set that we are in Non-Blocking mode */
             if ( (0 == timeout->tv_sec) && (0 == timeout->tv_usec) )
             {
                 IsNonBlocking = TRUE;
             }
             else
             {
                SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
 
                /* If there is a trigger select running in the progress abort the new blocking request */
                if (g_pCB->SocketTriggerSelect.Info.State > SOCK_TRIGGER_READY)
                {
                     SL_DRV_PROTECTION_OBJ_UNLOCK();
                     return SL_RET_CODE_SOCKET_SELECT_IN_PROGRESS_ERROR;
                }
 
                SL_DRV_PROTECTION_OBJ_UNLOCK();
             }
 
             if (IsNonBlocking == TRUE)
             {
                 /* return EAGAIN if we alreay have select trigger in progress */
                 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
                 {
                     return SL_ERROR_BSD_EAGAIN;
                 }
                 /* return the stored response if already received */
                 else if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_RESP_RECEIVED)
                 {
 
                     if(  ((_i16)g_pCB->SocketTriggerSelect.Resp.Status) >= 0 )
                     {
                         if( readsds )
                         {
                            readsds->fd_array[0]  = g_pCB->SocketTriggerSelect.Resp.ReadFds;
                         }
                         if( writesds )
                         {
                            writesds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.WriteFds;
                         }
                     }
 
                     /* Now relaese the pool object */
                     _SlDrvReleasePoolObj(g_pCB->SocketTriggerSelect.Info.ObjPoolIdx);
 
                     g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = MAX_CONCURRENT_ACTIONS;
 
                     /* Reset the socket select trigger object */
                     g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_READY;
 
                     return (_i16)g_pCB->SocketTriggerSelect.Resp.Status;
                 }
             }
         }
     }
 #endif
 
     Msg.Cmd.Nfds          = (_u8)nfds;
     Msg.Cmd.ReadFdsCount  = 0;
     Msg.Cmd.WriteFdsCount = 0;
 
     Msg.Cmd.ReadFds = 0;
     Msg.Cmd.WriteFds = 0;
 
 
     if( readsds )
     {
        Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
     }
     if( writesds )
     {
        Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
     }
     if( NULL == timeout )
     {
         Msg.Cmd.tv_sec = 0xffff;
         Msg.Cmd.tv_usec = 0xffff;
     }
     else
     {
         if( 0xffff <= timeout->tv_sec )
         {
             Msg.Cmd.tv_sec = 0xffff;
         }
         else
         {
             Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
         }
 
         /*  convert to milliseconds */
         timeout->tv_usec = timeout->tv_usec >> 10;
 
         if( 0xffff <= timeout->tv_usec )
         {
             Msg.Cmd.tv_usec = 0xffff;
         }
         else
         {
             Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
         }
 
     }
 
     /* Use Obj to issue the command, if not available try later */
     ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, SELECT_ID, SL_MAX_SOCKETS);
 
     if (MAX_CONCURRENT_ACTIONS == ObjIdx)
     {
         return SL_POOL_IS_EMPTY;
     }
 
     /* send the command */
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
 
     if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
     {
         SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
 
         Msg.Rsp.status = (_i16)AsyncRsp.Status;
 
         /* this code handles the socket trigger mode case */
 #if((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler)))
         if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
         {
             /* if no data returned and we are in trigger mode,
                send another select cmd but now with timeout infinite,
                and return immediately with EAGAIN to the user */
             if ((IsNonBlocking == TRUE) && (AsyncRsp.Status == 0))
             {
                 /* set the select trigger-in-progress bit */
                 g_pCB->SocketTriggerSelect.Info.State  = SOCK_TRIGGER_WAITING_FOR_RESP;
 
                 Msg.Cmd.tv_sec = 0xffff;
                 Msg.Cmd.tv_usec = 0xffff;
 
                 /* Release pool object and try to take another call */
                 _SlDrvReleasePoolObj(ObjIdx);
 
                 /* Use Obj to issue the command, if not available try later */
                 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&g_pCB->SocketTriggerSelect.Resp, SELECT_ID, SL_MAX_SOCKETS);
 
                 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
                 {
                     return SL_POOL_IS_EMPTY;
                 }
 
                 /* Save the pool index to be released only after the user read the response  */
                 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = ObjIdx;
 
                 /* send the command */
                 VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
                 return SL_ERROR_BSD_EAGAIN;
 
             }
         }
 #endif
 
         if(  ((_i16)Msg.Rsp.status) >= 0 )
         {
             if( readsds )
             {
                readsds->fd_array[0]  = AsyncRsp.ReadFds;
             }
             if( writesds )
             {
                writesds->fd_array[0] = AsyncRsp.WriteFds;
             }
         }
     }
 
     _SlDrvReleasePoolObj(ObjIdx);
     return (_i16)Msg.Rsp.status;
 }

§ sl_Send()

_i16 sl_Send	(	_i16	sd,
		const void *	buf,
		_i16	len,
		_i16	flags
	)

Write data to TCP socket.

This function is used to transmit a message to another socket. Returns immediately after sending data to device. In case of TCP failure an async event SL_SOCKET_TX_FAILED_EVENT is going to be received.
In case of a RAW socket (transceiver mode), extra 4 bytes should be reserved at the end of the frame data buffer for WLAN FCS

Parameters

[in]	sd	Socket handle
[in]	buf	Points to a buffer containing the message to be sent
[in]	len	Message size in bytes. Range: 1-1460 bytes
[in]	flags	Specifies the type of message transmission. On this version, this parameter is not supported for TCP. For transceiver mode, the SL_WLAN_RAW_RF_TX_PARAMS macro can be used to determine transmission parameters (channel,rate,tx_power,preamble)

Returns: Zero on success, or negative error code on failure

See also: sl_SendTo

Note: Belongs to send_api

Warning

Example

Sending data:
SlSockAddrIn_t Addr;
_i16 AddrSize = sizeof(SlSockAddrIn_t);
_i16 SockID;
_i16 Status;
_i8 Buf[SEND_BUF_LEN];
Addr.sin_family = SL_AF_INET;
Addr.sin_port = sl_Htons(5001);
Addr.sin_addr.s_addr = sl_Htonl(SL_IPV4_VAL(10,1,1,200));
SockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, 0);
Status = sl_Connect(SockID, (SlSockAddr_t *)&Addr, AddrSize);
Status = sl_Send(SockID, Buf, 1460, 0 );

Definition at line 606 of file sl_socket.c.

 {
     _SlSendMsg_u   Msg;
     _SlCmdExt_t    CmdExt;
     _i16            RetVal;
     _u32         tempVal;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     _SlDrvResetCmdExt(&CmdExt);
     CmdExt.TxPayload1Len = (_u16)Len;
     CmdExt.pTxPayload1 = (_u8 *)pBuf;
     
     /* Only for RAW transceiver type socket, relay the flags parameter in the 2 bytes (4 byte aligned) before the actual payload */
     if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
     {
         tempVal = (_u32)flags;
         CmdExt.pRxPayload = (_u8 *)&tempVal;
         CmdExt.RxPayloadLen = -4; /* the (-) sign is used to mark the rx buff as output buff as well*/
     }
     else
     {
         CmdExt.pRxPayload = NULL;
         if (Len < 1)
         {
           /* ignore */
           return 0;
         }
     }
 
     Msg.Cmd.StatusOrLen = Len;
     Msg.Cmd.Sd = (_u8)sd;
     Msg.Cmd.FamilyAndFlags |= flags & 0x0F;
 
     RetVal = _SlDrvDataWriteOp((_u8)sd, (_SlCmdCtrl_t *)&_SlSendCmdCtrl, &Msg, &CmdExt);
     if(SL_OS_RET_CODE_OK != RetVal)
     {
         return RetVal;
     }
     
     return (_i16)Len;
 }

§ sl_SendTo()

_i16 sl_SendTo	(	_i16	sd,
		const void *	buf,
		_i16	len,
		_i16	flags,
		const SlSockAddr_t *	to,
		SlSocklen_t	tolen
	)

Write data to socket.

This function is used to transmit a message to another socket (connection less socket SOCK_DGRAM, SOCK_RAW).
Returns immediately after sending data to device.
In case of transmission failure an async event SL_SOCKET_TX_FAILED_EVENT is going to be received.

Parameters

[in]	sd	Socket handle
[in]	buf	Points to a buffer containing the message to be sent
[in]	len	message size in bytes. Range: 1-1460 bytes
[in]	flags	Specifies the type of message transmission. On this version, this parameter is not supported
[in]	to	Pointer to an address structure indicating the destination address. sockaddr: - code for the address format. On this version only AF_INET is supported. - socket address, the length depends on the code format
[in]	tolen	Destination address structure size

Returns: Zero on success, or negative error code on failure

See also: sl_Send

Note: Belongs to send_api

Warning

Example

Sending data:
SlSockAddrIn_t Addr;
_i16 AddrSize = sizeof(SlSockAddrIn_t);
_i16 SockID;
_i16 Status;
_i8 Buf[SEND_BUF_LEN];
Addr.sin_family = SL_AF_INET;
Addr.sin_port = sl_Htons(5001);
Addr.sin_addr.s_addr = sl_Htonl(SL_IPV4_VAL(10,1,1,200));
SockID = sl_Socket(SL_AF_INET,SL_SOCK_DGRAM, 0);
Status = sl_SendTo(SockID, Buf, 1472, 0, (SlSockAddr_t *)&Addr, AddrSize);

Definition at line 296 of file sl_socket.c.

 {
     _SlSendtoMsg_u   Msg;
     _SlCmdCtrl_t     CmdCtrl = {0, 0, 0};
     _SlCmdExt_t      CmdExt;
     _i16             RetVal;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
    /* RAW transceiver use only sl_Send  */
     if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
     {
         return SL_ERROR_BSD_SOC_ERROR;
     }
     else
     {
         if (Len < 1)
         {
           /* ignore */
           return 0;
         }
     }
 
     _SlDrvResetCmdExt(&CmdExt);
     CmdExt.TxPayload1Len = (_u16)Len;
     CmdExt.pTxPayload1 = (_u8 *)pBuf;
 
     switch(to->sa_family)
     {
         case SL_AF_INET:
             CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO;
             CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(SlSocketAddrIPv4Command_t);
             break;
 #ifndef SL_TINY               
 #ifdef SL_SUPPORT_IPV6
         case SL_AF_INET6:
             CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO_V6;
             CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(SlSocketAddrIPv6Command_t);
             break;
 #endif
 #endif
         case SL_AF_RF:
         default:
             return SL_RET_CODE_INVALID_INPUT;
     }
 
     Msg.Cmd.IpV4.LenOrPadding = Len;
     Msg.Cmd.IpV4.Sd = (_u8)sd;
     _SlSocketBuildAddress(to, &Msg.Cmd);
     Msg.Cmd.IpV4.FamilyAndFlags |= flags & 0x0F;
 
     RetVal = _SlDrvDataWriteOp((_SlSd_t)sd, &CmdCtrl, &Msg, &CmdExt);
     if(SL_OS_RET_CODE_OK != RetVal)
     {
         return RetVal;
     }
 
     return (_i16)Len;
 }

§ sl_SetSockOpt()

_i16 sl_SetSockOpt	(	_i16	sd,
		_i16	level,
		_i16	optname,
		const void *	optval,
		SlSocklen_t	optlen
	)

Set socket options-.

This function manipulate the options associated with a socket.
Options may exist at multiple protocol levels; they are always present at the uppermost socket level.
When manipulating socket options the level at which the option resides and the name of the option must be specified. To manipulate options at the socket level, level is specified as SOL_SOCKET. To manipulate options at any other level the protocol number of the appropriate proto- col controlling the option is supplied. For example, to indicate that an option is to be interpreted by the TCP protocol, level should be set to the protocol number of TCP;
The parameters optval and optlen are used to access optval - ues for setsockopt(). For getsockopt() they identify a buffer in which the value for the requested option(s) are to be returned. For getsockopt(), optlen is a value-result parameter, initially containing the size of the buffer pointed to by option_value, and modified on return to indicate the actual size of the value returned. If no option value is to be supplied or returned, option_value may be NULL.

Parameters

[in]	sd	Socket handle
[in]	level	Defines the protocol level for this option SL_SOL_SOCKET Socket level configurations (L4, transport layer) SL_IPPROTO_IP IP level configurations (L3, network layer) SL_SOL_PHY_OPT Link level configurations (L2, link layer)
[in]	optname	Defines the option name to interrogate SL_SOL_SOCKET SL_SO_KEEPALIVE Enable/Disable periodic keep alive. Keeps TCP connections active by enabling the periodic transmission of messages Timeout is 5 minutes. Default: Enabled This options takes SlSockKeepalive_t struct as parameter SL_SO_KEEPALIVETIME Set keep alive timeout. Value is in seconds Default: 5 minutes SL_SO_RX_NO_IP_BOUNDARY Enable/Disable rx ip boundary. In connectionless socket (udp/raw), unread data is dropped (when recvfrom len parameter < data size), Enable this option in order to read the left data on the next recvfrom iteration Default: Disabled, IP boundary kept, This options takes SlSockRxNoIpBoundary_t struct as parameter SL_SO_RCVTIMEO Sets the timeout value that specifies the maximum amount of time an input function waits until it completes. Default: No timeout This options takes SlTimeval_t struct as parameter SL_SO_RCVBUF Sets tcp max recv window size. This options takes SlSockWinsize_t struct as parameter SL_SO_NONBLOCKING Sets socket to non-blocking operation Impacts: connect, accept, send, sendto, recv and recvfrom. Default: Blocking. This options takes SlSockNonblocking_t struct as parameter SL_SO_SECMETHOD Sets method to tcp secured socket (SL_SEC_SOCKET) Default: SL_SO_SEC_METHOD_SSLv3_TLSV1_2 This options takes SlSockSecureMethod_t struct as parameter SL_SO_SECURE_MASK Sets specific cipher to tcp secured socket (SL_SEC_SOCKET) Default: "Best" cipher suitable to method This options takes SlSockSecureMask_t struct as parameter SL_SO_SECURE_FILES_CA_FILE_NAME Map secured socket to CA file by name This options takes _u8 buffer as parameter SL_SO_SECURE_FILES_PRIVATE_KEY_FILE_NAME Map secured socket to private key by name This options takes _u8 buffer as parameter SL_SO_SECURE_FILES_CERTIFICATE_FILE_NAME Map secured socket to certificate file by name This options takes _u8 buffer as parameter SL_SO_SECURE_FILES_DH_KEY_FILE_NAME Map secured socket to Diffie Hellman file by name This options takes _u8 buffer as parameter SL_SO_CHANGE_CHANNEL Sets channel in transceiver mode. This options takes _u32 as channel number parameter SL_SO_SECURE_ALPN Sets the ALPN list. the parameter is a bit map consist of or of the following values - SL_SECURE_ALPN_H1 SL_SECURE_ALPN_H2 SL_SECURE_ALPN_H2C SL_SECURE_ALPN_H2_14 SL_SECURE_ALPN_H2_16 SL_SECURE_ALPN_FULL_LIST SL_IPPROTO_IP SL_IP_MULTICAST_TTL Set the time-to-live value of outgoing multicast packets for this socket. This options takes _u8 as parameter SL_IP_ADD_MEMBERSHIP UDP socket, Join a multicast group. This options takes SlSockIpMreq_t struct as parameter SL_IP_DROP_MEMBERSHIP UDP socket, Leave a multicast group This options takes SlSockIpMreq_t struct as parameter SL_IP_RAW_RX_NO_HEADER Raw socket remove IP header from received data. Default: data includes ip header This options takes _u32 as parameter SL_IP_HDRINCL RAW socket only, the IPv4 layer generates an IP header when sending a packet unless the IP_HDRINCL socket option is enabled on the socket. When it is enabled, the packet must contain an IP header. Default: disabled, IPv4 header generated by Network Stack This options takes _u32 as parameter SL_IP_RAW_IPV6_HDRINCL (inactive) RAW socket only, the IPv6 layer generates an IP header when sending a packet unless the IP_HDRINCL socket option is enabled on the socket. When it is enabled, the packet must contain an IP header Default: disabled, IPv4 header generated by Network Stack This options takes _u32 as parameter SL_SOL_PHY_OPT SL_SO_PHY_RATE RAW socket, set WLAN PHY transmit rate The values are based on SlWlanRateIndex_e This options takes _u32 as parameter SL_SO_PHY_TX_POWER RAW socket, set WLAN PHY TX power Valid rage is 1-15 This options takes _u32 as parameter SL_SO_PHY_NUM_FRAMES_TO_TX RAW socket, set number of frames to transmit in transceiver mode. Default: 1 packet This options takes _u32 as parameter SL_SO_PHY_PREAMBLE RAW socket, set WLAN PHY preamble for Long/Short This options takes _u32 as parameter SL_SO_PHY_TX_INHIBIT_THRESHOLD RAW socket, set WLAN Tx � Set CCA threshold. The values are based on SlTxInhibitThreshold_e This options takes _u32 as parameter SL_SO_PHY_TX_TIMEOUT RAW socket, set WLAN Tx � changes the TX timeout (lifetime) of transceiver frames. Value in Ms, maximum value is 10ms This options takes _u32 as parameter SL_SO_PHY_ALLOW_ACKS RAW socket, set WLAN Tx � Enable sending ACKs in transceiver mode 0 = disabled / 1 = enabled This options takes _u32 as parameter SL_SO_LINGER Socket lingers on close pending remaining send/receive packetst SL_SO_SECURE_EXT_CLIENT_CHLNG_RESP Set with no parameter to indicate that the client uses external signature using netapp requesrt. needs netapp request handler SL_SO_SECURE_DOMAIN_NAME_VERIFICATION Set a domain name, to check in ssl client connection.
[in]	optval	Specifies a value for the option
[in]	optlen	Specifies the length of the option value

Returns: Zero on success, or negative error code on failure

Persistent: All params are Non- Persistent

See also: sl_getsockopt

Note: Belongs to basic_api

Warning

Examples

SL_SO_KEEPALIVE (disable Keepalive):
SlSockKeepalive_t enableOption;
enableOption.KeepaliveEnabled = 0;
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_KEEPALIVE, (_u8 *)&enableOption,sizeof(enableOption));
SL_SO_KEEPALIVETIME (Set Keepalive timeout):
_i16 Status;
_u32 TimeOut = 120;
sl_SetSockOpt(Sd, SL_SOL_SOCKET, SL_SO_KEEPALIVETIME,( _u8*) &TimeOut, sizeof(TimeOut));
SL_SO_RX_NO_IP_BOUNDARY (disable boundary):
SlSockRxNoIpBoundary_t enableOption;
enableOption.RxIpNoBoundaryEnabled = 1;
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_RX_NO_IP_BOUNDARY, (_u8 *)&enableOption,sizeof(enableOption));
SL_SO_RCVTIMEO:
struct SlTimeval_t timeVal;
timeVal.tv_sec = 1; // Seconds
timeVal.tv_usec = 0; // Microseconds. 10000 microseconds resolution
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_RCVTIMEO, (_u8 *)&timeVal, sizeof(timeVal)); // Enable receive timeout
SL_SO_RCVBUF:
SlSockWinsize_t size;
size.Winsize = 3000; // bytes
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_RCVBUF, (_u8 *)&size, sizeof(size));
SL_SO_NONBLOCKING:
SlSockNonblocking_t enableOption;
enableOption.NonblockingEnabled = 1;
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_NONBLOCKING, (_u8 *)&enableOption,sizeof(enableOption)); // Enable/disable nonblocking mode
SL_SO_SECMETHOD:
SlSockSecureMethod_t method;
method.SecureMethod = SL_SO_SEC_METHOD_SSLV3; // security method we want to use
SockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, SL_SEC_SOCKET);
sl_SetSockOpt(SockID, SL_SOL_SOCKET, SL_SO_SECMETHOD, (_u8 *)&method, sizeof(method));
SL_SO_SECURE_MASK:
SlSockSecureMask_t cipher;
cipher.SecureMask = SL_SEC_MASK_SSL_RSA_WITH_RC4_128_SHA; // cipher type
SockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, SL_SEC_SOCKET);
sl_SetSockOpt(SockID, SL_SOL_SOCKET, SL_SO_SECURE_MASK,(_u8 *)&cipher, sizeof(cipher));
SL_SO_SECURE_FILES_CA_FILE_NAME:
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_SECURE_FILES_CA_FILE_NAME,"exuifaxCaCert.der",strlen("exuifaxCaCert.der"));
SL_SO_SECURE_FILES_PRIVATE_KEY_FILE_NAME;
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_SECURE_FILES_PRIVATE_KEY_FILE_NAME,"myPrivateKey.der",strlen("myPrivateKey.der"));
SL_SO_SECURE_FILES_CERTIFICATE_FILE_NAME:
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_SECURE_FILES_CERTIFICATE_FILE_NAME,"myCertificate.der",strlen("myCertificate.der"));
SL_SO_SECURE_FILES_DH_KEY_FILE_NAME:
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_SECURE_FILES_DH_KEY_FILE_NAME,"myDHinServerMode.der",strlen("myDHinServerMode.der"));
SL_IP_MULTICAST_TTL:
_u8 ttl = 20;
sl_SetSockOpt(SockID, SL_IPPROTO_IP, SL_IP_MULTICAST_TTL, &ttl, sizeof(ttl));
SL_IP_ADD_MEMBERSHIP:
SlSockIpMreq_t mreq;
sl_SetSockOpt(SockID, SL_IPPROTO_IP, SL_IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
SL_IP_DROP_MEMBERSHIP:
SlSockIpMreq_t mreq;
sl_SetSockOpt(SockID, SL_IPPROTO_IP, SL_IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq));
SL_SO_CHANGE_CHANNEL:
_u32 newChannel = 6; // range is 1-13
sl_SetSockOpt(SockID, SL_SOL_SOCKET, SL_SO_CHANGE_CHANNEL, &newChannel, sizeof(newChannel));
SL_SO_SECURE_ALPN:
SlSockSecureALPN_t alpn;
alpn.SecureALPN = SL_SECURE_ALPN_H2 | SL_SECURE_ALPN_H2_14;
sl_SetSockOpt(SockID, SL_SOL_SOCKET, SL_SO_SECURE_ALPN, &alpn, sizeof(SlSockSecureALPN_t));
SL_IP_RAW_RX_NO_HEADER:
_u32 header = 1; // remove ip header
sl_SetSockOpt(SockID, SL_IPPROTO_IP, SL_IP_RAW_RX_NO_HEADER, &header, sizeof(header));
SL_IP_HDRINCL:
_u32 header = 1;
sl_SetSockOpt(SockID, SL_IPPROTO_IP, SL_IP_HDRINCL, &header, sizeof(header));
SL_IP_RAW_IPV6_HDRINCL:
_u32 header = 1;
sl_SetSockOpt(SockID, SL_IPPROTO_IP, SL_IP_RAW_IPV6_HDRINCL, &header, sizeof(header));
SL_SO_PHY_RATE:
_u32 rate = 6; // see wlan.h SlWlanRateIndex_e for values
sl_SetSockOpt(SockID, SL_SOL_PHY_OPT, SL_SO_PHY_RATE, &rate, sizeof(rate));
SL_SO_PHY_TX_POWER:
_u32 txpower = 1; // valid range is 1-15
sl_SetSockOpt(SockID, SL_SOL_PHY_OPT, SL_SO_PHY_TX_POWER, &txpower, sizeof(txpower));
SL_SO_PHY_NUM_FRAMES_TO_TX:
_u32 numframes = 1;
sl_SetSockOpt(SockID, SL_SOL_PHY_OPT, SL_SO_PHY_NUM_FRAMES_TO_TX, &numframes, sizeof(numframes));
SL_SO_PHY_PREAMBLE:
_u32 preamble = 1;
sl_SetSockOpt(SockID, SL_SOL_PHY_OPT, SL_SO_PHY_PREAMBLE, &preamble, sizeof(preamble));
SL_SO_PHY_TX_INHIBIT_THRESHOLD:
_u32 thrshld = SL_TX_INHIBIT_THRESHOLD_MED;
sl_SetSockOpt(SockID, SL_SOL_PHY_OPT, SL_SO_PHY_TX_INHIBIT_THRESHOLD , &thrshld, sizeof(thrshld));
SL_SO_PHY_TX_TIMEOUT:
_u32 timeout = 50;
sl_SetSockOpt(SockID, SL_SOL_PHY_OPT, SL_SO_PHY_TX_TIMEOUT , &timeout, sizeof(timeout));
SL_SO_PHY_ALLOW_ACKS:
_u32 acks = 1; // 0 = disabled / 1 = enabled
sl_SetSockOpt(SockID, SL_SOL_PHY_OPT, SL_SO_PHY_ALLOW_ACKS, &acks, sizeof(acks));
SL_SO_LINGER:
SlSocklinger_t linger;
linger.l_onoff = 1;
linger.l_linger = 10;
sl_SetSockOpt(SockID, SL_SOL_SOCKET, SL_SO_LINGER, &linger, sizeof(linger));
SL_SO_SECURE_EXT_CLIENT_CHLNG_RESP:
int dummy;
sl_SetSockOpt(SockID, SL_SOL_SOCKET, SL_SO_SECURE_EXT_CLIENT_CHLNG_RESP, &dummy, sizeof(dummy));
SL_SO_SECURE_DOMAIN_NAME_VERIFICATION:
sl_SetSockOpt(SockID,SL_SOL_SOCKET,SL_SO_SECURE_DOMAIN_NAME_VERIFICATION,"www.google.co.il",strlen("www.google.co.il"));

Definition at line 943 of file sl_socket.c.

 {
     _SlSetSockOptMsg_u    Msg;
     _SlCmdExt_t           CmdExt;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     _SlDrvResetCmdExt(&CmdExt);
     CmdExt.TxPayload1Len = optlen;
     CmdExt.pTxPayload1 = (_u8 *)optval;
 
     Msg.Cmd.Sd = (_u8)sd;
     Msg.Cmd.Level = (_u8)level;
     Msg.Cmd.OptionLen = (_u8)optlen;
     Msg.Cmd.OptionName = (_u8)optname;
 
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSetSockOptCmdCtrl, &Msg, &CmdExt));
 
     return (_i16)Msg.Rsp.StatusOrLen;
 }

§ sl_Socket()

_i16 sl_Socket	(	_i16	Domain,
		_i16	Type,
		_i16	Protocol
	)

Create an endpoint for communication.

The socket function creates a new socket of a certain socket type, identified by an integer number, and allocates system resources to it.
This function is called by the application layer to obtain a socket handle.

Parameters

[in]	Domain	Specifies the protocol family of the created socket. For example: SL_AF_INET for network protocol IPv4 SL_AF_INET6 for network protocol IPv6 SL_AF_RF for starting transceiver mode. Notes: sending and receiving any packet overriding 802.11 header for optimized power consumption the socket will be started in TX only mode until receive command is activated
[in]	Type	specifies the communication semantic, one of: SL_SOCK_STREAM (reliable stream-oriented service or Stream Sockets) SL_SOCK_DGRAM (datagram service or Datagram Sockets) SL_SOCK_RAW (raw protocols atop the network layer) when used with AF_RF: SL_SOCK_DGRAM - L2 socket SL_SOCK_RAW - L1 socket - bypass WLAN CCA (Clear Channel Assessment)
[in]	Protocol	specifies a particular transport to be used with the socket. The most common are SL_IPPROTO_TCP SL_IPPROTO_UDP The value 0 may be used to select a default protocol from the selected domain and type

Returns

On success, socket handle that is used for consequent socket operations.
A successful return code should be a positive number (int16)
On error, a negative (int16) value will be returned specifying the error code.

SL_EAFNOSUPPORT - illegal domain parameter
SL_EPROTOTYPE - illegal type parameter
SL_EACCES - permission denied
SL_ENSOCK - exceeded maximal number of socket
SL_ENOMEM - memory allocation error
SL_EINVAL - error in socket configuration
SL_EPROTONOSUPPORT - illegal protocol parameter
SL_EOPNOTSUPP - illegal combination of protocol and type parameters

See also: sl_Close

Note: belongs to basic_api

Warning

Definition at line 143 of file sl_socket.c.

 {
     _SlSockSocketMsg_u  Msg;
 
     Msg.Cmd.Domain      = (_u8)Domain;
     Msg.Cmd.Type        = (_u8)Type;
     Msg.Cmd.Protocol    = (_u8)Protocol;
 
     /* verify that this api is allowed. if not allowed then
     ignore the API execution and return immediately with an error */
     VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
 
     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSockSocketCmdCtrl, &Msg, NULL));
 
     if( Msg.Rsp.StatusOrLen < 0 )
     {
         return ( Msg.Rsp.StatusOrLen);
     }
     else
     {
         return (_i16)((_u8)Msg.Rsp.Sd);
     }
 }

Data Structure Documentation

§ SlInAddr_t

struct SlInAddr_t

Definition at line 221 of file sl_socket.h.

Data Fields
_u32	s_addr
union S_un	S_un

§ SlIn6Addr_t

struct SlIn6Addr_t

Definition at line 235 of file sl_socket.h.

Data Fields
union SlIn6Addr_t	_S6_un

§ SlIn6Addr_t._S6_un

union SlIn6Addr_t._S6_un

Definition at line 237 of file sl_socket.h.

Data Fields
_u32	_S6_u32[4]
_u8	_S6_u8[16]

§ SlSockKeepalive_t

struct SlSockKeepalive_t

Definition at line 246 of file sl_socket.h.

Data Fields
_u32	KeepaliveEnabled

§ SlSockReuseaddr_t

struct SlSockReuseaddr_t

Definition at line 251 of file sl_socket.h.

Data Fields
_u32	ReuseaddrEnabled

§ SlSockRxNoIpBoundary_t

struct SlSockRxNoIpBoundary_t

Definition at line 256 of file sl_socket.h.

Data Fields
_i32	RxIpNoBoundaryEnabled

§ SlSockWinsize_t

struct SlSockWinsize_t

Definition at line 262 of file sl_socket.h.

Data Fields
_u32	WinSize

§ SlSockNonblocking_t

struct SlSockNonblocking_t

Definition at line 267 of file sl_socket.h.

Data Fields
_u32	NonBlockingEnabled

§ SlSocketAsyncEvent_t

struct SlSocketAsyncEvent_t

Definition at line 272 of file sl_socket.h.

Data Fields
_i8	pExtraInfo[128]
_u8	Sd
_u8	Type
_i16	Val

§ SlSockTxFailEventData_t

struct SlSockTxFailEventData_t

Definition at line 280 of file sl_socket.h.

Data Fields
_u8	Padding
_u8	Sd
_i16	Status

§ SlSockEventData_u

union SlSockEventData_u

Definition at line 288 of file sl_socket.h.

Data Fields
SlSocketAsyncEvent_t	SockAsyncData
SlSockTxFailEventData_t	SockTxFailData

§ SlSockEvent_t

struct SlSockEvent_t

Definition at line 295 of file sl_socket.h.

Data Fields
_u32	Event
SlSockEventData_u	SocketAsyncEvent

§ SlSockTriggerEvent_t

struct SlSockTriggerEvent_t

Definition at line 301 of file sl_socket.h.

Data Fields
_u32	Event
_u32	EventData

§ SlSockSecureALPN_t

struct SlSockSecureALPN_t

Definition at line 308 of file sl_socket.h.

Data Fields
_u32	SecureALPN

§ SlSockSecureMask_t

struct SlSockSecureMask_t

Definition at line 313 of file sl_socket.h.

Data Fields
_u32	SecureMask

§ SlSockSecureMethod_t

struct SlSockSecureMethod_t

Definition at line 318 of file sl_socket.h.

Data Fields
_u8	SecureMethod

§ SlSockSSLCertInfo_t

struct SlSockSSLCertInfo_t

Definition at line 323 of file sl_socket.h.

Data Fields
_i8	FromDate[8]
_i8	IssuerName[SL_MAX_ISSUER_AND_SUBJECT_NAME_LEN]
_i8	IssuerNameLen
_u16	IssuerNameXoredSha1
_i8	Padding[2]
_i8	SubjectName[SL_MAX_ISSUER_AND_SUBJECT_NAME_LEN]
_i8	SubjectNameLen
_u16	SubjectNameXoredSha1
_i8	ToDate[8]

§ SlSockSSLConnectionParams_t

struct SlSockSSLConnectionParams_t

Definition at line 337 of file sl_socket.h.

Data Fields
_u32	SecureALPNChosenProtocol
_u32	SecureCipherSuit
_u32	SecureIsPeerValidated
SlSockSSLCertInfo_t	SecurePeerCertinfo
_u32	SecureVersion

§ SlSockIpMreq_t

struct SlSockIpMreq_t

Definition at line 360 of file sl_socket.h.

Data Fields
SlInAddr_t	imr_interface
SlInAddr_t	imr_multiaddr

§ SlSockIpV6Mreq_t

struct SlSockIpV6Mreq_t

Definition at line 366 of file sl_socket.h.

Data Fields
_u32	ipv6mr_interface
SlIn6Addr_t	ipv6mr_multiaddr

§ SlSocklinger_t

struct SlSocklinger_t

Definition at line 371 of file sl_socket.h.

Data Fields
_u32	l_linger
_u32	l_onoff

§ SlTimeval_t

struct SlTimeval_t

Definition at line 381 of file sl_socket.h.

Data Fields
SlTime_t	tv_sec
SlSuseconds_t	tv_usec

§ SlSockAddr_t

struct SlSockAddr_t

Definition at line 390 of file sl_socket.h.

Data Fields
_u8	sa_data[14]
_u16	sa_family

§ SlSockAddrIn6_t

struct SlSockAddrIn6_t

Definition at line 397 of file sl_socket.h.

Data Fields
SlIn6Addr_t	sin6_addr
_u16	sin6_family
_u32	sin6_flowinfo
_u16	sin6_port
_u32	sin6_scope_id

§ SlSockAddrIn_t

struct SlSockAddrIn_t

Definition at line 408 of file sl_socket.h.

Data Fields
SlInAddr_t	sin_addr
_u16	sin_family
_u16	sin_port
_i8	sin_zero[8]

§ SlSockSecureFiles_t

struct SlSockSecureFiles_t

Definition at line 417 of file sl_socket.h.

Data Fields
_u8	SecureFiles[4]

§ SlFdSet_t

struct SlFdSet_t

Definition at line 423 of file sl_socket.h.

Data Fields
_u32	fd_array[(SL_FD_SETSIZE+(_u8) 31)/(_u8) 32]

§ SlTransceiverRxOverHead_t

struct SlTransceiverRxOverHead_t

Definition at line 428 of file sl_socket.h.

Data Fields
_u8	Channel
_u8	Padding
_u8	Rate
_i8	Rssi
_u32	Timestamp

Functions

Typedefs

Enumerations

Detailed Description

Function Documentation

§ sl_Accept()

§ sl_Bind()

§ sl_Close()

§ sl_Connect()

§ sl_GetSockOpt()

§ sl_Htonl()

§ sl_Htons()

§ sl_Listen()

§ sl_Recv()

§ sl_RecvFrom()

§ sl_Select()

§ sl_Send()

§ sl_SendTo()

§ sl_SetSockOpt()

§ sl_Socket()

Data Structure Documentation

§ SlInAddr_t

§ SlIn6Addr_t

§ SlIn6Addr_t._S6_un

§ SlSockKeepalive_t

§ SlSockReuseaddr_t

§ SlSockRxNoIpBoundary_t

§ SlSockWinsize_t

§ SlSockNonblocking_t

§ SlSocketAsyncEvent_t

§ SlSockTxFailEventData_t

§ SlSockEventData_u

§ SlSockEvent_t

§ SlSockTriggerEvent_t

§ SlSockSecureALPN_t

§ SlSockSecureMask_t

§ SlSockSecureMethod_t

§ SlSockSSLCertInfo_t

§ SlSockSSLConnectionParams_t

§ SlSockIpMreq_t

§ SlSockIpV6Mreq_t

§ SlSocklinger_t

§ SlTimeval_t

§ SlSockAddr_t

§ SlSockAddrIn6_t

§ SlSockAddrIn_t

§ SlSockSecureFiles_t

§ SlFdSet_t

§ SlTransceiverRxOverHead_t