dns_resolve.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_DNS_RESOLVE_H_
#define ZEPHYR_INCLUDE_NET_DNS_RESOLVE_H_
 
#include <zephyr/kernel.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/socket_poll.h>
#include <zephyr/net/net_core.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum dns_query_type {
        DNS_QUERY_TYPE_A = 1,
        DNS_QUERY_TYPE_AAAA = 28
};
 
#ifndef DNS_MAX_NAME_SIZE
#define DNS_MAX_NAME_SIZE 20
#endif
 
#define DNS_BUF_TIMEOUT K_MSEC(500) /* ms */
 
/* This value is recommended by RFC 1035 */
#define DNS_RESOLVER_MAX_BUF_SIZE       512
 
/* Make sure that we can compile things even if CONFIG_DNS_RESOLVER
 * is not enabled.
 */
#if defined(CONFIG_DNS_RESOLVER_MAX_SERVERS)
#define DNS_RESOLVER_MAX_SERVERS CONFIG_DNS_RESOLVER_MAX_SERVERS
#else
#define DNS_RESOLVER_MAX_SERVERS 0
#endif
 
#if defined(CONFIG_DNS_NUM_CONCUR_QUERIES)
#define DNS_NUM_CONCUR_QUERIES CONFIG_DNS_NUM_CONCUR_QUERIES
#else
#define DNS_NUM_CONCUR_QUERIES 1
#endif
 
#if defined(CONFIG_NET_IF_MAX_IPV6_COUNT)
#define MAX_IPV6_IFACE_COUNT CONFIG_NET_IF_MAX_IPV6_COUNT
#else
#define MAX_IPV6_IFACE_COUNT 1
#endif
 
#if defined(CONFIG_NET_IF_MAX_IPV4_COUNT)
#define MAX_IPV4_IFACE_COUNT CONFIG_NET_IF_MAX_IPV4_COUNT
#else
#define MAX_IPV4_IFACE_COUNT 1
#endif
 
/* If mDNS is enabled, then add some extra well known multicast servers to the
 * server list.
 */
#if defined(CONFIG_MDNS_RESOLVER)
#if defined(CONFIG_NET_IPV6) && defined(CONFIG_NET_IPV4)
#define MDNS_SERVER_COUNT 2
#else
#define MDNS_SERVER_COUNT 1
#endif /* CONFIG_NET_IPV6 && CONFIG_NET_IPV4 */
#else
#define MDNS_SERVER_COUNT 0
#endif /* CONFIG_MDNS_RESOLVER */
 
/* If LLMNR is enabled, then add some extra well known multicast servers to the
 * server list.
 */
#if defined(CONFIG_LLMNR_RESOLVER)
#if defined(CONFIG_NET_IPV6) && defined(CONFIG_NET_IPV4)
#define LLMNR_SERVER_COUNT 2
#else
#define LLMNR_SERVER_COUNT 1
#endif /* CONFIG_NET_IPV6 && CONFIG_NET_IPV4 */
#else
#define LLMNR_SERVER_COUNT 0
#endif /* CONFIG_MDNS_RESOLVER */
 
#define DNS_MAX_MCAST_SERVERS (MDNS_SERVER_COUNT + LLMNR_SERVER_COUNT)
 
#if defined(CONFIG_MDNS_RESPONDER)
#if defined(CONFIG_NET_IPV6)
#define MDNS_MAX_IPV6_IFACE_COUNT CONFIG_NET_IF_MAX_IPV6_COUNT
#else
#define MDNS_MAX_IPV6_IFACE_COUNT 0
#endif /* CONFIG_NET_IPV6 */
 
#if defined(CONFIG_NET_IPV4)
#define MDNS_MAX_IPV4_IFACE_COUNT CONFIG_NET_IF_MAX_IPV4_COUNT
#else
#define MDNS_MAX_IPV4_IFACE_COUNT 0
#endif /* CONFIG_NET_IPV4 */
 
