socket.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017-2018 Linaro Limited
 * Copyright (c) 2021 Nordic Semiconductor
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_SOCKET_H_
#define ZEPHYR_INCLUDE_NET_SOCKET_H_
 
#include <zephyr/kernel.h>
#include <sys/types.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/socket_select.h>
#include <zephyr/net/socket_poll.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/sys/fdtable.h>
#include <zephyr/net/dns_resolve.h>
#include <stdlib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ZSOCK_POLL* values are compatible with Linux */
#define ZSOCK_POLLIN 1
#define ZSOCK_POLLPRI 2
#define ZSOCK_POLLOUT 4
#define ZSOCK_POLLERR 8
#define ZSOCK_POLLHUP 0x10
#define ZSOCK_POLLNVAL 0x20
#define ZSOCK_MSG_PEEK 0x02
#define ZSOCK_MSG_CTRUNC 0x08
#define ZSOCK_MSG_TRUNC 0x20
#define ZSOCK_MSG_DONTWAIT 0x40
#define ZSOCK_MSG_WAITALL 0x100
/* Well-known values, e.g. from Linux man 2 shutdown:
 * "The constants SHUT_RD, SHUT_WR, SHUT_RDWR have the value 0, 1, 2,
 * respectively". Some software uses numeric values.
 */
#define ZSOCK_SHUT_RD 0
#define ZSOCK_SHUT_WR 1
#define ZSOCK_SHUT_RDWR 2
#define SOL_TLS 282
 
#define TLS_SEC_TAG_LIST 1
#define TLS_HOSTNAME 2
#define TLS_CIPHERSUITE_LIST 3
#define TLS_CIPHERSUITE_USED 4
#define TLS_PEER_VERIFY 5
#define TLS_DTLS_ROLE 6
#define TLS_ALPN_LIST 7
#define TLS_DTLS_HANDSHAKE_TIMEOUT_MIN 8
 
#define TLS_DTLS_HANDSHAKE_TIMEOUT_MAX 9
 
#define TLS_CERT_NOCOPY        10
#define TLS_NATIVE 11
#define TLS_SESSION_CACHE 12
#define TLS_SESSION_CACHE_PURGE 13
#define TLS_DTLS_CID 14
#define TLS_DTLS_CID_STATUS 15
#define TLS_DTLS_CID_VALUE 16
#define TLS_DTLS_PEER_CID_VALUE 17
#define TLS_DTLS_HANDSHAKE_ON_CONNECT 18
 
/* Valid values for @ref TLS_PEER_VERIFY option */
#define TLS_PEER_VERIFY_NONE 0     
#define TLS_PEER_VERIFY_OPTIONAL 1 
#define TLS_PEER_VERIFY_REQUIRED 2 
/* Valid values for @ref TLS_DTLS_ROLE option */
#define TLS_DTLS_ROLE_CLIENT 0 
#define TLS_DTLS_ROLE_SERVER 1 
/* Valid values for @ref TLS_CERT_NOCOPY option */
#define TLS_CERT_NOCOPY_NONE 0     
#define TLS_CERT_NOCOPY_OPTIONAL 1 
/* Valid values for @ref TLS_SESSION_CACHE option */
#define TLS_SESSION_CACHE_DISABLED 0 
#define TLS_SESSION_CACHE_ENABLED 1 
/* Valid values for @ref TLS_DTLS_CID (Connection ID) option */
#define TLS_DTLS_CID_DISABLED           0 
#define TLS_DTLS_CID_SUPPORTED          1 
#define TLS_DTLS_CID_ENABLED            2 
/* Valid values for @ref TLS_DTLS_CID_STATUS option */
#define TLS_DTLS_CID_STATUS_DISABLED            0 
#define TLS_DTLS_CID_STATUS_DOWNLINK            1 
#define TLS_DTLS_CID_STATUS_UPLINK              2 
#define TLS_DTLS_CID_STATUS_BIDIRECTIONAL       3 
 
struct zsock_addrinfo {
        struct zsock_addrinfo *ai_next; 
        int ai_flags;             
        int ai_family;            
        int ai_socktype;          
        int ai_protocol;          
        int ai_eflags;            
        socklen_t ai_addrlen;     
        struct sockaddr *ai_addr; 
        char *ai_canonname;       
        struct sockaddr _ai_addr;
        char _ai_canonname[DNS_MAX_NAME_SIZE + 1];
};
 
__syscall void *zsock_get_context_object(int sock);
 
