dns_resolve.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017 Intel Corporation
 * Copyright 2025 NXP
 *
 * 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>
#include <zephyr/sys/atomic.h>
 
#ifdef __cplusplus
extern "C" {
#endif


enum dns_query_type {
        DNS_QUERY_TYPE_A = 1,
        DNS_QUERY_TYPE_CNAME = 5,
        DNS_QUERY_TYPE_PTR = 12,
        DNS_QUERY_TYPE_TXT = 16,
        DNS_QUERY_TYPE_AAAA = 28,
        DNS_QUERY_TYPE_SRV = 33,
        DNS_QUERY_TYPE_ANY = 255,
        DNS_QUERY_TYPE_RESERVED = 65535,
};
 

#define DNS_RR_TYPE_PRIVATE_START_VALUE 65280
#define DNS_RR_TYPE_PRIVATE_END_VALUE 65534

static inline bool dns_query_type_is_private(enum dns_query_type type)
{
        unsigned int val = (unsigned int)type;
 
        return (val >= DNS_RR_TYPE_PRIVATE_START_VALUE &&
                val <= DNS_RR_TYPE_PRIVATE_END_VALUE);
}

enum dns_server_source {
        DNS_SOURCE_UNKNOWN = 0,
        DNS_SOURCE_MANUAL,
        DNS_SOURCE_DHCPV4,
        DNS_SOURCE_DHCPV6,
        DNS_SOURCE_IPV6_RA,
        DNS_SOURCE_PPP,
};

#if defined(CONFIG_DNS_RESOLVER_MAX_NAME_LEN)
#define DNS_MAX_NAME_SIZE CONFIG_DNS_RESOLVER_MAX_NAME_LEN
#else
#define DNS_MAX_NAME_SIZE 20
#endif /* CONFIG_DNS_RESOLVER_MAX_NAME_LEN */

#if defined(CONFIG_DNS_RESOLVER_MAX_TEXT_LEN)
#define DNS_MAX_TEXT_SIZE CONFIG_DNS_RESOLVER_MAX_TEXT_LEN
#else
#define DNS_MAX_TEXT_SIZE 64
#endif /* CONFIG_DNS_RESOLVER_MAX_TEXT_LEN */

#if defined(CONFIG_DNS_RESOLVER_MAX_PRIVATE_DATA_LEN)
#define DNS_MAX_PRIVATE_DATA_SIZE CONFIG_DNS_RESOLVER_MAX_PRIVATE_DATA_LEN
#else
#define DNS_MAX_PRIVATE_DATA_SIZE 128
#endif /* CONFIG_DNS_RESOLVER_MAX_PRIVATE_DATA_LEN */

 
#define DNS_BUF_TIMEOUT K_MSEC(500) /* ms */
 
/* This value is recommended by RFC 1035 */
#if defined(CONFIG_DNS_RESOLVER_MAX_ANSWER_SIZE)
#define DNS_RESOLVER_MAX_BUF_SIZE CONFIG_DNS_RESOLVER_MAX_ANSWER_SIZE
#else
#define DNS_RESOLVER_MAX_BUF_SIZE 512
#endif /* CONFIG_DNS_RESOLVER_MAX_ANSWER_SIZE */
 
/* 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)
 
/* Cap the max poll to 32 */
BUILD_ASSERT(DNS_RESOLVER_MAX_POLL <= 32,
             "DNS_RESOLVER_MAX_POLL " STRINGIFY(DNS_RESOLVER_MAX_POLL)
             " must be smaller or equal than " STRINGIFY(32));

#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 net_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;
        union {
                struct net_sockaddr_storage local_addr_storage;
                /* Use the local_addr_storage instead of this one. */
                struct net_sockaddr local_addr;
        };
        dns_socket_dispatcher_cb cb;
        struct zsock_pollfd *fds;
        int fds_len;
        int sock;
        int ifindex;
        struct dns_socket_dispatcher *pair;
        bool paired;
        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);


enum dns_resolve_extension {
        DNS_RESOLVE_NONE = 0, 
        DNS_RESOLVE_TXT,      
        DNS_RESOLVE_SRV,      
        DNS_RESOLVE_PRIVATE,  
};

struct dns_resolve_txt {
        size_t textlen;
        char   text[DNS_MAX_TEXT_SIZE + 1];
};

struct dns_resolve_srv {
        uint16_t priority;
        uint16_t weight;
        uint16_t port;
        size_t   targetlen;
        char     target[DNS_MAX_NAME_SIZE + 1];
};

struct dns_resolve_private {
        uint16_t type;
        size_t datalen;
        uint8_t data[DNS_MAX_PRIVATE_DATA_SIZE];
};

struct dns_addrinfo {
        uint8_t ai_family;
 
        union {
                struct {
                        net_socklen_t ai_addrlen;

