pal_network.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// Copyright 2016-2021 Pelion.
//
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------------------------------------------------------

#ifndef _PAL_SOCKET_H
#define _PAL_SOCKET_H

#ifndef _PAL_H
#error "Please do not include this file directly, use pal.h instead"
#endif


#ifdef __cplusplus
extern "C" {
#endif

typedef uint32_t palSocketLength_t; 
typedef void *palSocket_t; 
#define  PAL_NET_MAX_ADDR_SIZE 32 // check if we can make this more efficient

typedef struct palSocketAddress {
    unsigned short    addressType;    
    char              addressData[PAL_NET_MAX_ADDR_SIZE];  
} palSocketAddress_t; 
#if PAL_NET_DNS_SUPPORT
#if (PAL_DNS_API_VERSION == 3)
typedef void *palAddressInfo_t; 
#endif // (PAL_DNS_API_VERSION == 3)
#endif // PAL_NET_DNS_SUPPORT

typedef struct palNetInterfaceInfo {
    char interfaceName[16]; //15 + ‘\0’
    palSocketAddress_t address;
    uint32_t addressSize;
} palNetInterfaceInfo_t;

typedef enum {
    PAL_AF_UNSPEC = 0,
    PAL_AF_INET = 2,    
    PAL_AF_INET6 = 10, 
} palSocketDomain_t;

typedef enum {
    PAL_NETWORK_STATUS_DISCONNECTED = 0,
    PAL_NETWORK_STATUS_CONNECTED = 1
} palNetworkStatus_t;

typedef enum {
#if PAL_NET_TCP_AND_TLS_SUPPORT
    PAL_SOCK_STREAM = 1,    
    PAL_SOCK_STREAM_SERVER = 99,    
#endif //PAL_NET_TCP_AND_TLS_SUPPORT
    PAL_SOCK_DGRAM = 2  
} palSocketType_t;

typedef enum {
    PAL_SO_REUSEADDR = 0x0004,  
#if PAL_NET_TCP_AND_TLS_SUPPORT // Socket options below supported only if TCP is supported.
    PAL_SO_KEEPALIVE = 0x0008, 
    PAL_SO_KEEPIDLE = 0x0009,  
    PAL_SO_KEEPINTVL = 0x0010, 
#endif //PAL_NET_TCP_AND_TLS_SUPPORT
    PAL_SO_SNDTIMEO = 0x1005,  
    PAL_SO_RCVTIMEO = 0x1006,  
    PAL_SO_IPV6_MULTICAST_HOPS = 0x1007,  
    PAL_SO_IPV6_TRAFFIC_CLASS = 0x1008  
} palSocketOptionName_t;

typedef enum {
    PAL_SOL_SOCKET = 0,
    PAL_SOL_IPPROTO_IPV6 = 1
} palSocketOptionLevelName_t;

#define PAL_NET_DEFAULT_INTERFACE 0xFFFFFFFF

#define PAL_IPV4_ADDRESS_SIZE 4
#define PAL_IPV6_ADDRESS_SIZE 16

typedef uint8_t palIpV4Addr_t[PAL_IPV4_ADDRESS_SIZE];
typedef uint8_t palIpV6Addr_t[PAL_IPV6_ADDRESS_SIZE];

typedef void(*connectionStatusCallback)(palNetworkStatus_t status, void *client_arg);

palStatus_t pal_registerNetworkInterface(void *networkInterfaceContext, uint32_t *interfaceIndex);

palStatus_t pal_unregisterNetworkInterface(uint32_t interfaceIndex);

palStatus_t pal_setSockAddrPort(palSocketAddress_t *address, uint16_t port);

palStatus_t pal_setSockAddrIPV4Addr(palSocketAddress_t *address, palIpV4Addr_t ipV4Addr);

palStatus_t pal_getSockAddrIPV4Addr(const palSocketAddress_t *address, palIpV4Addr_t ipV4Addr);

palStatus_t pal_setSockAddrIPV6Addr(palSocketAddress_t *address, palIpV6Addr_t ipV6Addr);

palStatus_t pal_getSockAddrIPV6Addr(const palSocketAddress_t *address, palIpV6Addr_t ipV6Addr);

palStatus_t pal_setSockAddrNAT64Addr(palSocketAddress_t *address, palIpV4Addr_t ipV4Addr);

palStatus_t pal_getSockAddrPort(const palSocketAddress_t *address, uint16_t *port);

palStatus_t pal_setSocketOptions(palSocket_t socket, int optionName, const void *optionValue, palSocketLength_t optionLength);

palStatus_t pal_setSocketOptionsWithLevel(palSocket_t socket, palSocketOptionLevelName_t optionLevel, int optionName, const void *optionValue, palSocketLength_t optionLength);

palStatus_t pal_isNonBlocking(palSocket_t socket, bool *isNonBlocking);

palStatus_t pal_bind(palSocket_t socket, palSocketAddress_t *myAddress, palSocketLength_t addressLength);

palStatus_t pal_receiveFrom(palSocket_t socket, void *buffer, size_t length, palSocketAddress_t *from, palSocketLength_t *fromLength, size_t *bytesReceived);

palStatus_t pal_sendTo(palSocket_t socket, const void *buffer, size_t length, const palSocketAddress_t *to, palSocketLength_t toLength, size_t *bytesSent);

palStatus_t pal_close(palSocket_t *socket);

palStatus_t pal_getNumberOfNetInterfaces(uint32_t *numInterfaces);

palStatus_t pal_getNetInterfaceInfo(uint32_t interfaceNum, palNetInterfaceInfo_t *interfaceInfo);

palStatus_t pal_setConnectionStatusCallback(uint32_t interfaceNum, connectionStatusCallback callback, void *client_arg);

#define PAL_NET_SOCKET_SELECT_MAX_SOCKETS 8
#define PAL_NET_SOCKET_SELECT_RX_BIT (1)
#define PAL_NET_SOCKET_SELECT_TX_BIT (2)
#define PAL_NET_SOCKET_SELECT_ERR_BIT (4)

#define PAL_NET_SELECT_IS_RX(socketStatus, index)   ((socketStatus[index] & PAL_NET_SOCKET_SELECT_RX_BIT) != 0) 
#define PAL_NET_SELECT_IS_TX(socketStatus, index)   ((socketStatus[index] & PAL_NET_SOCKET_SELECT_TX_BIT) != 0) 
#define PAL_NET_SELECT_IS_ERR(socketStatus, index)  ((socketStatus[index] & PAL_NET_SOCKET_SELECT_ERR_BIT) != 0) 
typedef void(*palAsyncSocketCallback_t)(void *);

#if PAL_NET_TCP_AND_TLS_SUPPORT // The functionality below is supported only if TCP is supported.

#if PAL_NET_SERVER_SOCKET_API

palStatus_t pal_listen(palSocket_t socket, int backlog);

palStatus_t pal_accept(palSocket_t socket, palSocketAddress_t *address, palSocketLength_t *addressLen, palSocket_t *acceptedSocket, palAsyncSocketCallback_t callback, void *callbackArgument);

#endif // PAL_NET_SERVER_SOCKET_API

palStatus_t pal_connect(palSocket_t socket, const palSocketAddress_t *address, palSocketLength_t addressLen);

palStatus_t pal_recv(palSocket_t socket, void *buf, size_t len, size_t *recievedDataSize);

palStatus_t pal_send(palSocket_t socket, const void *buf, size_t len, size_t *sentDataSize);


#endif //PAL_NET_TCP_AND_TLS_SUPPORT

palStatus_t pal_asynchronousSocket(palSocketDomain_t domain, palSocketType_t type, bool nonBlockingSocket, uint32_t interfaceNum, palAsyncSocketCallback_t callback, palSocket_t *socket);

palStatus_t pal_asynchronousSocketWithArgument(palSocketDomain_t domain, palSocketType_t type, bool nonBlockingSocket, uint32_t interfaceNum, palAsyncSocketCallback_t callback, void *callbackArgument, palSocket_t *socket);


#if PAL_NET_DNS_SUPPORT
#if (PAL_DNS_API_VERSION == 0) || (PAL_DNS_API_VERSION == 1)

palStatus_t pal_getAddressInfo(const char *hostname, palSocketAddress_t *address, palSocketLength_t *addressLength);

#if (PAL_DNS_API_VERSION == 1)

typedef void(*palGetAddressInfoAsyncCallback_t)(const char *hostname, palSocketAddress_t *address, palSocketLength_t *addressLength, palStatus_t status, void *callbackArgument);

palStatus_t pal_getAddressInfoAsync(const char *hostname, palSocketAddress_t *address, palSocketLength_t *addressLength, palGetAddressInfoAsyncCallback_t callback, void *callbackArgument);
#endif
#elif (PAL_DNS_API_VERSION == 2) || (PAL_DNS_API_VERSION == 3)
#if (PAL_DNS_API_VERSION == 2)
typedef int32_t palDNSQuery_t; 
typedef void(*palGetAddressInfoAsyncCallback_t)(const char *hostname, palSocketAddress_t *address, palStatus_t status, void *callbackArgument);

typedef struct pal_asyncAddressInfo {
    char *hostname;
    palSocketAddress_t *address;
    palGetAddressInfoAsyncCallback_t callback;
    void *callbackArgument;
    palDNSQuery_t *queryHandle;
} pal_asyncAddressInfo_t;

palStatus_t pal_getAddressInfoAsync(const char *hostname,
                                    palSocketAddress_t *address,
                                    palGetAddressInfoAsyncCallback_t callback,
                                    void *callbackArgument,
                                    palDNSQuery_t *queryHandle);

#elif (PAL_DNS_API_VERSION == 3)
typedef uintptr_t palDNSQuery_t; 
palStatus_t pal_getDNSAddress(palAddressInfo_t *addrInfo, uint16_t index, palSocketAddress_t *addr);

int pal_getDNSCount(palAddressInfo_t *addrInfo);

void pal_freeAddrInfo(palAddressInfo_t *addrInfo);

palStatus_t pal_free_addressinfoAsync(palDNSQuery_t handle);

typedef void(*palGetAddressInfoAsyncCallback_t)(const char *hostname, palAddressInfo_t *addrInfo, palStatus_t status, void *callbackArgument);

typedef struct pal_asyncAddressInfo
{
    char* hostname;
    palAddressInfo_t *addrInfo;
    palGetAddressInfoAsyncCallback_t callback;
    void* callbackArgument;
    palDNSQuery_t *queryHandle;
} pal_asyncAddressInfo_t;

palStatus_t pal_getAddressInfoAsync(const char* hostname,
                                     palGetAddressInfoAsyncCallback_t callback,
                                     void* callbackArgument,
                                     palDNSQuery_t* queryHandle);

#endif

palStatus_t pal_cancelAddressInfoAsync(palDNSQuery_t queryHandle);
#else
    #error "Please specify the platform PAL_DNS_API_VERSION 0, 1, 2 or 3"
#endif //  PAL_DNS_API_VERSION
#endif  // PAL_NET_DNS_SUPPORT

uint8_t pal_getRttEstimate();

uint16_t pal_getStaggerEstimate(uint16_t data_amount);

void pal_setFixedStaggerEstimate(uint16_t stagger_estimate);

#ifdef __cplusplus
}
#endif
#endif //_PAL_SOCKET_H