__syscall int zsock_socket(int family, int type, int proto);
 
__syscall int zsock_socketpair(int family, int type, int proto, int *sv);
 
__syscall int zsock_close(int sock);
 
__syscall int zsock_shutdown(int sock, int how);
 
__syscall int zsock_bind(int sock, const struct sockaddr *addr,
                         socklen_t addrlen);
 
__syscall int zsock_connect(int sock, const struct sockaddr *addr,
                            socklen_t addrlen);
 
__syscall int zsock_listen(int sock, int backlog);
 
__syscall int zsock_accept(int sock, struct sockaddr *addr, socklen_t *addrlen);
 
__syscall ssize_t zsock_sendto(int sock, const void *buf, size_t len,
                               int flags, const struct sockaddr *dest_addr,
                               socklen_t addrlen);
 
static inline ssize_t zsock_send(int sock, const void *buf, size_t len,
                                 int flags)
{
        return zsock_sendto(sock, buf, len, flags, NULL, 0);
}
 
__syscall ssize_t zsock_sendmsg(int sock, const struct msghdr *msg,
                                int flags);
 
__syscall ssize_t zsock_recvfrom(int sock, void *buf, size_t max_len,
                                 int flags, struct sockaddr *src_addr,
                                 socklen_t *addrlen);
 
__syscall ssize_t zsock_recvmsg(int sock, struct msghdr *msg, int flags);
 
static inline ssize_t zsock_recv(int sock, void *buf, size_t max_len,
                                 int flags)
{
        return zsock_recvfrom(sock, buf, max_len, flags, NULL, NULL);
}
 
__syscall int zsock_fcntl_impl(int sock, int cmd, int flags);
 
/*
 * Need this wrapper because newer GCC versions got too smart and "typecheck"
 * even macros.
 */
static inline int zsock_fcntl_wrapper(int sock, int cmd, ...)
{
        va_list args;
        int flags;
 
        va_start(args, cmd);
        flags = va_arg(args, int);
        va_end(args);
        return zsock_fcntl_impl(sock, cmd, flags);
}
 
#define zsock_fcntl zsock_fcntl_wrapper
 
__syscall int zsock_ioctl_impl(int sock, unsigned long request, va_list ap);
 
static inline int zsock_ioctl_wrapper(int sock, unsigned long request, ...)
{
        int ret;
        va_list args;
 
        va_start(args, request);
        ret = zsock_ioctl_impl(sock, request, args);
        va_end(args);
 
        return ret;
}
 
#define zsock_ioctl zsock_ioctl_wrapper
 
static inline int zsock_poll(struct zsock_pollfd *fds, int nfds, int timeout)
{
        return zvfs_poll(fds, nfds, timeout);
}
 
__syscall int zsock_getsockopt(int sock, int level, int optname,
                               void *optval, socklen_t *optlen);
 
__syscall int zsock_setsockopt(int sock, int level, int optname,
                               const void *optval, socklen_t optlen);
 
__syscall int zsock_getpeername(int sock, struct sockaddr *addr,
                                socklen_t *addrlen);
 
__syscall int zsock_getsockname(int sock, struct sockaddr *addr,
                                socklen_t *addrlen);
 
__syscall int zsock_gethostname(char *buf, size_t len);
 
static inline char *zsock_inet_ntop(sa_family_t family, const void *src,
                                    char *dst, size_t size)
{
        return net_addr_ntop(family, src, dst, size);
}
 
__syscall int zsock_inet_pton(sa_family_t family, const char *src, void *dst);
 
__syscall int z_zsock_getaddrinfo_internal(const char *host,
                                           const char *service,
                                           const struct zsock_addrinfo *hints,
                                           struct zsock_addrinfo *res);
/* Flags for getaddrinfo() hints. */
 
#define AI_PASSIVE 0x1
#define AI_CANONNAME 0x2
#define AI_NUMERICHOST 0x4
#define AI_V4MAPPED 0x8
#define AI_ALL 0x10
#define AI_ADDRCONFIG 0x20
#define AI_NUMERICSERV 0x400
#define AI_EXTFLAGS 0x800
int zsock_getaddrinfo(const char *host, const char *service,
                      const struct zsock_addrinfo *hints,
                      struct zsock_addrinfo **res);
 
void zsock_freeaddrinfo(struct zsock_addrinfo *ai);
 
const char *zsock_gai_strerror(int errcode);
 
