Socket

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...
int16_t	SlNetIfWifi_socket (void *ifContext, int16_t Domain, int16_t Type, int16_t Protocol, void **sdContext)
	Create an endpoint for communication. More...
int32_t	SlNetIfWifi_close (int16_t sd, void *sdContext)
	Gracefully close socket. More...
int16_t	SlNetIfWifi_accept (int16_t sd, void *sdContext, SlNetSock_Addr_t *addr, SlNetSocklen_t *addrlen, uint8_t flags, void **acceptedSdContext)
	Accept a connection on a socket. More...
int32_t	SlNetIfWifi_bind (int16_t sd, void *sdContext, const SlNetSock_Addr_t *addr, int16_t addrlen)
	Assign a name to a socket. More...
int32_t	SlNetIfWifi_listen (int16_t sd, void *sdContext, int16_t backlog)
	Listen for connections on a socket. More...
int32_t	SlNetIfWifi_connect (int16_t sd, void *sdContext, const SlNetSock_Addr_t *addr, SlNetSocklen_t addrlen, uint8_t flags)
	Initiate a connection on a socket. More...
int32_t	SlNetIfWifi_getSockName (int16_t sd, void *sdContext, SlNetSock_Addr_t *addr, SlNetSocklen_t *addrlen)
	Get local address info by socket descriptor Returns the local address info of the socket descriptor. More...
int32_t	SlNetIfWifi_select (void *ifContext, int16_t nfds, SlNetSock_SdSet_t *readsds, SlNetSock_SdSet_t *writesds, SlNetSock_SdSet_t *exceptsds, SlNetSock_Timeval_t *timeout)
	Monitor socket activity. More...
int32_t	SlNetIfWifi_setSockOpt (int16_t sd, void *sdContext, int16_t level, int16_t optname, void *optval, SlNetSocklen_t optlen)
	Set socket options-. More...
int32_t	SlNetIfWifi_getSockOpt (int16_t sd, void *sdContext, int16_t level, int16_t optname, void *optval, SlNetSocklen_t *optlen)
	Get socket options. More...
int32_t	SlNetIfWifi_recv (int16_t sd, void *sdContext, void *buf, uint32_t len, uint32_t flags)
	Read data from TCP socket. More...
int32_t	SlNetIfWifi_recvFrom (int16_t sd, void *sdContext, void *buf, uint32_t len, uint32_t flags, SlNetSock_Addr_t *from, SlNetSocklen_t *fromlen)
	Read data from socket. More...
int32_t	SlNetIfWifi_send (int16_t sd, void *sdContext, const void *buf, uint32_t len, uint32_t flags)
	Write data to TCP socket. More...
int32_t	SlNetIfWifi_sendTo (int16_t sd, void *sdContext, const void *buf, uint32_t len, uint32_t flags, const SlNetSock_Addr_t *to, SlNetSocklen_t tolen)
	Write data to socket. More...
int32_t	SlNetIfWifi_sockstartSec (int16_t sd, void *sdContext, SlNetSockSecAttrib_t *secAttrib, uint8_t flags)
	Start a security session on an opened socket. More...
int32_t	SlNetIfWifi_getHostByName (void *ifContext, char *name, const uint16_t nameLen, uint32_t *ipAddr, uint16_t *ipAddrLen, const uint8_t family)
	Get host IP by name Obtain the IP Address of machine on network, by machine name. More...
int32_t	SlNetIfWifi_getIPAddr (void *ifContext, SlNetIfAddressType_e addrType, uint16_t *addrConfig, uint32_t *ipAddr)
	Get IP Address of specific interface. More...
int32_t	SlNetIfWifi_getConnectionStatus (void *ifContext)
	Get interface connection status. More...
int32_t	SlNetIfWifi_loadSecObj (void *ifContext, uint16_t objType, char *objName, int16_t objNameLen, uint8_t *objBuff, int16_t objBuffLen)
	Load secured buffer to the network stack. More...
int32_t	SlNetIfWifi_CreateContext (uint16_t ifID, const char *ifName, void **ifContext)
	Allocate and store interface data. 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	slSockTransceiverTXRateTable_e {   SL_SOCK_TX_RATE_1M = 1,   SL_SOCK_TX_RATE_2M = 2,   SL_SOCK_TX_RATE_5_5M = 3,   SL_SOCK_TX_RATE_11M = 4,   SL_SOCK_TX_RATE_6M = 6,   SL_SOCK_TX_RATE_9M = 7,   SL_SOCK_TX_RATE_12M = 8,   SL_SOCK_TX_RATE_18M = 9,   SL_SOCK_TX_RATE_24M = 10,   SL_SOCK_TX_RATE_36M = 11,   SL_SOCK_TX_RATE_48M = 12,   SL_SOCK_TX_RATE_54M = 13,   SL_SOCK_TX_RATE_MCS_0 = 14,   SL_SOCK_TX_RATE_MCS_1 = 15,   SL_SOCK_TX_RATE_MCS_2 = 16,   SL_SOCK_TX_RATE_MCS_3 = 17,   SL_SOCK_TX_RATE_MCS_4 = 18,   SL_SOCK_TX_RATE_MCS_5 = 19,   SL_SOCK_TX_RATE_MCS_6 = 20,   SL_SOCK_TX_RATE_MCS_7 = 21,   SL_SOCK_TX_MAX_NUM_RATES = 0xFF }
enum	SlSockTransceiverRXRates_e {   SL_SOCK_RX_RATE_1M = 0,   SL_SOCK_RX_RATE_2M = 1,   SL_SOCK_RX_RATE_5_5M = 2,   SL_SOCK_RX_RATE_11M = 3,   SL_SOCK_RX_RATE_6M = 4,   SL_SOCK_RX_RATE_9M = 5,   SL_SOCK_RX_RATE_12M = 6,   SL_SOCK_RX_RATE_18M = 7,   SL_SOCK_RX_RATE_24M = 8,   SL_SOCK_RX_RATE_36M = 9,   SL_SOCK_RX_RATE_48M = 10,   SL_SOCK_RX_RATE_54M = 11,   SL_SOCK_RX_RATE_MCS0 = 12,   SL_SOCK_RX_RATE_MCS1 = 13,   SL_SOCK_RX_RATE_MCS2 = 14,   SL_SOCK_RX_RATE_MCS3 = 15,   SL_SOCK_RX_RATE_MCS4 = 16,   SL_SOCK_RX_RATE_MCS5 = 17,   SL_SOCK_RX_RATE_MCS6 = 18,   SL_SOCK_RX_RATE_MCS7 = 19,   SL_SOCK_RX_RATE_MCS7_SGI = 20 }
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 }

Variables
_u32	s_addr
_u8	s_b1
_u8	s_b2
_u8	s_b3
_u8	s_b4
struct {
_u8	s_b1
_u8	s_b2
_u8	s_b3
_u8	s_b4
}	S_un_b
_u16	s_w1
_u16	s_w2
struct {
_u16	s_w1
_u16	s_w2
}	S_un_w
_u32	S_addr
union SlInAddr_t::S_un	S_un
_u8	_S6_u8 [16]
_u32	_S6_u32 [4]
union {
_u8	_S6_u8 [16]
_u32	_S6_u32 [4]
}	_S6_un
_u32	KeepaliveEnabled
_u32	ReuseaddrEnabled
_i32	RxIpNoBoundaryEnabled
_u32	WinSize
_u32	NonBlockingEnabled
_u8	Sd
_u8	Type
_i16	Val
_i8	pExtraInfo [128]
_i16	Status
_u8	Sd
_u8	Padding
SlSockTxFailEventData_t	SockTxFailData
SlSocketAsyncEvent_t	SockAsyncData
_u32	Event
SlSockEventData_u	SocketAsyncEvent
_u32	Event
_u32	EventData
_u32	SecureALPN
_u32	SecureMask
_u8	SecureMethod
_u16	SubjectNameXoredSha1
_u16	IssuerNameXoredSha1
_i8	FromDate [8]
_i8	ToDate [8]
_i8	SubjectName [SL_MAX_ISSUER_AND_SUBJECT_NAME_LEN]
_i8	IssuerName [SL_MAX_ISSUER_AND_SUBJECT_NAME_LEN]
_i8	SubjectNameLen
_i8	IssuerNameLen
_i8	Padding [2]
_u32	SecureVersion
_u32	SecureCipherSuit
_u32	SecureIsPeerValidated
_u32	SecureALPNChosenProtocol
SlSockSSLCertInfo_t	SecurePeerCertinfo
_u16	type
_u16	length
SlInAddr_t	imr_multiaddr
SlInAddr_t	imr_interface
SlIn6Addr_t	ipv6mr_multiaddr
_u32	ipv6mr_interface
_u32	l_onoff
_u32	l_linger
SlTime_t	tv_sec
SlSuseconds_t	tv_usec
_u16	sa_family
_u8	sa_data [14]
_u16	sin6_family
_u16	sin6_port
_u32	sin6_flowinfo
SlIn6Addr_t	sin6_addr
_u32	sin6_scope_id
_u16	sin_family
_u16	sin_port
SlInAddr_t	sin_addr
_i8	sin_zero [8]
_u8	SecureFiles [4]
_u32	fd_array [(SL_FD_SETSIZE+(_u8) 31)/(_u8) 32]
_u8	Rate
_u8	Channel
_i8	Rssi
_u8	Padding
_u32	Timestamp
_u32	enableDisable
SlNetIf_Config_t	SlNetIfConfigWifi

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 692 of file sl_socket.c.

