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 <sys/types.h>
#include <zephyr/types.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/dns_resolve.h>
#include <zephyr/net/socket_select.h>
#include <stdlib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct zsock_pollfd {
        int fd;
        short events;
        short revents;
};
 
/* 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_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
 
/* Valid values for 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 TLS_DTLS_ROLE option */
#define TLS_DTLS_ROLE_CLIENT 0 
#define TLS_DTLS_ROLE_SERVER 1 
/* Valid values for TLS_CERT_NOCOPY option */
#define TLS_CERT_NOCOPY_NONE 0     
#define TLS_CERT_NOCOPY_OPTIONAL 1 
/* Valid values for TLS_SESSION_CACHE option */
#define TLS_SESSION_CACHE_DISABLED 0 
#define TLS_SESSION_CACHE_ENABLED 1 
struct zsock_addrinfo {
        struct zsock_addrinfo *ai_next;
        int ai_flags;
        int ai_family;
        int ai_socktype;
        int ai_protocol;
        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);
 
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(int sock, int cmd, int flags);
 
__syscall int zsock_poll(struct zsock_pollfd *fds, int nfds, int 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
 
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);
}
 
/*
 * Need this wrapper because newer GCC versions got too smart and "typecheck"
 * even macros, so '#define fcntl zsock_fcntl' leads to error.
 */
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(sock, cmd, flags);
}
 
#define fcntl zsock_fcntl_wrapper
 
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 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_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) */
 
#define IFNAMSIZ Z_DEVICE_MAX_NAME_LEN
 
struct ifreq {
        char ifr_name[IFNAMSIZ]; /* Interface name */
};
 
#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_REUSEPORT 15
 
#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
 
/* Socket options for IPPROTO_TCP level */
#define TCP_NODELAY 1
 
/* Socket options for IPPROTO_IPV6 level */
#define IPV6_V6ONLY 26
 
#define SO_PRIORITY 12
 
#define SO_TXTIME 61
#define SCM_TXTIME SO_TXTIME
 
/* Socket options for SOCKS5 proxy */
#define SO_SOCKS5 60
 
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);
};
 
#define NET_SOCKET_DEFAULT_PRIO CONFIG_NET_SOCKETS_PRIORITY_DEFAULT
 
#define NET_SOCKET_GET_NAME(socket_name, prio)  \
        __net_socket_register_##prio##_##socket_name
 
#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,                                    \
        }
 
#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 <syscalls/socket.h>
 
#endif /* ZEPHYR_INCLUDE_NET_SOCKET_H_ */