#define NI_NUMERICHOST 1
#define NI_NUMERICSERV 2
#define NI_NOFQDN 4
#define NI_NAMEREQD 8
#define NI_DGRAM 16
 
/* POSIX extensions */
 
#ifndef NI_MAXHOST
#define NI_MAXHOST 64
#endif
int zsock_getnameinfo(const struct sockaddr *addr, socklen_t addrlen,
                      char *host, socklen_t hostlen,
                      char *serv, socklen_t servlen, int flags);
 
#if defined(CONFIG_NET_SOCKETS_POSIX_NAMES)
 
#define pollfd zsock_pollfd
 
static inline int socket(int family, int type, int proto)
{
        return zsock_socket(family, type, proto);
}
 
static inline int socketpair(int family, int type, int proto, int sv[2])
{
        return zsock_socketpair(family, type, proto, sv);
}
 
static inline int close(int sock)
{
        return zsock_close(sock);
}
 
static inline int shutdown(int sock, int how)
{
        return zsock_shutdown(sock, how);
}
 
static inline int bind(int sock, const struct sockaddr *addr, socklen_t addrlen)
{
        return zsock_bind(sock, addr, addrlen);
}
 
static inline int connect(int sock, const struct sockaddr *addr,
                          socklen_t addrlen)
{
        return zsock_connect(sock, addr, addrlen);
}
 
static inline int listen(int sock, int backlog)
{
        return zsock_listen(sock, backlog);
}
 
static inline int accept(int sock, struct sockaddr *addr, socklen_t *addrlen)
{
        return zsock_accept(sock, addr, addrlen);
}
 
static inline ssize_t send(int sock, const void *buf, size_t len, int flags)
{
        return zsock_send(sock, buf, len, flags);
}
 
static inline ssize_t recv(int sock, void *buf, size_t max_len, int flags)
{
        return zsock_recv(sock, buf, max_len, flags);
}
 
static inline ssize_t sendto(int sock, const void *buf, size_t len, int flags,
                             const struct sockaddr *dest_addr,
                             socklen_t addrlen)
{
        return zsock_sendto(sock, buf, len, flags, dest_addr, addrlen);
}
 
static inline ssize_t sendmsg(int sock, const struct msghdr *message,
                              int flags)
{
        return zsock_sendmsg(sock, message, flags);
}
 
static inline ssize_t recvfrom(int sock, void *buf, size_t max_len, int flags,
                               struct sockaddr *src_addr, socklen_t *addrlen)
{
        return zsock_recvfrom(sock, buf, max_len, flags, src_addr, addrlen);
}
 
static inline ssize_t recvmsg(int sock, struct msghdr *msg, int flags)
{
        return zsock_recvmsg(sock, msg, flags);
}
 
static inline int poll(struct zsock_pollfd *fds, int nfds, int timeout)
{
        return zsock_poll(fds, nfds, timeout);
}
 
static inline int getsockopt(int sock, int level, int optname,
                             void *optval, socklen_t *optlen)
{
        return zsock_getsockopt(sock, level, optname, optval, optlen);
}
 
static inline int setsockopt(int sock, int level, int optname,
                             const void *optval, socklen_t optlen)
{
        return zsock_setsockopt(sock, level, optname, optval, optlen);
}
 
static inline int getpeername(int sock, struct sockaddr *addr,
                              socklen_t *addrlen)
{
        return zsock_getpeername(sock, addr, addrlen);
}
 
static inline int getsockname(int sock, struct sockaddr *addr,
                              socklen_t *addrlen)
{
        return zsock_getsockname(sock, addr, addrlen);
}
 
static inline int getaddrinfo(const char *host, const char *service,
                              const struct zsock_addrinfo *hints,
                              struct zsock_addrinfo **res)
{
        return zsock_getaddrinfo(host, service, hints, res);
}
 
static inline void freeaddrinfo(struct zsock_addrinfo *ai)
{
        zsock_freeaddrinfo(ai);
}
 
static inline const char *gai_strerror(int errcode)
{
        return zsock_gai_strerror(errcode);
}
 
static inline int getnameinfo(const struct sockaddr *addr, socklen_t addrlen,
                              char *host, socklen_t hostlen,
                              char *serv, socklen_t servlen, int flags)
{
        return zsock_getnameinfo(addr, addrlen, host, hostlen,
                                 serv, servlen, flags);
}
 
#define addrinfo zsock_addrinfo
 
static inline int gethostname(char *buf, size_t len)
{
        return zsock_gethostname(buf, len);
}
 