{
    _SlSockAcceptMsg_u       Msg;
    _SlReturnVal_t           RetVal;
    SlSocketAddrResponse_u   AsyncRsp;
    int ret_pool = 0; // for _SlDrvReleasePoolObj

    _i16 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)
    {
        /* 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) ))
        {
            ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE);
        }
        else
        {  
            /* wait for async and get Data Read parameters */
            ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);
        }

        RetVal = AsyncRsp.IpV4.StatusOrLen;

        if (0 <= RetVal)
        {
            VERIFY_PROTOCOL(AsyncRsp.IpV4.Sd == (_u8)sd);
        }

       
#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);

    if(ret_pool < 0)
    {
        return ret_pool;
    }
    else
    {
        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 237 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;
#ifdef SL_SUPPORT_IPV6
        case SL_AF_INET6:
            CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_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);
    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 176 of file sl_socket.c.

{
    _SlSockCloseMsg_u    Msg;
    _i16                 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)
        {    
            RetVal = _SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_LONG, SL_OPCODE_SOCKET_SOCKETCLOSEASYNCEVENT);

            if(RetVal >= 0)
            {
                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 449 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;
      _i16 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;

    int ret_pool = 0; // for _SlDrvReleasePoolObj
    if(SL_RET_CODE_OK == RetVal)
    {
        /*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) ))
        {
            ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE);
        }
        else
        {
            /* wait for async and get Data Read parameters */
            ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx, 0, 0);
        }
        
        RetVal = AsyncRsp.StatusOrLen;
        
        if (0 <= RetVal)
        {
            VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
        }        
    }

    _SlDrvReleasePoolObj(ObjIdx);

    if(ret_pool < 0)
    {
        return ret_pool;
    }
    else
    {
        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 protocol 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 optvalues 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 975 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 806 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 827 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 658 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 881 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 360 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:

1. The command will be executed alongside other select callers (success).
2. The command will wait (internal) until the previous sl_select finish, and then be executed.
3. 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 behavior 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 1761 of file sl_socket.c.

{
    _SlSelectMsg_u            Msg;
    SlSelectAsyncResponse_t   AsyncRsp;
    _i16                      ObjIdx = MAX_CONCURRENT_ACTIONS;
    _i16                      ret = 0;
#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)
    {
        ret = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);

        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);

                if(ret < 0)
                {
                    return ret;
                }

                /* 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);

    if(ret < 0)
    {
        return ret;
    }

    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.
[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) -rate need to be define using slSockTransceiverTXRateTable_e

Returns

On success, number of transmitted bytes is return, 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 594 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.
[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

On success, number of transmitted bytes is return, 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 283 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;
#ifdef SL_SUPPORT_IPV6
        case SL_AF_INET6:
            CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO_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 = 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_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) The Protocol parameter is used to set the channel number. Within this parameter, low power low rate flag can be set by using the macro SL_WLAN_RAW_RF_SOCKET_CHANNEL. i.e sl_Socket(SL_AF_RF, SL_SOCK_RAW, SL_WLAN_RAW_RF_SOCKET_CHANNEL(36, TRANSCEIVER_5G_LOW_POWER_LOW_RATE)); SL_SOCK_RX_MTR - opening socket to receive information frames with the following format in STA and P2P client only. | SlRxMetrics_TLV_t | SlTransceiverRxOverHead_t | WLAN header (24 / 26 bytes depending on QOS) payload | collecting WLAN headers and RX metrics between the device and the AP. if used with the setsockopt - SL_SO_PHY_RX_BSSID_DATA_FRAMES, the device start collecting WLAN headers of other devices in the BSS
[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 133 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);
    }
}

sl_StartTLS()

_i16 sl_StartTLS

(

_i16

sd

)

Initiate TLS connection on a socket.

Function Initiate TLS connection on the socket referred to by the socket descriptor sd. This function will works on blocking mode until the TLS handshake success or fails.

Parameters

[in]

sd

Socket descriptor (handle)

Returns

Zero on success, or negative error code on failure

See also

sl_Socket

Note

belongs to client_side

Warning

Definition at line 1971 of file sl_socket.c.

{
    _SlReturnVal_t       RetVal;
    SlSocketAsyncEvent_t AsyncRsp;
    _u32                 tempValue;
    _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
    _i8 ret;
    int ret_pool = 0; // for _SlDrvReleasePoolObj
    SlEventsListNode_t startTLS;
    _u8 ActionIndex;

    /* 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(SlSocketAsyncEvent_t));

    /* Check if there already Object with ActionID "startTLS" on the same socket */
    for (ActionIndex = 0; ActionIndex < MAX_CONCURRENT_ACTIONS; ++ActionIndex)
    {
        if(((g_pCB->ObjPool[ActionIndex].AdditionalData & 0x0F) == sd) && ((g_pCB->ObjPool[ActionIndex].ActionID) == START_TLS_ID))
        {
            return SL_RET_CODE_STARTTLS_IN_PROGRESS_ON_THIS_SD;
        }

    }

    ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, START_TLS_ID, (_u8)(sd  & SL_BSD_SOCKET_ID_MASK));

    if (MAX_CONCURRENT_ACTIONS == ObjIdx)
    {
        return SL_POOL_IS_EMPTY;
    }

    startTLS.event = (void *)_SlSocketHandleAsync_StartTLS;
    sl_RegisterLibsEventHandler(SL_EVENT_HDL_SOCKET, &startTLS);

    /* send Start TLS to sl_SetSockOpt */
    RetVal = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_STARTTLS, &tempValue, sizeof(tempValue));

    if(SL_RET_CODE_OK == RetVal)
    {
        /* wait for async and get Data Read parameters */
        ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);

        VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);

        RetVal = AsyncRsp.Val;
    }

    ret = sl_UnregisterLibsEventHandler(SL_EVENT_HDL_SOCKET, &startTLS);
    _SlDrvReleasePoolObj(ObjIdx);
    if(ret < 0)
    {
        return ret;
    }

    if(ret_pool < 0)
    {
        return ret_pool;
    }

    return RetVal;
}

SlNetIfWifi_accept()

int16_t SlNetIfWifi_accept	(	int16_t	sd,
		void *	sdContext,
		SlNetSock_Addr_t *	addr,
		SlNetSocklen_t *	addrlen,
		uint8_t	flags,
		void **	acceptedSdContext
	)

Accept a connection on a socket.

The SlNetIfWifi_accept 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 SlNetIfWifi_socket(), bound to a local address with SlNetIfWifi_bind(), and is listening for connections after a SlNetIfWifi_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)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[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. - 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
[in]	flags	Specifies socket descriptor flags. The available flags are: SLNETSOCK_SEC_START_SECURITY_SESSION_ONLY SLNETSOCK_SEC_BIND_CONTEXT_ONLY Note: This flags can be used in order to start security session if needed
[in]	acceptedSdContext	Allocate and store data for the new socket if needed in other to use it in other slnetwifi socket functions

Returns

On success, a socket descriptor.
On a non-blocking accept a possible negative value is SLNETERR_BSD_EAGAIN.
On failure, negative error code.
SLNETERR_BSD_ENOMEM 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

SlNetIfWifi_Socket SlNetIfWifi_Bind SlNetIfWifi_Listen

Note

Warning

Definition at line 151 of file slnetifwifi.c.

{
    return sl_Accept(sd, (SlSockAddr_t *)addr, addrlen);
}

SlNetIfWifi_bind()

int32_t SlNetIfWifi_bind	(	int16_t	sd,
		void *	sdContext,
		const SlNetSock_Addr_t *	addr,
		int16_t	addrlen
	)

Assign a name to a socket.

This SlNetIfWifi_bind 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]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[in]	addr	Specifies the destination addrs sockaddr: - code for the address format. - 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

SlNetIfWifi_Socket SlNetIfWifi_accept SlNetIfWifi_Listen

Note

Warning

Definition at line 162 of file slnetifwifi.c.

{
    return sl_Bind(sd, (const SlSockAddr_t *)addr, addrlen);
}

SlNetIfWifi_close()

int32_t SlNetIfWifi_close	(	int16_t	sd,
		void *	sdContext
	)

Gracefully close socket.

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

Parameters

[in]	sd	Socket descriptor (handle), received in SlNetIfWifi_socket
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.

Returns

Zero on success, or negative error code on failure

See also

SlNetIfWifi_socket

Note

Warning

Definition at line 139 of file slnetifwifi.c.

{
    /* Close socket and return the return value of the function                */
    return sl_Close(sd);
}

SlNetIfWifi_connect()

int32_t SlNetIfWifi_connect	(	int16_t	sd,
		void *	sdContext,
		const SlNetSock_Addr_t *	addr,
		SlNetSocklen_t	addrlen,
		uint8_t	flags
	)

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 SLNETSOCK_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 SLNETSOCK_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]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[in]	addr	Specifies the destination addr sockaddr: - code for the address format. - socket address, the length depends on the code format
[in]	addrlen	Contains the size of the structure pointed to by addr
[in]	flags	Specifies socket descriptor flags. The available flags are: SLNETSOCK_SEC_START_SECURITY_SESSION_ONLY SLNETSOCK_SEC_BIND_CONTEXT_ONLY Note: This flags can be used in order to start security session if needed

Returns