#define MDNS_MAX_POLL (MDNS_MAX_IPV4_IFACE_COUNT + MDNS_MAX_IPV6_IFACE_COUNT)
#else
#define MDNS_MAX_POLL 0
#endif /* CONFIG_MDNS_RESPONDER */
 
#if defined(CONFIG_LLMNR_RESPONDER)
#if defined(CONFIG_NET_IPV6) && defined(CONFIG_NET_IPV4)
#define LLMNR_MAX_POLL 2
#else
#define LLMNR_MAX_POLL 1
#endif
#else
#define LLMNR_MAX_POLL 0
#endif /* CONFIG_LLMNR_RESPONDER */
 
#define DNS_RESOLVER_MAX_POLL (DNS_RESOLVER_MAX_SERVERS + DNS_MAX_MCAST_SERVERS)
 
#define DNS_DISPATCHER_MAX_POLL (DNS_RESOLVER_MAX_POLL + MDNS_MAX_POLL + LLMNR_MAX_POLL)
 
#if defined(CONFIG_ZVFS_POLL_MAX)
BUILD_ASSERT(CONFIG_ZVFS_POLL_MAX >= DNS_DISPATCHER_MAX_POLL,
             "CONFIG_ZVFS_POLL_MAX must be larger than " STRINGIFY(DNS_DISPATCHER_MAX_POLL));
#endif
 
enum dns_socket_type {
        DNS_SOCKET_RESOLVER = 1,  
        DNS_SOCKET_RESPONDER = 2  
};
 
struct dns_resolve_context;
struct mdns_responder_context;
struct dns_socket_dispatcher;
 
typedef int (*dns_socket_dispatcher_cb)(struct dns_socket_dispatcher *ctx, int sock,
                                        struct sockaddr *addr, size_t addrlen,
                                        struct net_buf *buf, size_t data_len);
 
struct dns_socket_dispatcher {
        sys_snode_t node;
        const struct net_socket_service_desc *svc;
        union {
                void *ctx;
                struct dns_resolve_context *resolve_ctx;
                struct mdns_responder_context *mdns_ctx;
        };
 
        enum dns_socket_type type;
        struct sockaddr local_addr;
        dns_socket_dispatcher_cb cb;
        struct zsock_pollfd *fds;
        int fds_len;
        int sock;
        int ifindex;
        struct dns_socket_dispatcher *pair;
        struct k_mutex lock;
        k_timeout_t buf_timeout;
};
 
int dns_dispatcher_register(struct dns_socket_dispatcher *ctx);
 
int dns_dispatcher_unregister(struct dns_socket_dispatcher *ctx);
 
struct dns_addrinfo {
        struct sockaddr ai_addr;
        socklen_t       ai_addrlen;
        uint8_t         ai_family;
        char            ai_canonname[DNS_MAX_NAME_SIZE + 1];
};
 
enum dns_resolve_status {
        DNS_EAI_BADFLAGS    = -1,
        DNS_EAI_NONAME      = -2,
        DNS_EAI_AGAIN       = -3,
        DNS_EAI_FAIL        = -4,
        DNS_EAI_NODATA      = -5,
        DNS_EAI_FAMILY      = -6,
        DNS_EAI_SOCKTYPE    = -7,
        DNS_EAI_SERVICE     = -8,
        DNS_EAI_ADDRFAMILY  = -9,
        DNS_EAI_MEMORY      = -10,
        DNS_EAI_SYSTEM      = -11,
        DNS_EAI_OVERFLOW    = -12,
        DNS_EAI_INPROGRESS  = -100,
        DNS_EAI_CANCELED    = -101,
        DNS_EAI_NOTCANCELED = -102,
        DNS_EAI_ALLDONE     = -103,
        DNS_EAI_IDN_ENCODE  = -105,
};
 