static inline int inet_pton(sa_family_t family, const char *src, void *dst)
{
        return zsock_inet_pton(family, src, dst);
}
 
static inline char *inet_ntop(sa_family_t family, const void *src, char *dst,
                              size_t size)
{
        return zsock_inet_ntop(family, src, dst, size);
}
 
#define POLLIN ZSOCK_POLLIN
#define POLLOUT ZSOCK_POLLOUT
#define POLLERR ZSOCK_POLLERR
#define POLLHUP ZSOCK_POLLHUP
#define POLLNVAL ZSOCK_POLLNVAL
 
#define MSG_PEEK ZSOCK_MSG_PEEK
#define MSG_CTRUNC ZSOCK_MSG_CTRUNC
#define MSG_TRUNC ZSOCK_MSG_TRUNC
#define MSG_DONTWAIT ZSOCK_MSG_DONTWAIT
#define MSG_WAITALL ZSOCK_MSG_WAITALL
 
#define SHUT_RD ZSOCK_SHUT_RD
#define SHUT_WR ZSOCK_SHUT_WR
#define SHUT_RDWR ZSOCK_SHUT_RDWR
 
#define EAI_BADFLAGS DNS_EAI_BADFLAGS
#define EAI_NONAME DNS_EAI_NONAME
#define EAI_AGAIN DNS_EAI_AGAIN
#define EAI_FAIL DNS_EAI_FAIL
#define EAI_NODATA DNS_EAI_NODATA
#define EAI_MEMORY DNS_EAI_MEMORY
#define EAI_SYSTEM DNS_EAI_SYSTEM
#define EAI_SERVICE DNS_EAI_SERVICE
#define EAI_SOCKTYPE DNS_EAI_SOCKTYPE
#define EAI_FAMILY DNS_EAI_FAMILY
#endif /* defined(CONFIG_NET_SOCKETS_POSIX_NAMES) */
 
#if defined(CONFIG_NET_INTERFACE_NAME)
#define IFNAMSIZ CONFIG_NET_INTERFACE_NAME_LEN
#else
#define IFNAMSIZ Z_DEVICE_MAX_NAME_LEN
#endif
 
struct ifreq {
        char ifr_name[IFNAMSIZ]; 
};
#define SOL_SOCKET 1
 
/* Socket options for SOL_SOCKET level */
 
#define SO_DEBUG 1
#define SO_REUSEADDR 2
#define SO_TYPE 3
#define SO_ERROR 4
#define SO_DONTROUTE 5
#define SO_BROADCAST 6
 
#define SO_SNDBUF 7
#define SO_RCVBUF 8
 
#define SO_KEEPALIVE 9
#define SO_OOBINLINE 10
#define SO_PRIORITY 12
#define SO_LINGER 13
#define SO_REUSEPORT 15
 
#define SO_RCVLOWAT 18
#define SO_SNDLOWAT 19
 
#define SO_RCVTIMEO 20
#define SO_SNDTIMEO 21
 
#define SO_BINDTODEVICE 25
 
#define SO_ACCEPTCONN 30
 
#define SO_TIMESTAMPING 37
 
#define SO_PROTOCOL 38
 
#define SO_DOMAIN 39
 
#define SO_SOCKS5 60
 
#define SO_TXTIME 61
#define SCM_TXTIME SO_TXTIME
 
#define SOF_TIMESTAMPING_RX_HARDWARE BIT(0)
#define SOF_TIMESTAMPING_TX_HARDWARE BIT(1)
 
/* Socket options for IPPROTO_TCP level */
#define TCP_NODELAY 1
#define TCP_KEEPIDLE 2
#define TCP_KEEPINTVL 3
#define TCP_KEEPCNT 4
 
/* Socket options for IPPROTO_IP level */
#define IP_TOS 1
 
#define IP_TTL 2
 
#define IP_PKTINFO 8
 
struct in_pktinfo {
        unsigned int   ipi_ifindex;  
        struct in_addr ipi_spec_dst; 
        struct in_addr ipi_addr;     
};
 
#define IP_MULTICAST_TTL 33
#define IP_ADD_MEMBERSHIP 35
#define IP_DROP_MEMBERSHIP 36
 
struct ip_mreqn {
        struct in_addr imr_multiaddr; 
        struct in_addr imr_address;   
        int            imr_ifindex;   
};
 
/* Socket options for IPPROTO_IPV6 level */
#define IPV6_UNICAST_HOPS       16
 
#define IPV6_MULTICAST_HOPS 18
 