On success, a socket descriptor (handle).
On a non-blocking connect a possible negative value is NETSCOK_EALREADY. On failure, negative value.
NETSCOK_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

SlNetIfWifi_socket

Note

Warning

Definition at line 184 of file slnetifwifi.c.

{
    return sl_Connect(sd, (const SlSockAddr_t *)addr, addrlen);
}

SlNetIfWifi_CreateContext()

int32_t SlNetIfWifi_CreateContext	(	uint16_t	ifID,
		const char *	ifName,
		void **	ifContext
	)

Allocate and store interface data.

The SlNetIfWifi_CreateContext function stores interface related data.

Parameters

[in]

ifContext

Allocate and store interface data if needed. Can be used in all slnetwifi interface functions

Returns

Zero on success, or negative error code on failure.

See also

Note

Warning

Examples

void *ifContext;
connection_status = SlNetIfWifi_CreateContext(&context);

Definition at line 601 of file slnetifwifi.c.

{
    return SLNETERR_RET_CODE_OK;
}

SlNetIfWifi_getConnectionStatus()

int32_t SlNetIfWifi_getConnectionStatus

(

void *

ifContext

)

Get interface connection status.

The SlNetIfWifi_getConnectionStatus function gets the connection status of the interface (connected Or disconnected).

Parameters

[in]

ifContext

Stores interface data if CreateContext function supported and implemented. Can be used in all SlNetIf_Config_t functions

Returns

Connection status of the interface on success, or negative error code on failure

See also

Note

Warning

Examples

int16_t connection_status
connection_status = SlNetIfWifi_getConnectionStatus();

Definition at line 511 of file slnetifwifi.c.

{
    SlWlanConnStatusParam_t connectionParams;
    uint16_t                Opt    = 0;
    int32_t                 retVal = 0;
    uint16_t                Size   = 0;

    Size = sizeof(SlWlanConnStatusParam_t);
    memset(&connectionParams, 0, Size);
    
    retVal = sl_WlanGet(SL_WLAN_CONNECTION_INFO, &Opt, &Size, (uint8_t *)&connectionParams);

    /* Check if the function returned an error                               */
    if (retVal < SLNETERR_RET_CODE_OK)
    {
        /* Return error code                                                 */
        return retVal;
    }
    return connectionParams.ConnStatus;
}

SlNetIfWifi_getHostByName()

int32_t SlNetIfWifi_getHostByName	(	void *	ifContext,
		char *	name,
		const uint16_t	nameLen,
		uint32_t *	ipAddr,
		uint16_t *	ipAddrLen,
		const uint8_t	family
	)

Get host IP by name
Obtain the IP Address of machine on network, by machine name.

Parameters

[in]	ifContext	Stores interface data if CreateContext function supported and implemented. Can be used in all SlNetIf_Config_t functions
[in]	ifBitmap	Specifies the interfaces which the host ip needs to be retrieved from (according to the priority until one of them will return an answer). The values of the interface identifiers is defined with the prefix SLNETIF_ID_ which defined in slnetif.h
[in]	name	Host name
[in]	nameLen	Name length
[out]	ipAddr	This parameter is filled in with host IP addresses. In case that host name is not resolved, out_ip_addr is zero.
[in,out]	ipAddrLen	Holds the size of the ipAddr array, when function successful, the ipAddrLen parameter will be updated with the number of the IP addresses found.
[in]	family	Protocol family

Returns

Zero on success, or negative on failure.
SLNETUTIL_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 Possible DNS error codes:

• SLNETUTIL_DNS_QUERY_NO_RESPONSE
• SLNETUTIL_DNS_NO_SERVER
• SLNETUTIL_DNS_QUERY_FAILED
• SLNETUTIL_DNS_MALFORMED_PACKET
• SLNETUTIL_DNS_MISMATCHED_RESPONSE

See also

Note

Only one sl_NetAppDnsGetHostByName can be handled at a time.
Calling this API while the same command is called from another thread, may result in one of the two scenarios:

1. The command will wait (internal) until the previous command finish, and then be executed.
2. There are not enough resources and 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.

Warning

In case an IP address in a string format is set as input, without any prefix (e.g. "1.2.3.4") the device will not try to access the DNS and it will return the input address on the 'out_ip_addr' field

Example

• Getting host by name:

  uint16_t DestIPListSize = 1;
  uint32_t DestIP[1];
  uint32_t ifID;
  int16_t  SockId;
  SlNetSock_AddrIn_t LocalAddr; //address of the server to connect to
  int32_t LocalAddrSize;
  
  SlNetIfWifi_getHostByName(0, "www.google.com", strlen("www.google.com"), (uint32_t *)DestIP, &DestIPListSize, SLNETSOCK_PF_INET);
  
  LocalAddr.sin_family = SLNETSOCK_AF_INET;
  LocalAddr.sin_addr.s_addr = SlNetUtil_htonl(DestIP[0]);
  LocalAddr.sin_port = SlNetUtil_htons(80);
  LocalAddrSize = sizeof(SlNetSock_AddrIn_t);
  
  SockId = SlNetIfWifi_socket(SLNETSOCK_AF_INET, SLNETSOCK_SOCK_STREAM, ifID, 0);
  
  if (SockId >= 0)
  {
      status = SlNetIfWifi_connect(SockId, (SlNetSock_Addr_t *) &LocalAddr, LocalAddrSize);
  }

Definition at line 409 of file slnetifwifi.c.

{
    int32_t  retVal = SLNETERR_RET_CODE_OK;
    
    /* sl_NetAppDnsGetHostByName can receive only one ipAddr variable, so
       only the first slot of the array will be used and the ipAddrLen will
       be updated to 1 when function is successfully                         */
    retVal = sl_NetAppDnsGetHostByName((signed char *)name, nameLen, (_u32 *)ipAddr, family);
    
    if (retVal == SLNETERR_RET_CODE_OK)
    {
        *ipAddrLen = 1;
    }
    
    return retVal;
     
}

SlNetIfWifi_getIPAddr()

int32_t SlNetIfWifi_getIPAddr	(	void *	ifContext,
		SlNetIfAddressType_e	addrType,
		uint16_t *	addrConfig,
		uint32_t *	ipAddr
	)

Get IP Address of specific interface.

The SlNetIfWifi_getIPAddr function retrieve the IP address of a specific interface according to the Address Type, IPv4, IPv6 LOCAL or IPv6 GLOBAL.

Parameters

[in]	ifContext	Stores interface data if CreateContext function supported and implemented. Can be used in all SlNetIf_Config_t functions
[in]	ifID	Specifies the interface which its connection state needs to be retrieved. The values of the interface identifier is defined with the prefix SLNETIF_ID_ which defined in slnetif.h
[in]	addrType	Address type: SLNETIF_IPV4_ADDR SLNETIF_IPV6_ADDR_LOCAL SLNETIF_IPV6_ADDR_GLOBAL
[out]	addrConfig	Address config: SLNETIF_ADDR_CFG_UNKNOWN SLNETIF_ADDR_CFG_DHCP SLNETIF_ADDR_CFG_DHCP_LLA SLNETIF_ADDR_CFG_STATIC SLNETIF_ADDR_CFG_STATELESS SLNETIF_ADDR_CFG_STATEFUL
[out]	ipAddr	IP Address according to the Address Type

Returns

Zero on success, or negative error code on failure

See also

SlNetIfAddressType_e

Note

Warning

Examples

SlNetSock_In6Addr_t IPAdd;
uint16_t addressConfig = 0;
SlNetIfWifi_getIPAddr(SLNETIF_ID_1 ,SLNETIF_IPV6_ADDR_LOCAL ,&addressConfig ,(uint8_t *)ipAddr);

Definition at line 490 of file slnetifwifi.c.

{
    int32_t    retVal;
    uint16_t   ipAddrLen;
    SlNetCfg_e newAddrType;

    /* Translate the addrType of SlNetSock type to addrType of SlNetSockIfWifi type */
    retVal = matchModeByRole(addrType, &newAddrType, &ipAddrLen);
    if(retVal == SLNETERR_RET_CODE_OK)
    {
        retVal = sl_NetCfgGet(newAddrType, addrConfig, &ipAddrLen, (unsigned char *)ipAddr);
    }
    return retVal;
}

SlNetIfWifi_getSockName()

int32_t SlNetIfWifi_getSockName	(	int16_t	sd,
		void *	sdContext,
		SlNetSock_Addr_t *	addr,
		SlNetSocklen_t *	addrlen
	)

Get local address info by socket descriptor
Returns the local address info of the socket descriptor.

Parameters

[in]	sd	Socket descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[out]	addr	The argument addr is a pointer to a SlNetSock_Addr_t 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 SlNetSock_Addr_t: - code for the address format. - 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

Zero on success, or negative on failure.

See also

SlNetSock_create SlNetSock_bind

Note

If the provided buffer is too small the returned address will be truncated and the addrlen will contain the actual size of the socket address

Warning

Definition at line 196 of file slnetifwifi.c.

{
// Not implemented in NWP
    return SLNETERR_INVALPARAM;
}

SlNetIfWifi_getSockOpt()

int32_t SlNetIfWifi_getSockOpt	(	int16_t	sd,
		void *	sdContext,
		int16_t	level,
		int16_t	optname,
		void *	optval,
		SlNetSocklen_t *	optlen
	)

Get socket options.

