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/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
 
/* Make sure that we can compile things even if CONFIG_DNS_RESOLVER
 * is not enabled.
 */
#if !defined(CONFIG_DNS_RESOLVER_MAX_SERVERS)
#define CONFIG_DNS_RESOLVER_MAX_SERVERS 1
#endif
#if !defined(CONFIG_DNS_NUM_CONCUR_QUERIES)
#define CONFIG_DNS_NUM_CONCUR_QUERIES 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)
 
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 {
 struct sockaddr dns_server;
 
 int sock;
 
 uint8_t is_mdns : 1;
 
 uint8_t is_llmnr : 1;
 } servers[CONFIG_DNS_RESOLVER_MAX_SERVERS + DNS_MAX_MCAST_SERVERS];
 
#if (IS_ENABLED(CONFIG_NET_IPV6) && IS_ENABLED(CONFIG_NET_IPV4))
#define DNS_RESOLVER_MAX_POLL (2 * (CONFIG_DNS_RESOLVER_MAX_SERVERS + DNS_MAX_MCAST_SERVERS))
#else
#define DNS_RESOLVER_MAX_POLL (1 * (CONFIG_DNS_RESOLVER_MAX_SERVERS + DNS_MAX_MCAST_SERVERS))
#endif
 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[CONFIG_DNS_NUM_CONCUR_QUERIES];
 
 enum dns_resolve_context_state state;
};
 
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_ */