#define IPV6_ADD_MEMBERSHIP 20
 
#define IPV6_DROP_MEMBERSHIP 21
 
struct ipv6_mreq {
        struct in6_addr ipv6mr_multiaddr;
 
        int ipv6mr_ifindex;
};
 
#define IPV6_V6ONLY 26
 
#define IPV6_RECVPKTINFO 49
 
#define IPV6_ADDR_PREFERENCES   72
 
#define IPV6_PREFER_SRC_TMP             0x0001
#define IPV6_PREFER_SRC_PUBLIC          0x0002
#define IPV6_PREFER_SRC_PUBTMP_DEFAULT  0x0100
#define IPV6_PREFER_SRC_COA             0x0004
#define IPV6_PREFER_SRC_HOME            0x0400
#define IPV6_PREFER_SRC_CGA             0x0008
#define IPV6_PREFER_SRC_NONCGA          0x0800
 
struct in6_pktinfo {
        struct in6_addr ipi6_addr;    
        unsigned int    ipi6_ifindex; 
};
 
#define IPV6_TCLASS 67
#define SOMAXCONN 128
struct net_socket_register {
        int family;
        bool is_offloaded;
        bool (*is_supported)(int family, int type, int proto);
        int (*handler)(int family, int type, int proto);
#if defined(CONFIG_NET_SOCKETS_OBJ_CORE)
        /* Store also the name of the socket type in order to be able to
         * print it later.
         */
        const char * const name;
#endif
};
 
#define NET_SOCKET_DEFAULT_PRIO CONFIG_NET_SOCKETS_PRIORITY_DEFAULT
 
#define NET_SOCKET_GET_NAME(socket_name, prio)  \
        __net_socket_register_##prio##_##socket_name
 
#if defined(CONFIG_NET_SOCKETS_OBJ_CORE)
#define K_OBJ_TYPE_SOCK  K_OBJ_TYPE_ID_GEN("SOCK")
 
#define NET_SOCKET_REGISTER_NAME(_name)         \
        .name = STRINGIFY(_name),
#else
#define NET_SOCKET_REGISTER_NAME(_name)
#endif
 
#define _NET_SOCKET_REGISTER(socket_name, prio, _family, _is_supported, _handler, _is_offloaded) \
        static const STRUCT_SECTION_ITERABLE(net_socket_register,       \
                        NET_SOCKET_GET_NAME(socket_name, prio)) = {     \
                .family = _family,                                      \
                .is_offloaded = _is_offloaded,                          \
                .is_supported = _is_supported,                          \
                .handler = _handler,                                    \
                NET_SOCKET_REGISTER_NAME(socket_name)                   \
        }
 
#define NET_SOCKET_REGISTER(socket_name, prio, _family, _is_supported, _handler) \
        _NET_SOCKET_REGISTER(socket_name, prio, _family, _is_supported, _handler, false)
 
#define NET_SOCKET_OFFLOAD_REGISTER(socket_name, prio, _family, _is_supported, _handler) \
        _NET_SOCKET_REGISTER(socket_name, prio, _family, _is_supported, _handler, true)
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/socket.h>
 
/* Avoid circular loops with POSIX socket headers.
 * We have these includes here so that we do not need
 * to change the applications that were only including
 * zephyr/net/socket.h header file.
 *
 * Additionally, if non-zephyr-prefixed headers are used here,
 * native_sim pulls in those from the host rather than Zephyr's.
 *
 * This should be removed when CONFIG_NET_SOCKETS_POSIX_NAMES is removed.
 */
#if defined(CONFIG_POSIX_API)
#if !defined(ZEPHYR_INCLUDE_POSIX_ARPA_INET_H_)
#include <zephyr/posix/arpa/inet.h>
#endif
#if !defined(ZEPHYR_INCLUDE_POSIX_NETDB_H_)
#include <zephyr/posix/netdb.h>
#endif
#if !defined(ZEPHYR_INCLUDE_POSIX_UNISTD_H_)
#include <zephyr/posix/unistd.h>
#endif
#if !defined(ZEPHYR_INCLUDE_POSIX_POLL_H_)
#include <zephyr/posix/poll.h>
#endif
#if !defined(ZEPHYR_INCLUDE_POSIX_SYS_SOCKET_H_)
#include <zephyr/posix/sys/socket.h>
#endif
#endif /* CONFIG_POSIX_API */
 
#endif /* ZEPHYR_INCLUDE_NET_SOCKET_H_ */