The SlNetIfWifi_getSockOpt function gets the options associated with a socket. Options may exist at multiple protocol levels; they are always present at the uppermost socket level.
The parameters optval and optlen identify a buffer in which the value for the requested option(s) are to be returned. 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 descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[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

SlNetIfWifi_setSockOpt

Note

Warning

Definition at line 266 of file slnetifwifi.c.

{
    SlSocklen_t len;
    int32_t status = 0;
    SlNetSock_Timeval_t *slNetSockTimeVal;
    SlTimeval_t tv;

    switch (level)
    {
        case SLNETSOCK_LVL_SOCKET:
        {
            switch (optname)
            {
                case SLNETSOCK_OPSOCK_RCV_TIMEO:
                {
                    if (*optlen < sizeof(SlNetSock_Timeval_t))
                    {
                        return (SLNETERR_RET_CODE_INVALID_INPUT);
                    }
                    len = sizeof(SlTimeval_t);
                    status =
                        sl_GetSockOpt(sd, level, optname, (void *)&tv, &len);

                    slNetSockTimeVal = (SlNetSock_Timeval_t *)optval;
                    slNetSockTimeVal->tv_sec = tv.tv_sec;
                    slNetSockTimeVal->tv_usec = tv.tv_usec;
                    *optlen = sizeof(SlNetSock_Timeval_t);
                    break;
                }

                default:
                {
                    /* Pass values into sl_SetSockOpt directly */
                    status = sl_GetSockOpt(sd, level, optname, optval, optlen);
                    break;
                }

            }
            break;
        }
        default:
        {
            /* Pass values into sl_SetSockOpt directly */
            status = sl_GetSockOpt(sd, level, optname, optval, optlen);
            break;
        }
    }

    return (status);
}

SlNetIfWifi_listen()

int32_t SlNetIfWifi_listen	(	int16_t	sd,
		void *	sdContext,
		int16_t	backlog
	)

Listen for connections on a socket.

The willingness to accept incoming connections and a queue limit for incoming connections are specified with SlNetIfWifi_listen(), and then the connections are accepted with SlNetIfWifi_accept().
The SlNetIfWifi_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]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[in]	backlog	Specifies the listen queue depth.

Returns

Zero on success, or negative error code on failure

See also

SlNetIfWifi_Socket SlNetIfWifi_accept SlNetIfWifi_bind

Note

Warning

Definition at line 173 of file slnetifwifi.c.

{
    return sl_Listen(sd, backlog);
}

SlNetIfWifi_loadSecObj()

int32_t SlNetIfWifi_loadSecObj	(	void *	ifContext,
		uint16_t	objType,
		char *	objName,
		int16_t	objNameLen,
		uint8_t *	objBuff,
		int16_t	objBuffLen
	)

Load secured buffer to the network stack.

The SlNetSock_secLoadObj function loads buffer/files into the inputted network stack for future usage of the socket SSL/TLS connection. This option is relevant for network stacks with file system and also for network stacks that lack file system that can store the secured files.

Parameters

[in]	ifContext	Stores interface data if CreateContext function supported and implemented. Can be used in all SlNetIf_Config_t functions
[in]	objType	Specifies the security object type which could be one of the following: SLNETIF_SEC_OBJ_TYPE_RSA_PRIVATE_KEY SLNETIF_SEC_OBJ_TYPE_CERTIFICATE SLNETIF_SEC_OBJ_TYPE_DH_KEY
[in]	objName	Specifies the name/input identifier of the secured buffer loaded for file systems - this can be the file name for plain text buffer loading this can be the name of the object
[in]	objNameLen	Specifies the buffer name length to be loaded.
[in]	objBuff	Specifies the pointer to the secured buffer to be loaded.
[in]	objBuffLen	Specifies the buffer length to be loaded.

Returns

On success, buffer type handler index to be used when attaching the secured buffer to a socket.
A successful return code should be a positive number (int16)
On error, a negative value will be returned specifying the error code.

• SLNETERR_STATUS_ERROR - load operation failed

See also

SlNetIfWifi_setSockOpt

Note

Warning

Definition at line 538 of file slnetifwifi.c.

{
    int32_t   retVal;    /* negative retVal is an error */
    uint16_t  i;
    uint32_t  Offset            = 0;
    uint32_t  MasterToken       = 0;
    int32_t   OpenFlags         = 0;
    int32_t   DeviceFileHandle  = (-1);
    uint16_t  macAddressLen     = SL_MAC_ADDR_LEN;
    char      *deviceFileName   = objName;
    uint8_t   macAddress[SL_MAC_ADDR_LEN];

    /* Check if the inputs exists                                            */
    if ((NULL == objName) || (NULL == objBuff))
    {
        /* input not valid, return error code                                */
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }
    /* Print device MAC address                                              */
    retVal = sl_NetCfgGet(SL_NETCFG_MAC_ADDRESS_GET, 0, &macAddressLen, &macAddress[0]);

    /* Generating Random MasterPassword but constant per deviceFileName      */
    for (i = 0; i < strlen(deviceFileName); i++)
    {
        MasterToken = ((MasterToken << 8) ^ deviceFileName[i]);
    }

    /* Create a file and write data. The file is secured, without
       signature and with a fail safe commit, with vendor token which is
       a XOR combination between the MAC address of the device and the
       object file name                                                      */
    OpenFlags = SL_FS_CREATE;
    OpenFlags |= SL_FS_OVERWRITE;
    OpenFlags |= SL_FS_CREATE_SECURE;
    OpenFlags |= SL_FS_CREATE_VENDOR_TOKEN;
    OpenFlags |= SL_FS_CREATE_NOSIGNATURE;
    OpenFlags |= SL_FS_CREATE_FAILSAFE;

    /* Create a secure file if not exists and open it for write.             */
    DeviceFileHandle =  sl_FsOpen((unsigned char *)deviceFileName, OpenFlags | SL_FS_CREATE_MAX_SIZE( objBuffLen ), (unsigned long *)&MasterToken);

    /* Check if file created successfully                                    */
    if ( DeviceFileHandle < SLNETERR_RET_CODE_OK )
    {
        return DeviceFileHandle;
    }

    Offset = 0;
    /* Write the buffer to the new file                                      */
    retVal = sl_FsWrite(DeviceFileHandle, Offset, (unsigned char *)objBuff, objBuffLen);

    /* Close the file                                                        */
    retVal = sl_FsClose(DeviceFileHandle, NULL, NULL , 0);

    return retVal;
}

SlNetIfWifi_recv()

int32_t SlNetIfWifi_recv	(	int16_t	sd,
		void *	sdContext,
		void *	buf,
		uint32_t	len,
		uint32_t	flags
	)

Read data from TCP socket.

The SlNetIfWifi_recv function receives a message from a connection-mode socket

Parameters