                        union {
                                struct net_sockaddr_storage ai_addr_storage;
                                struct net_sockaddr ai_addr;
                        };

                        char ai_canonname[DNS_MAX_NAME_SIZE + 1];
                };

                struct {
                        enum dns_resolve_extension ai_extension;
 
                        union {
                                struct dns_resolve_txt ai_txt;
                                struct dns_resolve_srv ai_srv;
#if defined(CONFIG_DNS_RESOLVER_PRIVATE_RR_SUPPORT) || defined(__DOXYGEN__)
                                struct dns_resolve_private ai_private;
#endif /* CONFIG_DNS_RESOLVER_PRIVATE_RR_SUPPORT */
                        };
                };
        };
};

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

typedef void (*dns_resolve_pkt_fw_cb_t)(struct net_buf *dns_data, size_t buf_len, void *user_data);

 
enum dns_resolve_context_state {
        DNS_RESOLVE_CONTEXT_UNINITIALIZED = 0,
        DNS_RESOLVE_CONTEXT_ACTIVE,
        DNS_RESOLVE_CONTEXT_DEACTIVATING,
        DNS_RESOLVE_CONTEXT_INACTIVE,
};


struct dns_resolve_context {
        struct dns_server_info {
                union {
                        struct net_sockaddr_storage dns_server_addr;
                        struct net_sockaddr dns_server;
                };

                int sock;

                int if_index;

                enum dns_server_source source;

                uint8_t is_mdns : 1;

                uint8_t is_llmnr : 1;

                struct dns_socket_dispatcher dispatcher;

                bool in_dispatch;
        } 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;

                const char *query;

                enum dns_query_type query_type;

                uint16_t id;

                uint16_t query_hash;

                uint16_t orig_query_hash;
 
                /* Number of additional queries sent to resolve CNAME record
                 * name aliases.
                 */
                uint8_t additional_queries;

                bool cb_called;

                k_timepoint_t deadline;

                struct {
                        atomic_t sent;

                        atomic_t pending;

                        atomic_t failed;
                } servers;

                enum dns_resolve_status last_status;
        } queries[DNS_NUM_CONCUR_QUERIES];

        enum dns_resolve_context_state state;
 
#if defined(CONFIG_DNS_RESOLVER_PACKET_FORWARDING) || defined(__DOXYGEN__)
        dns_resolve_pkt_fw_cb_t pkt_fw_cb;
#endif /* CONFIG_DNS_RESOLVER_PACKET_FORWARDING */

        int init_called;
};

 
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 net_sockaddr_storage 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 net_sockaddr *dns_servers_sa[]);

int dns_resolve_init_default(struct dns_resolve_context *ctx);

int dns_resolve_close(struct dns_resolve_context *ctx);

bool dns_resolve_is_active(struct dns_resolve_context *ctx);

int dns_resolve_reconfigure(struct dns_resolve_context *ctx,
                            const char *servers_str[],
                            const struct net_sockaddr *servers_sa[],
                            enum dns_server_source source);

int dns_resolve_reconfigure_with_interfaces(struct dns_resolve_context *ctx,
                                            const char *servers_str[],
                                            const struct net_sockaddr *servers_sa[],
                                            int interfaces[],
                                            enum dns_server_source source);

int dns_resolve_remove(struct dns_resolve_context *ctx, int if_index);

int dns_resolve_remove_source(struct dns_resolve_context *ctx, int if_index,
                              enum dns_server_source source);

int dns_resolve_remove_server_addresses(struct dns_resolve_context *ctx,
                                        const struct net_sockaddr *servers_sa[],
                                        int interfaces[]);

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

static inline int dns_resolve_service(struct dns_resolve_context *ctx,
                                      const char *query,
                                      uint16_t *dns_id,
                                      dns_resolve_cb_t cb,
                                      void *user_data,
                                      int32_t timeout)
{
        return dns_resolve_name(ctx, query, DNS_QUERY_TYPE_PTR,
                                dns_id, cb, user_data, timeout);
}

struct dns_resolve_context *dns_resolve_get_default(void);
 
#if defined(CONFIG_DNS_RESOLVER_PACKET_FORWARDING) || defined(__DOXYGEN__)
static inline void dns_resolve_enable_packet_forwarding(struct dns_resolve_context *ctx,
                                                        dns_resolve_pkt_fw_cb_t cb)
{
        ctx->pkt_fw_cb = cb;
}
#endif /* CONFIG_DNS_RESOLVER_PACKET_FORWARDING */

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

static inline int dns_cancel_addr_info_with_name(const char *query_name,
                                        enum dns_query_type query_type,
                                        uint16_t dns_id)
{
        return dns_resolve_cancel_with_name(dns_resolve_get_default(),
                                dns_id,
                                query_name,
                                query_type);
}



const char *dns_get_source_str(enum dns_server_source source);

#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_ */