typedef void (*dns_resolve_cb_t)(enum dns_resolve_status status,
                                 struct dns_addrinfo *info,
                                 void *user_data);
 
enum dns_resolve_context_state {
        DNS_RESOLVE_CONTEXT_ACTIVE,
        DNS_RESOLVE_CONTEXT_DEACTIVATING,
        DNS_RESOLVE_CONTEXT_INACTIVE,
};
 
struct dns_resolve_context {
        struct dns_server {
                struct sockaddr dns_server;
 
                int sock;
 
                int if_index;
 
                uint8_t is_mdns : 1;
 
                uint8_t is_llmnr : 1;
 
                struct dns_socket_dispatcher dispatcher;
        } servers[DNS_RESOLVER_MAX_POLL];
 
        struct zsock_pollfd fds[DNS_RESOLVER_MAX_POLL];
        struct k_mutex lock;
 
        k_timeout_t buf_timeout;
 
        struct dns_pending_query {
                struct k_work_delayable timer;
 
                struct dns_resolve_context *ctx;
 
                dns_resolve_cb_t cb;
 
                void *user_data;
 
                k_timeout_t timeout;
 
                const char *query;
 
                enum dns_query_type query_type;
 
                uint16_t id;
 
                uint16_t query_hash;
        } queries[DNS_NUM_CONCUR_QUERIES];
 
        enum dns_resolve_context_state state;
};
 
struct mdns_probe_user_data {
        struct mdns_responder_context *ctx;
        char query[DNS_MAX_NAME_SIZE + 1];
        uint16_t dns_id;
};
 
struct mdns_responder_context {
        struct sockaddr server_addr;
        struct dns_socket_dispatcher dispatcher;
        struct zsock_pollfd fds[1];
        int sock;
        struct net_if *iface;
#if defined(CONFIG_MDNS_RESPONDER_PROBE)
        struct k_work_delayable probe_timer;
        struct dns_resolve_context probe_ctx;
        struct mdns_probe_user_data probe_data;
#endif
};
 
int dns_resolve_init(struct dns_resolve_context *ctx,
                     const char *dns_servers_str[],
                     const struct sockaddr *dns_servers_sa[]);
 
int dns_resolve_init_default(struct dns_resolve_context *ctx);
 
int dns_resolve_close(struct dns_resolve_context *ctx);
 
int dns_resolve_reconfigure(struct dns_resolve_context *ctx,
                            const char *servers_str[],
                            const struct sockaddr *servers_sa[]);
 
int dns_resolve_cancel(struct dns_resolve_context *ctx,
                       uint16_t dns_id);
 
int dns_resolve_cancel_with_name(struct dns_resolve_context *ctx,
                                 uint16_t dns_id,
                                 const char *query_name,
                                 enum dns_query_type query_type);
 
int dns_resolve_name(struct dns_resolve_context *ctx,
                     const char *query,
                     enum dns_query_type type,
                     uint16_t *dns_id,
                     dns_resolve_cb_t cb,
                     void *user_data,
                     int32_t timeout);
 
struct dns_resolve_context *dns_resolve_get_default(void);
 
static inline int dns_get_addr_info(const char *query,
                                    enum dns_query_type type,
                                    uint16_t *dns_id,
                                    dns_resolve_cb_t cb,
                                    void *user_data,
                                    int32_t timeout)
{
        return dns_resolve_name(dns_resolve_get_default(),
                                query,
                                type,
                                dns_id,
                                cb,
                                user_data,
                                timeout);
}
 
static inline int dns_cancel_addr_info(uint16_t dns_id)
{
        return dns_resolve_cancel(dns_resolve_get_default(), dns_id);
}
 
#if defined(CONFIG_DNS_RESOLVER_AUTO_INIT)
void dns_init_resolver(void);
 
#else
#define dns_init_resolver(...)
#endif /* CONFIG_DNS_RESOLVER_AUTO_INIT */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_DNS_RESOLVE_H_ */