[in]	sd	Socket descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[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	Upper 8 bits specifies the security flags Lower 24 bits specifies the type of message reception. On this version, the lower 24 bits are 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 SLNETERR_BSD_EAGAIN.
SLNETERR_BSD_ENOMEM 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

SlNetIfWifi_recvFrom

Note

Warning

Examples

• Receiving data using TCP socket:

  SlNetSock_AddrIn_t  Addr;
  SlNetSock_AddrIn_t  LocalAddr;
  int16_t AddrSize = sizeof(SlNetSock_AddrIn_t);
  int16_t SockID, newSockID;
  int16_t Status;
  int8_t Buf[RECV_BUF_LEN];
  
  LocalAddr.sin_family = SLNETSOCK_AF_INET;
  LocalAddr.sin_port = SlNetSock_htons(5001);
  LocalAddr.sin_addr.s_addr = 0;
  
  Addr.sin_family = SLNETSOCK_AF_INET;
  Addr.sin_port = SlNetSock_htons(5001);
  Addr.sin_addr.s_addr = SlNetSock_htonl(SLNETSOCK_IPV4_VAL(10,1,1,200));
  
  SockID = SlNetIfWifi_socket(SLNETSOCK_AF_INET, SLNETSOCK_SOCK_STREAM, 0, 0, 0);
  Status = SlNetIfWifi_bind(SockID, (SlNetSock_Addr_t *)&LocalAddr, AddrSize);
  Status = SlNetIfWifi_listen(SockID, 0);
  newSockID = SlNetIfWifi_accept(SockID, (SlNetSock_Addr_t*)&Addr, (SlNetSocklen_t*) &AddrSize);
  Status = SlNetIfWifi_recv(newSockID, Buf, 1460, 0);

  
  
• Rx transceiver mode using a raw socket:

  int8_t buffer[1536];
  int16_t sd;
  uint16_t size;
  SlNetSock_TransceiverRxOverHead_t *transHeader;
  sd = SlNetIfWifi_socket(SLNETSOCK_AF_RF, SLNETSOCK_SOCK_RAW, 11, 0, 0); // channel 11
  while(1)
  {
      size = SlNetIfWifi_recv(sd,buffer,1536,0);
      transHeader = (SlNetSock_TransceiverRxOverHead_t *)buffer;
      printf("RSSI is %d frame type is 0x%x size %d\n",transHeader->rssi,buffer[sizeof(SlNetSock_TransceiverRxOverHead_t)],size);
  }

Definition at line 323 of file slnetifwifi.c.

{
    DISABLE_SEC_BITS_FROM_INPUT_FLAGS(flags);
    return sl_Recv(sd, buf, len, flags);
}

SlNetIfWifi_recvFrom()

int32_t SlNetIfWifi_recvFrom	(	int16_t	sd,
		void *	sdContext,
		void *	buf,
		uint32_t	len,
		uint32_t	flags,
		SlNetSock_Addr_t *	from,
		SlNetSocklen_t *	fromlen
	)

Read data from socket.

SlNetIfWifi_recvFrom function receives a message from a connection-mode or connectionless-mode socket

Parameters

[in]	sd	Socket descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[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	Upper 8 bits specifies the security flags Lower 24 bits specifies the type of message reception. On this version, the lower 24 bits are not supported
[in]	from	Pointer to an address structure indicating the source address. sockaddr: - code for the address format. - 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 SLNETERR_BSD_EAGAIN. SLNETSOCK_RET_CODE_INVALID_INPUT (-2) will be returned if fromlen has incorrect length.
SLNETERR_BSD_ENOMEM 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

SlNetIfWifi_recv

Note

Warning

Example

• Receiving data:

  SlNetSock_AddrIn_t  Addr;
  SlNetSock_AddrIn_t  LocalAddr;
  int16_t AddrSize = sizeof(SlNetSock_AddrIn_t);
  int16_t SockID;
  int16_t Status;
  int8_t Buf[RECV_BUF_LEN];
  
  LocalAddr.sin_family = SLNETSOCK_AF_INET;
  LocalAddr.sin_port = SlNetSock_htons(5001);
  LocalAddr.sin_addr.s_addr = 0;
  
  SockID = SlNetIfWifi_socket(SLNETSOCK_AF_INET, SLNETSOCK_SOCK_DGRAM, 0, 0, 0);
  Status = SlNetIfWifi_bind(SockID, (SlNetSock_Addr_t *)&LocalAddr, AddrSize);
  Status = SlNetIfWifi_recvFrom(SockID, Buf, 1472, 0, (SlNetSock_Addr_t *)&Addr, (SlNetSocklen_t*)&AddrSize);

Definition at line 335 of file slnetifwifi.c.

{
    DISABLE_SEC_BITS_FROM_INPUT_FLAGS(flags);
    return sl_RecvFrom(sd, buf, len, flags, (SlSockAddr_t *)from, fromlen);
}

SlNetIfWifi_select()

int32_t SlNetIfWifi_select	(	void *	ifContext,
		int16_t	nfds,
		SlNetSock_SdSet_t *	readsds,
		SlNetSock_SdSet_t *	writesds,
		SlNetSock_SdSet_t *	exceptsds,
		SlNetSock_Timeval_t *	timeout
	)

Monitor socket activity.

SlNetIfWifi_send 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 sdset is the one that retrieved in the first triggered call. To enable the trigger mode, an handler must be statically registered to the slcb_SocketTriggerEventHandler (user.h)

Parameters

[in]	ifContext	Stores interface data if CreateContext function supported and implemented. Can be used in all SlNetIf_Config_t functions
[in]	nsds	The highest-numbered file descriptor in any of the three sets, plus 1.
[in,out]	readsds	Socket descriptors list for read monitoring and accept monitoring
[in,out]	writesds	Socket descriptors list for connect monitoring only, write monitoring is not supported
[in,out]	exceptsds	Socket descriptors list for exception monitoring, not supported.
[in]	timeout	Is an upper bound on the amount of time elapsed before SlNetIfWifi_send() 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 timeout fields must be set to zero.

Returns

On success, SlNetIfWifi_send() returns the number of file descriptors contained in the three returned descriptor sets (that is, the total number of bits that are set in readsds, writesds, exceptsds) 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.
SLNETERR_BSD_ENOMEM 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

SlNetIfWifi_socket

Note

If the timeout value set to less than 10ms it will automatically set to 10ms to prevent overload of the system
Only one SlNetIfWifi_send can be handled at a time. Calling this API while the same command is called from another thread, may result in one of the following scenarios:

1. The command will wait (internal) until the previous command finish, and then be executed.
2. There are not enough resources and SLNETERR_BSD_ENOMEM error will return. In this case, MAX_CONCURRENT_ACTIONS can be increased (result in memory increase) or try again later to issue the command.
3. In case there is already a triggered SlNetIfWifi_send in progress, the following call will return with SLNETSOCK_RET_CODE_SOCKET_SELECT_IN_PROGRESS_ERROR.

Warning

Definition at line 208 of file slnetifwifi.c.

{
    SlNetSock_Timeval_t *slNetSockTimeVal;
    SlTimeval_t tv;
    /* Translate from SlNetSock_Timeval_t into SlTimeval_t */
    slNetSockTimeVal = (SlNetSock_Timeval_t *)timeout;
    tv.tv_sec = slNetSockTimeVal->tv_sec;
    tv.tv_usec = slNetSockTimeVal->tv_usec;
    return sl_Select(nfds, (SlFdSet_t *)readsds, (SlFdSet_t *)writesds, (SlFdSet_t *)exceptsds, &tv);
}

SlNetIfWifi_send()

int32_t SlNetIfWifi_send	(	int16_t	sd,
		void *	sdContext,
		const void *	buf,
		uint32_t	len,
		uint32_t	flags
	)

Write data to TCP socket.

The SlNetIfWifi_send 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 SLNETSOCK_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 descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[in]	buf	Points to a buffer containing the message to be sent
[in]	len	Message size in bytes. Range: 1-1460 bytes
[in]	flags	Upper 8 bits specifies the security flags Lower 24 bits specifies the type of message reception. On this version, the lower 24 bits are not supported for TCP. For transceiver mode, the SLNETSOCK_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

SlNetIfWifi_sendTo

Note

Warning

Example

• Sending data:

  SlNetSock_AddrIn_t  Addr;
  int16_t AddrSize = sizeof(SlNetSock_AddrIn_t);
  int16_t SockID;
  int16_t Status;
  int8_t Buf[SEND_BUF_LEN];
  
  Addr.sin_family = SLNETSOCK_AF_INET;
  Addr.sin_port = SlNetSock_htons(5001);
  Addr.sin_addr.s_addr = SlNetSock_htonl(SLNETSOCK_IPV4_VAL(10,1,1,200));
  
  SockID = SlNetIfWifi_socket(SLNETSOCK_AF_INET, SLNETSOCK_SOCK_STREAM, 0, 0, 0);
  Status = SlNetIfWifi_connect(SockID, (SlNetSock_Addr_t *)&Addr, AddrSize);
  Status = SlNetIfWifi_send(SockID, Buf, 1460, 0 );

Definition at line 347 of file slnetifwifi.c.

{
    DISABLE_SEC_BITS_FROM_INPUT_FLAGS(flags);
    return sl_Send(sd, buf, len, flags);
}

SlNetIfWifi_sendTo()

int32_t SlNetIfWifi_sendTo	(	int16_t	sd,
		void *	sdContext,
		const void *	buf,
		uint32_t	len,
		uint32_t	flags,
		const SlNetSock_Addr_t *	to,
		SlNetSocklen_t	tolen
	)

Write data to socket.

The SlNetIfWifi_sendTo function is used to transmit a message on a connectionless socket (connection less socket SLNETSOCK_SOCK_DGRAM, SLNETSOCK_SOCK_RAW).
Returns immediately after sending data to device.
In case of transmission failure an async event SLNETSOCK_SOCKET_TX_FAILED_EVENT is going to be received.

Parameters

[in]	sd	Socket descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[in]	buf	Points to a buffer containing the message to be sent
[in]	len	message size in bytes. Range: 1-1460 bytes
[in]	flags	Upper 8 bits specifies the security flags Lower 24 bits specifies the type of message reception. On this version, the lower 24 bits are not supported
[in]	to	Pointer to an address structure indicating the destination address. sockaddr: - code for the address format. - 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

SlNetIfWifi_send

Note

Warning

Example

• Sending data:

  SlNetSock_AddrIn_t  Addr;
  int16_t AddrSize = sizeof(SlNetSock_AddrIn_t);
  int16_t SockID;
  int16_t Status;
  int8_t Buf[SEND_BUF_LEN];
  
  Addr.sin_family = SLNETSOCK_AF_INET;
  Addr.sin_port = SlNetSock_htons(5001);
  Addr.sin_addr.s_addr = SlNetSock_htonl(SLNETSOCK_IPV4_VAL(10,1,1,200));
  
  SockID = SlNetIfWifi_socket(SLNETSOCK_AF_INET, SLNETSOCK_SOCK_DGRAM, 0, 0, 0);
  Status = SlNetIfWifi_sendTo(SockID, Buf, 1472, 0, (SlNetSock_Addr_t *)&Addr, AddrSize);

Definition at line 359 of file slnetifwifi.c.

{
    DISABLE_SEC_BITS_FROM_INPUT_FLAGS(flags);
    return sl_SendTo(sd, buf, len, flags, (const SlSockAddr_t *)to, tolen);
}

SlNetIfWifi_setSockOpt()

int32_t SlNetIfWifi_setSockOpt	(	int16_t	sd,
		void *	sdContext,
		int16_t	level,
		int16_t	optname,
		void *	optval,
		SlNetSocklen_t	optlen
	)

Set socket options-.

The SlNetIfWifi_setSockOpt 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 protocol 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 opt_values for SlNetIfWifi_setSockOpt(). For SlNetIfWifi_getSockOpt() they identify a buffer in which the value for the requested option(s) are to be returned. For SlNetIfWifi_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 descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[in]	level	Defines the protocol level for this option SLNETSOCK_LVL_SOCKET Socket level configurations (L4, transport layer) SLNETSOCK_LVL_IP IP level configurations (L3, network layer) SLNETSOCK_LVL_PHY Link level configurations (L2, link layer)
[in]	optname	Defines the option name to interrogate SLNETSOCK_LVL_SOCKET SLNETSOCK_OPSOCK_RCV_BUF Sets tcp max recv window size. This options takes SlNetSock_Winsize_t struct as parameter SLNETSOCK_OPSOCK_RCV_TIMEO Sets the timeout value that specifies the maximum amount of time an input function waits until it completes. Default: No timeout This options takes SlNetSock_Timeval_t struct as parameter SLNETSOCK_OPSOCK_KEEPALIVE Enable or Disable periodic keep alive. Keeps TCP connections active by enabling the periodic transmission of messages Timeout is 5 minutes. Default: Enabled This options takes SlNetSock_Keepalive_t struct as parameter SLNETSOCK_OPSOCK_KEEPALIVE_TIME Set keep alive timeout. Value is in seconds Default: 5 minutes SLNETSOCK_OPSOCK_LINGER Socket lingers on close pending remaining send/receive packets SLNETSOCK_OPSOCK_NON_BLOCKING Sets socket to non-blocking operation Impacts: connect, accept, send, sendto, recv and recvfrom. Default: Blocking. This options takes SlNetSock_Nonblocking_t struct as parameter SLNETSOCK_OPSOCK_NON_IP_BOUNDARY Enable or Disable rx ip boundary. In connectionless socket (udp/raw), unread data is dropped (when SlNetIfWifi_recvfrom len parameter < data size), Enable this option in order to read the left data on the next SlNetIfWifi_recvfrom iteration Default: Disabled, IP boundary kept, This options takes SlNetSock_NonIpBoundary_t struct as parameter SLNETSOCK_LVL_IP SLNETSOCK_OPIP_MULTICAST_TTL Set the time-to-live value of outgoing multicast packets for this socket. This options takes uint8_t as parameter SLNETSOCK_OPIP_ADD_MEMBERSHIP UDP socket, Join a multicast group. This options takes SlNetSock_IpMreq_t struct as parameter SLNETSOCK_OPIP_DROP_MEMBERSHIP UDP socket, Leave a multicast group This options takes SlNetSock_IpMreq_t struct as parameter SLNETSOCK_OPIP_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 uint32_t as parameter SLNETSOCK_OPIP_RAW_RX_NO_HEADER Raw socket remove IP header from received data. Default: data includes ip header This options takes uint32_t as parameter SLNETSOCK_OPIP_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 uint32_t as parameter SLNETSOCK_LVL_PHY SLNETSOCK_OPPHY_CHANNEL Sets channel in transceiver mode. This options takes uint32_t as channel number parameter SLNETSOCK_OPPHY_RATE RAW socket, set WLAN PHY transmit rate The values are based on SlWlanRateIndex_e This options takes uint32_t as parameter SLNETSOCK_OPPHY_TX_POWER RAW socket, set WLAN PHY TX power Valid rage is 1-15 This options takes uint32_t as parameter SLNETSOCK_OPPHY_NUM_FRAMES_TO_TX RAW socket, set number of frames to transmit in transceiver mode. Default: 1 packet This options takes uint32_t as parameter SLNETSOCK_OPPHY_PREAMBLE RAW socket, set WLAN PHY preamble for Long/Short This options takes uint32_t as parameter SLNETSOCK_OPPHY_TX_INHIBIT_THRESHOLD RAW socket, set WLAN Tx - Set CCA threshold. The values are based on SlNetSockTxInhibitThreshold_e This options takes uint32_t as parameter SLNETSOCK_OPPHY_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 uint32_t as parameter SLNETSOCK_OPPHY_ALLOW_ACKS RAW socket, set WLAN Tx - Enable or Disable sending ACKs in transceiver mode 0 = disabled / 1 = enabled This options takes uint32_t as parameter
[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

SlNetIfWifi_getSockOpt

Note

Warning

Examples

• SLNETSOCK_OPSOCK_RCV_BUF:

  SlNetSock_Winsize_t size;
  size.winsize = 3000; // bytes
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPSOCK_RCV_BUF, (uint8_t *)&size, sizeof(size));

  
  
• SLNETSOCK_OPSOCK_RCV_TIMEO:

  struct SlNetSock_Timeval_t timeVal;
  timeVal.tv_sec =  1; // Seconds
  timeVal.tv_usec = 0; // Microseconds. 10000 microseconds resolution
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPSOCK_RCV_TIMEO, (uint8_t *)&timeVal, sizeof(timeVal)); // Enable receive timeout

  
  
• SLNETSOCK_OPSOCK_KEEPALIVE: //disable Keepalive

  SlNetSock_Keepalive_t enableOption;
  enableOption.keepaliveEnabled = 0;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPSOCK_KEEPALIVE, (uint8_t *)&enableOption, sizeof(enableOption));

  
  
• SLNETSOCK_OPSOCK_KEEPALIVE_TIME: //Set Keepalive timeout

  int16_t Status;
  uint32_t TimeOut = 120;
  SlNetIfWifi_setSockOpt(Sd, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPSOCK_KEEPALIVE_TIME, (uint8_t *)&TimeOut, sizeof(TimeOut));

  
  
• SLNETSOCK_OPSOCK_NON_BLOCKING: //Enable or disable nonblocking mode

  SlNetSock_Nonblocking_t enableOption;
  enableOption.nonBlockingEnabled = 1;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPSOCK_NON_BLOCKING, (uint8_t *)&enableOption, sizeof(enableOption));

  
  
• SLNETSOCK_OPSOCK_NON_IP_BOUNDARY: //disable boundary

  SlNetSock_NonIpBoundary_t enableOption;
  enableOption.nonIpBoundaryEnabled = 1;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPSOCK_NON_IP_BOUNDARY, (uint8_t *)&enableOption, sizeof(enableOption));

  
  
• SLNETSOCK_OPSOCK_LINGER:

  SlNetSock_linger_t linger;
  linger.l_onoff = 1;
  linger.l_linger = 10;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPSOCK_LINGER, &linger, sizeof(linger));

  
  
• SLNETSOCK_OPIP_MULTICAST_TTL:

  uint8_t ttl = 20;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_IP, SLNETSOCK_OPIP_MULTICAST_TTL, &ttl, sizeof(ttl));

  
  
• SLNETSOCK_OPIP_ADD_MEMBERSHIP:

  SlNetSock_IpMreq_t mreq;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_IP, SLNETSOCK_OPIP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));

  
  
• SLNETSOCK_OPIP_DROP_MEMBERSHIP:

  SlNetSock_IpMreq_t mreq;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_IP, SLNETSOCK_OPIP_DROP_MEMBERSHIP, &mreq, sizeof(mreq));

  
  
• SLNETSOCK_OPIP_RAW_RX_NO_HEADER:

  uint32_t header = 1;  // remove ip header
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_IP, SLNETSOCK_OPIP_RAW_RX_NO_HEADER, &header, sizeof(header));

  
  
• SLNETSOCK_OPIP_HDRINCL:

  uint32_t header = 1;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_IP, SLNETSOCK_OPIP_HDRINCL, &header, sizeof(header));

  
  
• SLNETSOCK_OPIP_RAW_IPV6_HDRINCL:

  uint32_t header = 1;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_IP, SLNETSOCK_OPIP_RAW_IPV6_HDRINCL, &header, sizeof(header));

  
  
• SLNETSOCK_OPPHY_CHANNEL:

  uint32_t newChannel = 6; // range is 1-13
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_SOCKET, SLNETSOCK_OPPHY_CHANNEL, &newChannel, sizeof(newChannel));

  
  
• SLNETSOCK_OPPHY_RATE:

  uint32_t rate = 6; // see wlan.h SlWlanRateIndex_e for values
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_PHY, SLNETSOCK_OPPHY_RATE, &rate, sizeof(rate));

  
  
• SLNETSOCK_OPPHY_TX_POWER:

  uint32_t txpower = 1; // valid range is 1-15
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_PHY, SLNETSOCK_OPPHY_TX_POWER, &txpower, sizeof(txpower));

  
  
• SLNETSOCK_OPPHY_NUM_FRAMES_TO_TX:

  uint32_t numframes = 1;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_PHY, SLNETSOCK_OPPHY_NUM_FRAMES_TO_TX, &numframes, sizeof(numframes));

  
  
• SLNETSOCK_OPPHY_PREAMBLE:

  uint32_t preamble = 1;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_PHY, SLNETSOCK_OPPHY_PREAMBLE, &preamble, sizeof(preamble));

  
  
• SLNETSOCK_OPPHY_TX_INHIBIT_THRESHOLD:

  uint32_t thrshld = SLNETSOCK_TX_INHIBIT_THRESHOLD_MED;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_PHY, SLNETSOCK_OPPHY_TX_INHIBIT_THRESHOLD , &thrshld, sizeof(thrshld));

  
  
• SLNETSOCK_OPPHY_TX_TIMEOUT:

  uint32_t timeout = 50;
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_PHY, SLNETSOCK_OPPHY_TX_TIMEOUT  , &timeout, sizeof(timeout));

  
  
• SLNETSOCK_OPPHY_ALLOW_ACKS:

  uint32_t acks = 1; // 0 = disabled / 1 = enabled
  SlNetIfWifi_setSockOpt(SockID, sdContext, SLNETSOCK_LVL_PHY, SLNETSOCK_OPPHY_ALLOW_ACKS, &acks, sizeof(acks));

  
  

Definition at line 225 of file slnetifwifi.c.

{
    SlNetSock_Timeval_t *slNetSockTimeVal;
    SlTimeval_t tv;

    switch (level)
    {
        case SLNETSOCK_LVL_SOCKET:
        {
            switch (optname)
            {
                case SLNETSOCK_OPSOCK_RCV_TIMEO:
                {
                    /* Translate from SlNetSock_Timeval_t into SlTimeval_t */
                    slNetSockTimeVal = (SlNetSock_Timeval_t *)optval;
                    tv.tv_sec = slNetSockTimeVal->tv_sec;
                    tv.tv_usec = slNetSockTimeVal->tv_usec;
                    optval = (void *)&tv;
                    optlen = sizeof(SlTimeval_t);
                    break;
                }
                default:
                    /* Pass values into sl_SetSockOpt directly */
                    break;
            }
            break;
        }
        default:
            /* Pass values into sl_SetSockOpt directly */
            break;
    }

    return sl_SetSockOpt(sd, level, optname, optval, optlen);
}

SlNetIfWifi_socket()

int16_t SlNetIfWifi_socket	(	void *	ifContext,
		int16_t	Domain,
		int16_t	Type,
		int16_t	Protocol,
		void **	sdContext
	)

Create an endpoint for communication.

The SlNetIfWifi_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 descriptor (handle).

Parameters

[in]	ifContext	Stores interface data if CreateContext function supported and implemented.
[in]	domain	Specifies the protocol family of the created socket. For example: SLNETSOCK_AF_INET for network protocol IPv4 SLNETSOCK_AF_INET6 for network protocol IPv6 SLNETSOCK_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 socket type, which determines the semantics of communication over the socket. The socket types supported by the system are implementation-dependent. Possible socket types include: SLNETSOCK_SOCK_STREAM (reliable stream-oriented service or Stream Sockets) SLNETSOCK_SOCK_DGRAM (datagram service or Datagram Sockets) SLNETSOCK_SOCK_RAW (raw protocols atop the network layer) when used with AF_RF: SLNETSOCK_SOCK_RX_MTR SLNETSOCK_SOCK_MAC_WITH_CCA SLNETSOCK_SOCK_MAC_WITH_NO_CCA SLNETSOCK_SOCK_BRIDGE SLNETSOCK_SOCK_ROUTER
[in]	protocol	Specifies a particular transport to be used with the socket. The most common are SLNETSOCK_PROTO_TCP SLNETSOCK_PROTO_UDP SLNETSOCK_PROTO_RAW SLNETSOCK_PROTO_SECURE The value 0 may be used to select a default protocol from the selected domain and type
[in]	sdContext	Allocate and store socket data if needed for using in other slnetwifi socket functions

Returns

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

• SLNETERR_BSD_EAFNOSUPPORT - illegal domain parameter
• SLNETERR_BSD_EPROTOTYPE - illegal type parameter
• SLNETERR_BSD_EACCES - permission denied
• SLNETERR_BSD_ENSOCK - exceeded maximal number of socket
• SLNETERR_BSD_ENOMEM - memory allocation error
• SLNETERR_BSD_EINVAL - error in socket configuration
• SLNETERR_BSD_EPROTONOSUPPORT - illegal protocol parameter
• SLNETERR_BSD_EOPNOTSUPP - illegal combination of protocol and type parameters

See also

SlNetIfWifi_socket

Note

Warning

Definition at line 126 of file slnetifwifi.c.

{
    /* Create socket and return the return value of the function             */
    int16_t mappedSocketType = socketType[Type - 1];
    return (sl_Socket(Domain, mappedSocketType, Protocol));
}

SlNetIfWifi_sockstartSec()

int32_t SlNetIfWifi_sockstartSec	(	int16_t	sd,
		void *	sdContext,
		SlNetSockSecAttrib_t *	secAttrib,
		uint8_t	flags
	)

Start a security session on an opened socket.

The SlNetIfWifi_sockstartSec function is used start a security session on an opened socket. If the security handle is NULL the session would be started with the default security settings.

Parameters

[in]	sd	Socket descriptor (handle)
[in]	sdContext	May store socket data if implemented in the SlNetIfWifi_socket function.
[in]	secAttrib	Secure attribute handle
[in]	flags	Specifies flags. The available flags are: SLNETSOCK_SEC_START_SECURITY_SESSION_ONLY SLNETSOCK_SEC_BIND_CONTEXT_ONLY SLNETSOCK_SEC_IS_SERVER

Returns

Zero on success, or negative error code on failure

See also

Note

Warning

Example

• start security session on an opened socket:

Definition at line 371 of file slnetifwifi.c.

{
    SlNetSock_SecAttribNode_t *tempSecAttrib = *secAttrib;
    int32_t                   retVal         = SLNETERR_RET_CODE_OK;

    if ( 0 != (flags & SLNETSOCK_SEC_BIND_CONTEXT_ONLY)  )
    {
        /* run over all attributes and set them                              */
        while (NULL != tempSecAttrib)
        {
            if ( tempSecAttrib->attribName <= SLNETSOCK_SEC_ATTRIB_DISABLE_CERT_STORE)
            {
                retVal = sl_SetSockOpt(sd, SL_SOL_SOCKET, StartSecOptName[tempSecAttrib->attribName], tempSecAttrib->attribBuff, tempSecAttrib->attribBuffLen);
            }
            else
            {
                return SLNETERR_RET_CODE_INVALID_INPUT;
            }
            tempSecAttrib = tempSecAttrib->next;
        }
    }

    if ( 0 != (flags & SLNETSOCK_SEC_START_SECURITY_SESSION_ONLY)  )
    {
        /* Start TLS session                                                 */
        retVal = sl_StartTLS(sd);
    }

    return retVal;
}

---

Data Structure Documentation

SlInAddr_t

struct SlInAddr_t

Definition at line 223 of file sl_socket.h.

Data Fields
_u32	s_addr
union S_un	S_un

SlInAddr_t::S_un

union SlInAddr_t::S_un

Definition at line 228 of file sl_socket.h.

Data Fields
_u32	S_addr
struct S_un	S_un_b
struct S_un	S_un_w

SlInAddr_t::S_un.S_un_b

struct SlInAddr_t::S_un.S_un_b

Definition at line 229 of file sl_socket.h.

Data Fields
_u8	s_b1
_u8	s_b2
_u8	s_b3
_u8	s_b4

SlInAddr_t::S_un.S_un_w

struct SlInAddr_t::S_un.S_un_w

Definition at line 230 of file sl_socket.h.

Data Fields
_u16	s_w1
_u16	s_w2

SlIn6Addr_t

struct SlIn6Addr_t

Definition at line 237 of file sl_socket.h.

Data Fields
union SlIn6Addr_t	_S6_un

SlIn6Addr_t._S6_un

union SlIn6Addr_t._S6_un

Definition at line 239 of file sl_socket.h.

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

SlSockKeepalive_t

struct SlSockKeepalive_t

Definition at line 248 of file sl_socket.h.

Data Fields
_u32	KeepaliveEnabled

SlSockReuseaddr_t

struct SlSockReuseaddr_t

Definition at line 253 of file sl_socket.h.

Data Fields
_u32	ReuseaddrEnabled

SlSockRxNoIpBoundary_t

struct SlSockRxNoIpBoundary_t

Definition at line 258 of file sl_socket.h.

Data Fields
_i32	RxIpNoBoundaryEnabled

SlSockWinsize_t

struct SlSockWinsize_t

Definition at line 263 of file sl_socket.h.

Data Fields
_u32	WinSize

SlSockNonblocking_t

struct SlSockNonblocking_t

Definition at line 268 of file sl_socket.h.

Data Fields
_u32	NonBlockingEnabled

SlSocketAsyncEvent_t

struct SlSocketAsyncEvent_t

Definition at line 273 of file sl_socket.h.

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

SlSockTxFailEventData_t

struct SlSockTxFailEventData_t

Definition at line 281 of file sl_socket.h.

Data Fields
_u8	Padding
_u8	Sd
_i16	Status

SlSockEventData_u

union SlSockEventData_u

Definition at line 289 of file sl_socket.h.

Data Fields
SlSocketAsyncEvent_t	SockAsyncData
SlSockTxFailEventData_t	SockTxFailData

SlSockEvent_t

struct SlSockEvent_t

Definition at line 296 of file sl_socket.h.

Data Fields
_u32	Event
SlSockEventData_u	SocketAsyncEvent

SlSockTriggerEvent_t

struct SlSockTriggerEvent_t

Definition at line 302 of file sl_socket.h.

Data Fields
_u32	Event
_u32	EventData

SlSockSecureALPN_t

struct SlSockSecureALPN_t

Definition at line 309 of file sl_socket.h.

Data Fields
_u32	SecureALPN

SlSockSecureMask_t

struct SlSockSecureMask_t

Definition at line 314 of file sl_socket.h.

Data Fields
_u32	SecureMask

SlSockSecureMethod_t

struct SlSockSecureMethod_t

Definition at line 319 of file sl_socket.h.

Data Fields
_u8	SecureMethod

SlSockSSLCertInfo_t

struct SlSockSSLCertInfo_t

Definition at line 324 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 338 of file sl_socket.h.

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

SlRxMetrics_TLV_t

struct SlRxMetrics_TLV_t

Definition at line 354 of file sl_socket.h.

Data Fields
_u16	length
_u16	type

SlSockIpMreq_t

struct SlSockIpMreq_t

Definition at line 421 of file sl_socket.h.

Data Fields
SlInAddr_t	imr_interface
SlInAddr_t	imr_multiaddr

SlSockIpV6Mreq_t

struct SlSockIpV6Mreq_t

Definition at line 427 of file sl_socket.h.

Data Fields
_u32	ipv6mr_interface
SlIn6Addr_t	ipv6mr_multiaddr

SlSocklinger_t

struct SlSocklinger_t

Definition at line 432 of file sl_socket.h.

Data Fields
_u32	l_linger
_u32	l_onoff

SlTimeval_t

struct SlTimeval_t

Definition at line 442 of file sl_socket.h.

Data Fields
SlTime_t	tv_sec
SlSuseconds_t	tv_usec

SlSockAddr_t

struct SlSockAddr_t

Definition at line 451 of file sl_socket.h.

Data Fields
_u8	sa_data[14]
_u16	sa_family

SlSockAddrIn6_t

struct SlSockAddrIn6_t

Definition at line 457 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 468 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 476 of file sl_socket.h.

Data Fields
_u8	SecureFiles[4]

SlFdSet_t

struct SlFdSet_t

Definition at line 481 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 486 of file sl_socket.h.

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

SlRxMetricsEnableDisableRXOnBSS_t

struct SlRxMetricsEnableDisableRXOnBSS_t

Definition at line 495 of file sl_socket.h.

Data Fields
_u32	enableDisable

Variable Documentation

_S6_u32

_u32 _S6_u32[4]

Definition at line 242 of file sl_socket.h.

_S6_u8

_u8 _S6_u8[16]

Definition at line 241 of file sl_socket.h.

_S6_un

union { ... } _S6_un

Channel

_u8 Channel

Definition at line 489 of file sl_socket.h.

enableDisable

_u32 enableDisable

Definition at line 497 of file sl_socket.h.

Event [1/2]

_u32 Event

Definition at line 298 of file sl_socket.h.

Event [2/2]

_u32 Event

Definition at line 304 of file sl_socket.h.

EventData

_u32 EventData

Definition at line 305 of file sl_socket.h.

fd_array

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

Definition at line 483 of file sl_socket.h.

FromDate

_i8 FromDate[8]

Definition at line 328 of file sl_socket.h.

imr_interface

SlInAddr_t imr_interface

Definition at line 424 of file sl_socket.h.

imr_multiaddr

SlInAddr_t imr_multiaddr

Definition at line 423 of file sl_socket.h.

ipv6mr_interface

_u32 ipv6mr_interface

Definition at line 429 of file sl_socket.h.

ipv6mr_multiaddr

SlIn6Addr_t ipv6mr_multiaddr

Definition at line 428 of file sl_socket.h.

IssuerName

_i8 IssuerName[SL_MAX_ISSUER_AND_SUBJECT_NAME_LEN]

Definition at line 331 of file sl_socket.h.

IssuerNameLen

_i8 IssuerNameLen

Definition at line 333 of file sl_socket.h.

IssuerNameXoredSha1

_u16 IssuerNameXoredSha1

Definition at line 327 of file sl_socket.h.

KeepaliveEnabled

_u32 KeepaliveEnabled

Definition at line 250 of file sl_socket.h.

l_linger

_u32 l_linger

Definition at line 435 of file sl_socket.h.

l_onoff

_u32 l_onoff

Definition at line 434 of file sl_socket.h.

length

_u16 length

Definition at line 357 of file sl_socket.h.

NonBlockingEnabled

_u32 NonBlockingEnabled

Definition at line 270 of file sl_socket.h.

Padding [1/3]

_u8 Padding

Definition at line 285 of file sl_socket.h.

Padding [2/3]

_i8 Padding[2]

Definition at line 334 of file sl_socket.h.

Padding [3/3]

_u8 Padding

Definition at line 491 of file sl_socket.h.

pExtraInfo

_i8 pExtraInfo[128]

Definition at line 278 of file sl_socket.h.

Rate

_u8 Rate

Definition at line 488 of file sl_socket.h.

ReuseaddrEnabled

_u32 ReuseaddrEnabled

Definition at line 255 of file sl_socket.h.

Rssi

_i8 Rssi

Definition at line 490 of file sl_socket.h.

RxIpNoBoundaryEnabled

_i32 RxIpNoBoundaryEnabled

Definition at line 260 of file sl_socket.h.

s_addr

_u32 s_addr

Definition at line 226 of file sl_socket.h.

S_addr

_u32 S_addr

Definition at line 231 of file sl_socket.h.

s_b1

_u8 s_b1

Definition at line 229 of file sl_socket.h.

s_b2

_u8 s_b2

Definition at line 229 of file sl_socket.h.

s_b3

_u8 s_b3

Definition at line 229 of file sl_socket.h.

s_b4

_u8 s_b4

Definition at line 229 of file sl_socket.h.

S_un

union SlInAddr_t::S_un S_un

S_un_b

struct { ... } S_un_b

S_un_w

struct { ... } S_un_w

s_w1

_u16 s_w1

Definition at line 230 of file sl_socket.h.

s_w2

_u16 s_w2

Definition at line 230 of file sl_socket.h.

sa_data

_u8 sa_data[14]

Definition at line 454 of file sl_socket.h.

sa_family

_u16 sa_family

Definition at line 453 of file sl_socket.h.

Sd [1/2]

_u8 Sd

Definition at line 275 of file sl_socket.h.

Sd [2/2]

_u8 Sd

Definition at line 284 of file sl_socket.h.

SecureALPN

_u32 SecureALPN

Definition at line 311 of file sl_socket.h.

SecureALPNChosenProtocol

_u32 SecureALPNChosenProtocol

Definition at line 343 of file sl_socket.h.

SecureCipherSuit

_u32 SecureCipherSuit

Definition at line 341 of file sl_socket.h.

SecureFiles

_u8 SecureFiles[4]

Definition at line 478 of file sl_socket.h.

SecureIsPeerValidated

_u32 SecureIsPeerValidated

Definition at line 342 of file sl_socket.h.

SecureMask

_u32 SecureMask

Definition at line 316 of file sl_socket.h.

SecureMethod

_u8 SecureMethod

Definition at line 321 of file sl_socket.h.

SecurePeerCertinfo

SlSockSSLCertInfo_t SecurePeerCertinfo

Definition at line 350 of file sl_socket.h.

SecureVersion

_u32 SecureVersion

Definition at line 340 of file sl_socket.h.

sin6_addr

SlIn6Addr_t sin6_addr

Definition at line 462 of file sl_socket.h.

sin6_family

_u16 sin6_family

Definition at line 459 of file sl_socket.h.

sin6_flowinfo

_u32 sin6_flowinfo

Definition at line 461 of file sl_socket.h.

sin6_port

_u16 sin6_port

Definition at line 460 of file sl_socket.h.

sin6_scope_id

_u32 sin6_scope_id

Definition at line 463 of file sl_socket.h.

sin_addr

SlInAddr_t sin_addr

Definition at line 472 of file sl_socket.h.

sin_family

_u16 sin_family

Definition at line 470 of file sl_socket.h.

sin_port

_u16 sin_port

Definition at line 471 of file sl_socket.h.

sin_zero

_i8 sin_zero[8]

Definition at line 473 of file sl_socket.h.

SlNetIfConfigWifi

SlNetIf_Config_t SlNetIfConfigWifi

SlNetIfConfigWifi structure contains all the function callbacks that are expected to be filled by the relevant network stack interface Each interface has different capabilities, so not all the API's must be supported. Interface that is not supporting a non-mandatory API are set to NULL

Definition at line 65 of file slnetifwifi.c.

SockAsyncData

SlSocketAsyncEvent_t SockAsyncData

Definition at line 292 of file sl_socket.h.

SocketAsyncEvent

SlSockEventData_u SocketAsyncEvent

Definition at line 299 of file sl_socket.h.

SockTxFailData

SlSockTxFailEventData_t SockTxFailData

Definition at line 291 of file sl_socket.h.

Status

_i16 Status

Definition at line 283 of file sl_socket.h.

SubjectName

_i8 SubjectName[SL_MAX_ISSUER_AND_SUBJECT_NAME_LEN]

Definition at line 330 of file sl_socket.h.

SubjectNameLen

_i8 SubjectNameLen

Definition at line 332 of file sl_socket.h.

SubjectNameXoredSha1

_u16 SubjectNameXoredSha1

Definition at line 326 of file sl_socket.h.

Timestamp

_u32 Timestamp

Definition at line 492 of file sl_socket.h.

ToDate

_i8 ToDate[8]

Definition at line 329 of file sl_socket.h.

tv_sec

SlTime_t tv_sec

Definition at line 444 of file sl_socket.h.

tv_usec

SlSuseconds_t tv_usec

Definition at line 445 of file sl_socket.h.

Type

_u8 Type

Definition at line 276 of file sl_socket.h.

type

_u16 type

Definition at line 356 of file sl_socket.h.

Val

_i16 Val

Definition at line 277 of file sl_socket.h.

WinSize

_u32 WinSize

Definition at line 265 of file sl_socket.h.