patrick/zephyr
1
0
Fork 0
Code Issues Pull requests Actions 8 Packages Projects Releases Wiki Activity

net: dns: dns-sd: support dns service discovery

Browse source 
This change adds support for DNS Service Discovery (DNS-SD)
as described in RFC 6763.

Fixes #29099

Signed-off-by: Christopher Friedt <chrisfriedt@gmail.com>
This commit is contained in:
Christopher Friedt 2020-10-29 14:56:30 -04:00 committed by Andrew Boie
parent 5c691491a7
commit e7e58439e7
8 changed files with 1436 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CODEOWNERS
View file

@ -532,7 +532,7 @@
/subsys/net/buf.c @jukkar @jhedberg @tbursztyka @pfalcon
/subsys/net/ip/ @jukkar @tbursztyka @pfalcon
/subsys/net/lib/ @jukkar @tbursztyka @pfalcon
/subsys/net/lib/dns/ @jukkar @tbursztyka @pfalcon
/subsys/net/lib/dns/ @jukkar @tbursztyka @pfalcon @cfriedt
/subsys/net/lib/lwm2m/ @rlubos
/subsys/net/lib/config/ @jukkar @tbursztyka @pfalcon
/subsys/net/lib/mqtt/ @jukkar @tbursztyka @rlubos

4
include/linker/common-rom.ld
View file

@ -134,6 +134,10 @@
} GROUP_LINK_IN(ROMABLE_REGION)
#endif /* CONFIG_EMUL */
#if defined(CONFIG_DNS_SD)
Z_ITERABLE_SECTION_ROM(dns_sd_rec, 4)
#endif
SECTION_DATA_PROLOGUE(log_const_sections,,)
{
__log_const_start = .;

234
include/net/dns_sd.h Normal file
View file

@ -0,0 +1,234 @@
/** @file
* @brief DNS Service Discovery
*/
/*
* Copyright (c) 2020 Friedt Professional Engineering Services, Inc
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ZEPHYR_INCLUDE_NET_DNS_SD_H_
#define ZEPHYR_INCLUDE_NET_DNS_SD_H_
#include <stdint.h>
#include <sys/byteorder.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief DNS Service Discovery
*
* @details This API enables services to be advertised via DNS. To
* advvertise a service, system or application code should use
* @ref DNS_SD_REGISTER_TCP_SERVICE or
* @ref DNS_SD_REGISTER_UDP_SERVICE.
*
* @see <a href="https://tools.ietf.org/html/rfc6763">RFC 6763</a>
*
* @defgroup dns_sd DNS Service Discovery
* @ingroup networking
* @{
*/
/** RFC 1034 Section 3.1 */
#define DNS_SD_INSTANCE_MIN_SIZE 1
/** RFC 1034 Section 3.1, RFC 6763 Section 7.2 */
#define DNS_SD_INSTANCE_MAX_SIZE 63
/** RFC 6763 Section 7.2 - inclusive of underscore */
#define DNS_SD_SERVICE_MIN_SIZE 2
/** RFC 6763 Section 7.2 - inclusive of underscore */
#define DNS_SD_SERVICE_MAX_SIZE 16
/** RFC 6763 Section 4.1.2 */
#define DNS_SD_SERVICE_PREFIX '_'
/** RFC 6763 Section 4.1.2 - either _tcp or _udp (case insensitive) */
#define DNS_SD_PROTO_SIZE 4
/** ICANN Rules for TLD naming */
#define DNS_SD_DOMAIN_MIN_SIZE 2
/** RFC 1034 Section 3.1, RFC 6763 Section 7.2 */
#define DNS_SD_DOMAIN_MAX_SIZE 63
/**
* @brief Register a service for DNS Service Discovery
*
* This macro should be used for advanced use cases. Two simple use cases are
* when a custom @p domain or a custom (non-standard) @p proto is required.
*
* Another use case is when the port number is not preassigned. That could
* be for a number of reasons, but the most common use case would be for
* ephemeral port usage - i.e. when the service is bound using port number 0.
* In that case, Zephyr (like other OS's) will simply choose an unused port.
* When using ephemeral ports, it can be helpful to assign @p port to the
* @ref sockaddr_in.sin_port field of an IPv4 @ref sockaddr_in, or to the
* @ref sockaddr_in6.sin6_port field of an IPv6 @ref sockaddr_in6.
*
* The service can be referenced using the @p id variable.
*
* @param id variable name for the DNS-SD service record
* @param instance name of the service instance such as "My HTTP Server"
* @param service name of the service, such as "_http"
* @param proto protocol used by the service - either "_tcp" or "_udp"
* @param domain the domain of the service, such as "local"
* @param text information for the DNS TXT record
* @param port a pointer to the port number that this service will use
*/
#define DNS_SD_REGISTER_SERVICE(id, instance, service, proto, domain, \
text, port) \
static const Z_STRUCT_SECTION_ITERABLE(dns_sd_rec, id) = { \
instance, \
service, \
proto, \
domain, \
(const char *)text, \
sizeof(text) - 1, \
port \
}
/**
* @brief Register a TCP service for DNS Service Discovery
*
* This macro can be used for service advertisement using DNS-SD.
*
* The service can be referenced using the @p id variable.
*
* Example (with TXT):
* @code{c}
* #include <net/dns_sd.h>
* static const bar_txt[] = {
* "\x06" "path=/"
* "\x0f" "this=is the way"
* "\x0e" "foo or=foo not"
* "\x17" "this=has\0embedded\0nulls"
* "\x04" "true"
* };
* // Possibly use an ephemeral port
* // Possibly only assign bar_port when the service is running
* static uint16_t bar_port;
* DNS_SD_REGISTER_TCP_SERVICE(bar, CONFIG_NET_HOSTNAME,
* "_bar", "local", bar_txt, &bar_port);
* @endcode{c}
*
* TXT records begin with a single length byte (hex-encoded)
* and contain key=value pairs. Thus, the length of the key-value pair
* must not exceed 255 bytes. Care must be taken to ensure that the
* encoded length value is correct.
*
* For additional rules on TXT encoding, see RFC 6763, Section 6.
* @param id variable name for the DNS-SD service record
* @param instance name of the service instance such as "My HTTP Server"
* @param service name of the service, such as "_http"
* @param domain the domain of the service, such as "local"
* @param text information for the DNS TXT record
* @param port the port number that this service will use
*
* @see <a href="https://tools.ietf.org/html/rfc6763">RFC 6763</a>
*/
#define DNS_SD_REGISTER_TCP_SERVICE(id, instance, service, domain, text, \
port) \
static const uint16_t id ## _port = sys_cpu_to_be16(port); \
DNS_SD_REGISTER_SERVICE(id, instance, service, "_tcp", domain, \
text, &id ## _port)
/**
* @brief Register a UDP service for DNS Service Discovery
*
* This macro can be used for service advertisement using DNS-SD.
*
* The service can be referenced using the @p id variable.
*
* Example (no TXT):
* @code{c}
* #include <net/dns_sd.h>
* #include <sys/byteorder.h>
* static const foo_port = sys_cpu_to_be16(4242);
* DNS_SD_REGISTER_UDP_SERVICE(foo, CONFIG_NET_HOSTNAME,
* "_foo", DNS_SD_EMPTY_TXT, &foo_port);
* @endcode{c}
*
* @param id variable name for the DNS-SD service record
* @param instance name of the service instance such as "My TFTP Server"
* @param service name of the service, such as "_tftp"
* @param domain the domain of the service, such as "local" or "zephyrproject.org"
* @param text information for the DNS TXT record
* @param port a pointer to the port number that this service will use
*
* @see <a href="https://tools.ietf.org/html/rfc6763">RFC 6763</a>
*/
#define DNS_SD_REGISTER_UDP_SERVICE(id, instance, service, domain, text, \
port) \
static const uint16_t id ## _port = sys_cpu_to_be16(port); \
DNS_SD_REGISTER_SERVICE(id, instance, service, "_udp", domain, \
text, &id ## _port)
/** Empty DNS-SD TXT specifier */
#define DNS_SD_EMPTY_TXT dns_sd_empty_txt
/** @cond INTERNAL_HIDDEN */
/**
* @brief DNS Service Discovery record
*
* This structure used in the implementation of RFC 6763 and should not
* need to be accessed directly from application code.
*
* The @a port pointer must be non-NULL. When the value in @a port
* is non-zero, the service is advertized as being on that particular
* port. When the value in @a port is zero, then the service is not
* advertised.
*
* Thus, it is possible for multiple services to advertise on a
* particular port if they hard-code the port.
*
* @internal
*
* @see <a href="https://tools.ietf.org/html/rfc6763">RFC 6763</a>
*/
struct dns_sd_rec {
/** <Instance> - e.g. "My HTTP Server" */
const char *instance;
/** Top half of the <Service> such as "_http" */
const char *service;
/** Bottom half of the <Service> "_tcp" or "_udp" */
const char *proto;
/** <Domain> such as "local" or "zephyrproject.org" */
const char *domain;
/** DNS TXT record */
const char *text;
/** Size (in bytes) of the DNS TXT record */
size_t text_size;
/** A pointer to the port number used by the service */
const uint16_t *port;
};
/**
* @brief Empty TXT specifier for DNS-SD
*
* @internal
*/
extern const char dns_sd_empty_txt[1];
/** @endcond */
/**
* @brief Obtain the size of DNS-SD TXT data
*
* @param rec the record to in question
* @return the size of the text field
*/
static inline size_t dns_sd_txt_size(const struct dns_sd_rec *rec)
{
return rec->text_size;
}
/**
* @}
*/
#ifdef __cplusplus
};
#endif
#endif /* ZEPHYR_INCLUDE_NET_DNS_SD_H_ */

1
subsys/net/lib/dns/CMakeLists.txt
View file

@ -6,6 +6,7 @@ zephyr_library()
zephyr_library_sources(dns_pack.c)
zephyr_library_sources_ifdef(CONFIG_DNS_RESOLVER resolve.c)
zephyr_library_sources_ifdef(CONFIG_DNS_SD dns_sd.c)
if(CONFIG_MDNS_RESPONDER)
zephyr_library_sources(mdns_responder.c)

18
subsys/net/lib/dns/Kconfig
View file

@ -198,3 +198,21 @@ config LLMNR_RESOLVER_ADDITIONAL_BUF_CTR
Number of additional buffers available for the LLMNR responder.
endif # LLMNR_RESPONDER
config DNS_SD
bool "Enable DNS Service Discovery"
help
This option enables DNS Service Discovery for Zephyr. It can
be enabled for virtually any network service with only a few
lines of code and works for both Unicast and Multicast DNS.
See RFC 6763 for more details about DNS-SD.
if DNS_SD
module = DNS_SD
module-dep = NET_LOG
module-str = Log level for DNS-SD
module-help = Enables DNS Service Discovery code to output debug messages.
source "subsys/net/Kconfig.template.log_config.net"
endif # DNS_SD

66
subsys/net/lib/dns/dns_pack.h
View file

@ -21,7 +21,10 @@
/* This is the label's length octet, see 4.1.2. Question section format */
#define DNS_LABEL_LEN_SIZE 1
#define DNS_POINTER_SIZE 2
#define DNS_LABEL_MIN_SIZE 1
#define DNS_LABEL_MAX_SIZE 63
#define DNS_NAME_MAX_SIZE 255
#define DNS_ANSWER_MIN_SIZE 12
#define DNS_COMMON_UINT_SIZE 2
@ -86,7 +89,10 @@ enum dns_rr_type {
DNS_RR_TYPE_INVALID = 0,
DNS_RR_TYPE_A = 1, /* IPv4 */
DNS_RR_TYPE_CNAME = 5, /* CNAME */
DNS_RR_TYPE_AAAA = 28 /* IPv6 */
DNS_RR_TYPE_PTR = 12, /* PTR */
DNS_RR_TYPE_TXT = 16, /* TXT */
DNS_RR_TYPE_AAAA = 28, /* IPv6 */
DNS_RR_TYPE_SRV = 33, /* SRV */
};
enum dns_response_type {
@ -99,6 +105,7 @@ enum dns_response_type {
enum dns_class {
DNS_CLASS_INVALID = 0,
DNS_CLASS_IN,
DNS_CLASS_FLUSH = BIT(15)
};
enum dns_msg_type {
@ -115,6 +122,63 @@ enum dns_header_rcode {
DNS_HEADER_REFUSED
};
struct dns_header {
/** Transaction ID */
uint16_t id;
/**
* | Name | Bit Position | Width | Description |
* |------|--------------|-------|-------------|
* | RCODE | 0 | 4 | Response / Error code |
* | CD | 4 | 1 | |
* | AD | 5 | 1 | Authenticated Data. 0 := Unacceptable, 1 := Acceptable |
* | Z | 6 | 1 | Reserved (WZ/RAZ) |
* | RA | 7 | 1 | Recursion Available. 0 := Unavailable, 1 := Available |
* | RD | 8 | 1 | Recursion Desired. 0 := No Recursion, 1 := Recursion |
* | TC | 9 | 1 | 0 := Not Truncated, 1 := Truncated |
* | AA | 10 | 1 | Answer Authenticated / Answer Authoritative. 0 := Not Authenticated, 1 := Authenticated|
* | Opcode | 11 | 4 | See @ref dns_opcode |
* | QR | 15 | 1 | 0 := Query, 1 := Response |
*/
uint16_t flags;
/** Query count */
uint16_t qdcount;
/** Answer count */
uint16_t ancount;
/** Authority count */
uint16_t nscount;
/** Additional information count */
uint16_t arcount;
/** Flexible array member for records */
uint8_t data[];
} __packed;
struct dns_query {
uint16_t type;
uint16_t class_;
} __packed;
struct dns_rr {
uint16_t type;
uint16_t class_;
uint32_t ttl;
uint16_t rdlength;
uint8_t rdata[];
} __packed;
struct dns_srv_rdata {
uint16_t priority;
uint16_t weight;
uint16_t port;
} __packed;
struct dns_a_rdata {
uint32_t address;
} __packed;
struct dns_aaaa_rdata {
uint8_t address[16];
} __packed;
/** It returns the ID field in the DNS msg header */
static inline int dns_header_id(uint8_t *header)
{

972
subsys/net/lib/dns/dns_sd.c Normal file
View file

@ -0,0 +1,972 @@
/*
* Copyright (c) 2020 Friedt Professional Engineering Services, Inc
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <ctype.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <net/net_context.h>
#include <net/net_core.h>
#include <net/dns_sd.h>
#include <sys/util.h>
#include <zephyr.h>
#include "dns_pack.h"
#include "dns_sd.h"
#include <logging/log.h>
LOG_MODULE_REGISTER(net_dns_sd, CONFIG_DNS_SD_LOG_LEVEL);
const char dns_sd_empty_txt[1];
#ifndef CONFIG_NET_TEST
static size_t service_proto_size(const struct dns_sd_rec *inst);
static bool label_is_valid(const char *label, size_t label_size);
static int add_a_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t host_offset, uint32_t addr,
uint8_t *buf,
uint16_t buf_offset, uint16_t buf_size);
static int add_ptr_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint8_t *buf, uint16_t buf_offset,
uint16_t buf_size,
uint16_t *service_offset,
uint16_t *instance_offset,
uint16_t *domain_offset);
static int add_txt_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t instance_offset, uint8_t *buf,
uint16_t buf_offset, uint16_t buf_size);
static int add_aaaa_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t host_offset, const uint8_t addr[16],
uint8_t *buf, uint16_t buf_offset,
uint16_t buf_size);
static int add_srv_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t instance_offset,
uint16_t domain_offset,
uint8_t *buf, uint16_t buf_offset,
uint16_t buf_size,
uint16_t *host_offset);
static bool rec_is_valid(const struct dns_sd_rec *inst);
#endif /* CONFIG_NET_TEST */
/**
* Calculate the size of a DNS-SD service
*
* This macro calculates the size of the DNS-SD service for a DNS
* Resource Record (RR).
*
* For example, if there is a service called 'My Foo'._http._tcp.local.,
* then the returned size is 18. That is broken down as shown below.
*
* - 1 byte for the size of "_http"
* - 5 bytes for the value of "_http"
* - 1 byte for the size of "_tcp"
* - 4 bytes for the value of "_tcp"
* - 1 byte for the size of "local"
* - 5 bytes for the value of "local"
* - 1 byte for the trailing NUL terminator '\0'
*
* @param ref the DNS-SD record
* @return the size of the DNS-SD service for a DNS Resource Record
*/
size_t service_proto_size(const struct dns_sd_rec *ref)
{
return 0
+ DNS_LABEL_LEN_SIZE + strlen(ref->service)
+ DNS_LABEL_LEN_SIZE + strlen(ref->proto)
+ DNS_LABEL_LEN_SIZE + strlen(ref->domain)
+ DNS_LABEL_LEN_SIZE
;
}
/**
* Check Label Validity according to RFC 1035, Section 3.5
*
* <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
* <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
* <let-dig-hyp> ::= <let-dig> | -
* <let-dig> ::= <letter> | <digit>
* <letter> ::= [a-zA-Z]
* <digit> ::= [0-9]
*/
bool label_is_valid(const char *label, size_t label_size)
{
size_t i;
if (label == NULL) {
return false;
}
if (label_size == 0) {
/* automatically calculate the length of the string */
label_size = strlen(label);
}
if (label_size < DNS_LABEL_MIN_SIZE ||
label_size > DNS_LABEL_MAX_SIZE) {
return false;
}
for (i = 0; i < label_size; ++i) {
if (isalpha((int)label[i])) {
continue;
}
if (i > 0) {
if (isdigit((int)label[i])) {
continue;
}
if ('-' == label[i]) {
continue;
}
}
return false;
}
return true;
}
static bool instance_is_valid(const char *instance)
{
size_t i;
size_t instance_size;
if (instance == NULL) {
NET_DBG("label is NULL");
return false;
}
instance_size = strlen(instance);
if (instance_size < DNS_SD_INSTANCE_MIN_SIZE) {
NET_DBG("label '%s' is too small (%zu, min: %u)",
instance, instance_size,
DNS_SD_INSTANCE_MIN_SIZE);
return false;
}
if (instance_size > DNS_SD_INSTANCE_MAX_SIZE) {
NET_DBG("label '%s' is too big (%zu, max: %u)",
instance, instance_size,
DNS_SD_INSTANCE_MAX_SIZE);
return false;
}
for (i = 0; i < instance_size; ++i) {
/* RFC 6763 Section 4.1.1 */
if (instance[i] <= 0x1f ||
instance[i] == 0x7f) {
NET_DBG(
"instance '%s' contains illegal byte 0x%02x",
instance, instance[i]);
return false;
}
}
return instance_size;
}
static bool service_is_valid(const char *service)
{
size_t service_size;
if (service == NULL) {
NET_DBG("label is NULL");
return false;
}
service_size = strlen(service);
if (service_size < DNS_SD_SERVICE_MIN_SIZE) {
NET_DBG("label '%s' is too small (%zu, min: %u)",
service, service_size, DNS_SD_SERVICE_MIN_SIZE);
return false;
}
if (service_size > DNS_SD_SERVICE_MAX_SIZE) {
NET_DBG("label '%s' is too big (%zu, max: %u)",
service, service_size, DNS_SD_SERVICE_MAX_SIZE);
return false;
}
if (service[0] != DNS_SD_SERVICE_PREFIX) {
NET_DBG("service '%s' invalid (no leading underscore)",
service);
return false;
}
if (!label_is_valid(&service[1], service_size - 1)) {
NET_DBG("service '%s' contains invalid characters",
service);
return false;
}
return service_size;
}
static bool proto_is_valid(const char *proto)
{
size_t proto_size;
if (proto == NULL) {
NET_DBG("label is NULL");
return false;
}
proto_size = strlen(proto);
if (proto_size != DNS_SD_PROTO_SIZE) {
NET_DBG("label '%s' wrong size (%zu, exp: %u)",
proto, proto_size, DNS_SD_PROTO_SIZE);
return false;
}
if (!(strncasecmp("_tcp", proto, DNS_SD_PROTO_SIZE) == 0 ||
strncasecmp("_udp", proto, DNS_SD_PROTO_SIZE) == 0)) {
/* RFC 1034 Section 3.1 */
NET_DBG("proto '%s' is invalid (not _tcp or _udp)",
proto);
return false;
}
return proto_size;
}
static bool domain_is_valid(const char *domain)
{
size_t domain_size;
if (domain == NULL) {
NET_DBG("label is NULL");
return false;
}
domain_size = strlen(domain);
if (domain_size < DNS_SD_DOMAIN_MIN_SIZE) {
NET_DBG("label '%s' is too small (%zu, min: %u)",
domain, domain_size, DNS_SD_DOMAIN_MIN_SIZE);
return false;
}
if (domain_size > DNS_SD_DOMAIN_MAX_SIZE) {
NET_DBG("label '%s' is too big (%zu, max: %u)",
domain, domain_size, DNS_SD_DOMAIN_MAX_SIZE);
return false;
}
if (!label_is_valid(domain, domain_size)) {
NET_DBG("domain '%s' contains invalid characters",
domain);
return false;
}
return domain_size;
}
/**
* Check DNS SD Record for validity
*
* Our records are in the form <Instance>.<Service>.<Proto>.<Domain>
*
* Currently, <Subdomain>.<Domain> services are not supported.
*/
bool rec_is_valid(const struct dns_sd_rec *inst)
{
return true
&& inst != NULL
&& instance_is_valid(inst->instance)
&& service_is_valid(inst->service)
&& proto_is_valid(inst->proto)
&& domain_is_valid(inst->domain)
&& inst->text != NULL
&& inst->port != NULL
;
}
int add_a_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t host_offset, uint32_t addr, uint8_t *buf,
uint16_t buf_offset, uint16_t buf_size)
{
uint16_t total_size;
struct dns_rr *rr;
struct dns_a_rdata *rdata;
uint16_t inst_offs;
uint16_t offset = buf_offset;
if ((DNS_SD_PTR_MASK & host_offset) != 0) {
NET_DBG("offset %u too big for message compression",
host_offset);
return -E2BIG;
}
/* First, calculate that there is enough space in the buffer */
total_size =
/* pointer to .<Instance>.local. */
2 + sizeof(*rr) + sizeof(*rdata);
if (offset > buf_size || total_size >= buf_size - offset) {
NET_DBG("Buffer too small. required: %u available: %d",
total_size, (int)buf_size - (int)offset);
return -ENOSPC;
}
/* insert a pointer to the instance + service name */
inst_offs = host_offset;
inst_offs |= DNS_SD_PTR_MASK;
inst_offs = htons(inst_offs);
memcpy(&buf[offset], &inst_offs, sizeof(inst_offs));
offset += sizeof(inst_offs);
rr = (struct dns_rr *)&buf[offset];
rr->type = htons(DNS_RR_TYPE_A);
rr->class_ = htons(DNS_CLASS_IN | DNS_CLASS_FLUSH);
rr->ttl = htonl(ttl);
rr->rdlength = htons(sizeof(*rdata));
offset += sizeof(*rr);
rdata = (struct dns_a_rdata *)&buf[offset];
rdata->address = htonl(addr);
offset += sizeof(*rdata);
__ASSERT_NO_MSG(total_size == offset - buf_offset);
return offset - buf_offset;
}
int add_ptr_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint8_t *buf, uint16_t buf_offset, uint16_t buf_size,
uint16_t *service_offset, uint16_t *instance_offset,
uint16_t *domain_offset)
{
uint8_t i;
int name_size;
struct dns_rr *rr;
uint16_t svc_offs;
uint16_t inst_offs;
uint16_t dom_offs;
size_t label_size;
uint16_t sp_size;
uint16_t offset = buf_offset;
const char *labels[] = {
inst->instance,
inst->service,
inst->proto,
inst->domain,
};
/* First, ensure that labels and full name are within spec */
if (!rec_is_valid(inst)) {
return -EINVAL;
}
sp_size = service_proto_size(inst);
/*
* Next, calculate that there is enough space in the buffer.
*
* We require that this is the first time names will appear in the
* DNS message. Message Compression is used in subsequent
* calculations.
*
* That is the reason there is an output variable for
* service_offset and instance_offset.
*
* For more information on DNS Message Compression, see
* RFC 1035, Section 4.1.4.
*/
name_size =
/* uncompressed. e.g. "._foo._tcp.local." */
sp_size +
sizeof(*rr)
/* compressed e.g. .My Foo" followed by (DNS_SD_PTR_MASK | 0x0abc) */
+ 1 + strlen(inst->instance) + 2;
if (offset > buf_size || name_size >= buf_size - offset) {
NET_DBG("Buffer too small. required: %u available: %d",
name_size, (int)buf_size - (int)offset);
return -ENOSPC;
}
svc_offs = offset;
if ((svc_offs & DNS_SD_PTR_MASK) != 0) {
NET_DBG("offset %u too big for message compression",
svc_offs);
return -E2BIG;
}
inst_offs = offset + sp_size + sizeof(*rr);
if ((inst_offs & DNS_SD_PTR_MASK) != 0) {
NET_DBG("offset %u too big for message compression",
inst_offs);
return -E2BIG;
}
dom_offs = offset + sp_size - 1 -
strlen(inst->domain) - 1;
/* Finally, write output with confidence that doing so is safe */
*service_offset = svc_offs;
*instance_offset = inst_offs;
*domain_offset = dom_offs;
/* copy the service name. e.g. "._foo._tcp.local." */
for (i = 1; i < ARRAY_SIZE(labels); ++i) {
label_size = strlen(labels[i]);
buf[offset++] = strlen(labels[i]);
memcpy(&buf[offset], labels[i], label_size);
offset += label_size;
if (i == ARRAY_SIZE(labels) - 1) {
/* terminator */
buf[offset++] = '\0';
}
}
__ASSERT_NO_MSG(svc_offs + sp_size == offset);
rr = (struct dns_rr *)&buf[offset];
rr->type = htons(DNS_RR_TYPE_PTR);
rr->class_ = htons(DNS_CLASS_IN);
rr->ttl = htonl(ttl);
rr->rdlength = htons(
DNS_LABEL_LEN_SIZE +
strlen(inst->instance)
+ DNS_POINTER_SIZE);
offset += sizeof(*rr);
__ASSERT_NO_MSG(inst_offs == offset);
/* copy the instance size, value, and add a pointer */
label_size = strlen(inst->instance);
buf[offset++] = label_size;
memcpy(&buf[offset], inst->instance, label_size);
offset += label_size;
svc_offs |= DNS_SD_PTR_MASK;
svc_offs = htons(svc_offs);
memcpy(&buf[offset], &svc_offs, sizeof(svc_offs));
offset += sizeof(svc_offs);
__ASSERT_NO_MSG(name_size == offset - buf_offset);
return offset - buf_offset;
}
int add_txt_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t instance_offset, uint8_t *buf,
uint16_t buf_offset, uint16_t buf_size)
{
uint16_t total_size;
struct dns_rr *rr;
uint16_t inst_offs;
uint16_t offset = buf_offset;
if ((DNS_SD_PTR_MASK & instance_offset) != 0) {
NET_DBG("offset %u too big for message compression",
instance_offset);
return -E2BIG;
}
/* First, calculate that there is enough space in the buffer */
total_size =
/* pointer to .<Instance>.<Service>.<Protocol>.local. */
DNS_POINTER_SIZE + sizeof(*rr) + dns_sd_txt_size(inst);
if (offset > buf_size || total_size >= buf_size - offset) {
NET_DBG("Buffer too small. required: %u available: %d",
total_size, (int)buf_size - (int)offset);
return -ENOSPC;
}
/* insert a pointer to the instance + service name */
inst_offs = instance_offset;
inst_offs |= DNS_SD_PTR_MASK;
inst_offs = htons(inst_offs);
memcpy(&buf[offset], &inst_offs, sizeof(inst_offs));
offset += sizeof(inst_offs);
rr = (struct dns_rr *)&buf[offset];
rr->type = htons(DNS_RR_TYPE_TXT);
rr->class_ = htons(DNS_CLASS_IN | DNS_CLASS_FLUSH);
rr->ttl = htonl(ttl);
rr->rdlength = htons(dns_sd_txt_size(inst));
offset += sizeof(*rr);
memcpy(&buf[offset], inst->text, dns_sd_txt_size(inst));
offset += dns_sd_txt_size(inst);
__ASSERT_NO_MSG(total_size == offset - buf_offset);
return offset - buf_offset;
}
int add_aaaa_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t host_offset, const uint8_t addr[16],
uint8_t *buf, uint16_t buf_offset, uint16_t buf_size)
{
uint16_t total_size;
struct dns_rr *rr;
struct dns_aaaa_rdata *rdata;
uint16_t inst_offs;
uint16_t offset = buf_offset;
if ((DNS_SD_PTR_MASK & host_offset) != 0) {
NET_DBG("offset %u too big for message compression",
host_offset);
return -E2BIG;
}
/* First, calculate that there is enough space in the buffer */
total_size =
/* pointer to .<Instance>.local. */
DNS_POINTER_SIZE + sizeof(*rr) + sizeof(*rdata);
if (offset > buf_size || total_size >= buf_size - offset) {
NET_DBG("Buffer too small. required: %u available: %d",
total_size, (int)buf_size - (int)offset);
return -ENOSPC;
}
/* insert a pointer to the instance + service name */
inst_offs = host_offset;
inst_offs |= DNS_SD_PTR_MASK;
inst_offs = htons(inst_offs);
memcpy(&buf[offset], &inst_offs, sizeof(inst_offs));
offset += sizeof(inst_offs);
rr = (struct dns_rr *)&buf[offset];
rr->type = htons(DNS_RR_TYPE_AAAA);
rr->class_ = htons(DNS_CLASS_IN | DNS_CLASS_FLUSH);
rr->ttl = htonl(ttl);
rr->rdlength = htons(sizeof(*rdata));
offset += sizeof(*rr);
rdata = (struct dns_aaaa_rdata *)&buf[offset];
memcpy(rdata->address, addr, sizeof(*rdata));
offset += sizeof(*rdata);
__ASSERT_NO_MSG(total_size == offset - buf_offset);
return offset - buf_offset;
}
int add_srv_record(const struct dns_sd_rec *inst, uint32_t ttl,
uint16_t instance_offset, uint16_t domain_offset,
uint8_t *buf, uint16_t buf_offset, uint16_t buf_size,
uint16_t *host_offset)
{
uint16_t total_size;
struct dns_rr *rr;
struct dns_srv_rdata *rdata;
size_t label_size;
uint16_t inst_offs;
uint16_t offset = buf_offset;
if ((DNS_SD_PTR_MASK & instance_offset) != 0) {
NET_DBG("offset %u too big for message compression",
instance_offset);
return -E2BIG;
}
if ((DNS_SD_PTR_MASK & domain_offset) != 0) {
NET_DBG("offset %u too big for message compression",
domain_offset);
return -E2BIG;
}
/* First, calculate that there is enough space in the buffer */
total_size =
/* pointer to .<Instance>.<Service>.<Protocol>.local. */
DNS_POINTER_SIZE + sizeof(*rr)
+ sizeof(*rdata)
/* .<Instance> */
+ DNS_LABEL_LEN_SIZE
+ strlen(inst->instance)
/* pointer to .local. */
+ DNS_POINTER_SIZE;
if (offset > buf_size || total_size >= buf_size - offset) {
NET_DBG("Buffer too small. required: %u available: %d",
total_size, (int)buf_size - (int)offset);
return -ENOSPC;
}
/* insert a pointer to the instance + service name */
inst_offs = instance_offset;
inst_offs |= DNS_SD_PTR_MASK;
inst_offs = htons(inst_offs);
memcpy(&buf[offset], &inst_offs, sizeof(inst_offs));
offset += sizeof(inst_offs);
rr = (struct dns_rr *)&buf[offset];
rr->type = htons(DNS_RR_TYPE_SRV);
rr->class_ = htons(DNS_CLASS_IN | DNS_CLASS_FLUSH);
rr->ttl = htonl(ttl);
/* .<Instance>.local. */
rr->rdlength = htons(sizeof(*rdata) + DNS_LABEL_LEN_SIZE
+ strlen(inst->instance) +
DNS_POINTER_SIZE);
offset += sizeof(*rr);
rdata = (struct dns_srv_rdata *)&buf[offset];
rdata->priority = 0;
rdata->weight = 0;
rdata->port = *(inst->port);
offset += sizeof(*rdata);
*host_offset = offset;
label_size = strlen(inst->instance);
buf[offset++] = label_size;
memcpy(&buf[offset], inst->instance, label_size);
offset += label_size;
domain_offset |= DNS_SD_PTR_MASK;
domain_offset = htons(domain_offset);
memcpy(&buf[offset], &domain_offset, sizeof(domain_offset));
offset += sizeof(domain_offset);
__ASSERT_NO_MSG(total_size == offset - buf_offset);
return offset - buf_offset;
}
#ifndef CONFIG_NET_TEST
static bool port_in_use_sockaddr(uint16_t proto, uint16_t port,
const struct sockaddr *addr)
{
const struct sockaddr_in any = {
.sin_family = AF_INET,
.sin_addr.s_addr = INADDR_ANY,
};
const struct sockaddr_in6 any6 = {
.sin6_family = AF_INET6,
.sin6_addr = in6addr_any,
};
const struct sockaddr *anyp =
(addr->sa_family == AF_INET)
? (const struct sockaddr *) &any
: (const struct sockaddr *) &any6;
return
net_context_port_in_use(proto, port, addr)
|| net_context_port_in_use(proto, port, anyp);
}
static bool port_in_use(uint16_t proto, uint16_t port, const struct in_addr *addr4,
const struct in6_addr *addr6)
{
bool r;
struct sockaddr sa;
if (addr4 != NULL) {
net_sin(&sa)->sin_family = AF_INET;
net_sin(&sa)->sin_addr = *addr4;
r = port_in_use_sockaddr(proto, port, &sa);
if (r) {
return true;
}
}
if (addr6 != NULL) {
net_sin6(&sa)->sin6_family = AF_INET6;
net_sin6(&sa)->sin6_addr = *addr6;
r = port_in_use_sockaddr(proto, port, &sa);
if (r) {
return true;
}
}
return false;
}
#else /* CONFIG_NET_TEST */
static inline bool port_in_use(uint16_t proto, uint16_t port, const struct in_addr *addr4,
const struct in6_addr *addr6)
{
ARG_UNUSED(port);
ARG_UNUSED(addr4);
ARG_UNUSED(addr6);
return true;
}
#endif /* CONFIG_NET_TEST */
int dns_sd_handle_ptr_query(const struct dns_sd_rec *inst,
const struct in_addr *addr4, const struct in6_addr *addr6,
uint8_t *buf, uint16_t buf_size)
{
/*
* RFC 6763 Section 12.1
*
* When including a DNS-SD Service Instance Enumeration or Selective
* Instance Enumeration (subtype) PTR record in a response packet, the
* server/responder SHOULD include the following additional records:
*
* o The SRV record(s) named in the PTR rdata.
* o The TXT record(s) named in the PTR rdata.
* o All address records (type "A" and "AAAA") named in the SRV rdata.
* contain the SRV record(s), the TXT record(s), and the address
* records (A or AAAA)
*/
uint16_t instance_offset;
uint16_t service_offset;
uint16_t domain_offset;
uint16_t host_offset;
uint16_t proto;
uint16_t offset = sizeof(struct dns_header);
struct dns_header *rsp = (struct dns_header *)buf;
uint32_t tmp;
int r;
memset(rsp, 0, sizeof(*rsp));
if (!rec_is_valid(inst)) {
return -EINVAL;
}
if (*(inst->port) == 0) {
NET_DBG("Ephemeral port %u for %s.%s.%s.%s "
"not initialized", ntohs(*(inst->port)),
inst->instance, inst->service, inst->proto,
inst->domain);
return -EHOSTDOWN;
}
if (strncmp("_tcp", inst->proto, DNS_SD_PROTO_SIZE) == 0) {
proto = IPPROTO_TCP;
} else if (strncmp("_udp", inst->proto, DNS_SD_PROTO_SIZE) == 0) {
proto = IPPROTO_UDP;
} else {
NET_DBG("invalid protocol %s", inst->proto);
return -EINVAL;
}
if (!port_in_use(proto, ntohs(*(inst->port)), addr4, addr6)) {
/* Service is not yet bound, so do not advertise */
return -EHOSTDOWN;
}
/* first add the answer record */
r = add_ptr_record(inst, DNS_SD_PTR_TTL, buf, offset,
buf_size - offset,
&service_offset, &instance_offset,
&domain_offset);
if (r < 0) {
return r; /* LCOV_EXCL_LINE */
}
rsp->ancount++;
offset += r;
/* then add the additional records */
r = add_txt_record(inst, DNS_SD_TXT_TTL, instance_offset, buf,
offset,
buf_size - offset);
if (r < 0) {
return r; /* LCOV_EXCL_LINE */
}
rsp->arcount++;
offset += r;
r = add_srv_record(inst, DNS_SD_SRV_TTL, instance_offset,
domain_offset,
buf, offset, buf_size - offset, &host_offset);
if (r < 0) {
return r; /* LCOV_EXCL_LINE */
}
rsp->arcount++;
offset += r;
if (addr6 != NULL) {
r = add_aaaa_record(inst, DNS_SD_AAAA_TTL, host_offset,
addr6->s6_addr,
buf, offset,
buf_size - offset); /* LCOV_EXCL_LINE */
if (r < 0) {
return r; /* LCOV_EXCL_LINE */
}
rsp->arcount++;
offset += r;
}
if (addr4 != NULL) {
tmp = htonl(*(addr4->s4_addr32));
r = add_a_record(inst, DNS_SD_A_TTL, host_offset,
tmp, buf, offset,
buf_size - offset);
if (r < 0) {
return r; /* LCOV_EXCL_LINE */
}
rsp->arcount++;
offset += r;
}
/* Set the Response and AA bits */
rsp->flags = htons(BIT(15) | BIT(10));
rsp->ancount = htons(rsp->ancount);
rsp->arcount = htons(rsp->arcount);
return offset;
}
/* TODO: dns_sd_handle_srv_query() */
/* TODO: dns_sd_handle_txt_query() */
bool dns_sd_rec_match(const struct dns_sd_rec *record,
const struct dns_sd_rec *filter)
{
size_t i;
const char *rec_label;
const char *filt_label;
static bool (*checkers[])(const char *) = {
instance_is_valid,
service_is_valid,
proto_is_valid,
domain_is_valid,
};
static const char *names[] = {
"instance",
"service",
"protocol",
"domain",
};
if (!rec_is_valid(record)) {
LOG_WRN("DNS SD record at %p is invalid", record);
return false;
}
if (filter == NULL) {
return false;
}
/* Deref only after it is deemed safe to do so */
const char *const pairs[] = {
record->instance, filter->instance,
record->service, filter->service,
record->proto, filter->proto,
record->domain, filter->domain,
};
BUILD_ASSERT(ARRAY_SIZE(pairs) == 2 * ARRAY_SIZE(checkers));
BUILD_ASSERT(ARRAY_SIZE(names) == ARRAY_SIZE(checkers));
for (i = 0; i < ARRAY_SIZE(checkers); ++i) {
rec_label = pairs[2 * i];
filt_label = pairs[2 * i + 1];
/* check for the "wildcard" pointer */
if (filt_label != NULL) {
if (!checkers[i](filt_label)) {
LOG_WRN("invalid %s label: '%s'",
names[i], filt_label);
return false;
}
if (strncasecmp(rec_label, filt_label,
DNS_LABEL_MAX_SIZE) != 0) {
return false;
}
}
}
/* check for the "wildcard" port */
if (filter->port != NULL && *(record->port) != *(filter->port)) {
return false;
}
return true;
}
int dns_sd_extract_service_proto_domain(const uint8_t *query,
size_t query_size, struct dns_sd_rec *record, char *service,
size_t service_size, char *proto, size_t proto_size, char *domain,
size_t domain_size)
{
uint16_t offs;
uint8_t label_size;
if (query == NULL || record == NULL || service == NULL
|| proto == NULL || domain == NULL) {
NET_DBG("one or more arguments are NULL");
return -EINVAL;
}
if (query_size <= DNS_MSG_HEADER_SIZE
|| service_size < DNS_SD_SERVICE_MAX_SIZE + 1
|| proto_size < DNS_SD_PROTO_SIZE + 1
|| domain_size < DNS_SD_DOMAIN_MAX_SIZE + 1
) {
NET_DBG("one or more size arguments are too small");
return -EINVAL;
}
memset(record, 0, sizeof(*record));
offs = DNS_MSG_HEADER_SIZE;
/* Copy service label to '\0'-terminated buffer */
label_size = query[offs];
if (label_size == 0 || label_size > service_size - 1
|| offs + label_size > query_size) {
NET_DBG("could not get service");
return -EINVAL;
} else {
strncpy(service, &query[offs + 1], label_size);
service[label_size] = '\0';
offs += label_size + 1;
}
/* Copy proto label to '\0'-terminated buffer */
label_size = query[offs];
if (label_size == 0 || label_size > proto_size - 1
|| offs + label_size > query_size) {
NET_DBG("could not get proto for '%s...'", service);
return -EINVAL;
} else {
strncpy(proto, &query[offs + 1], label_size);
proto[label_size] = '\0';
offs += label_size + 1;
}
/* Copy domain label to '\0'-terminated buffer */
label_size = query[offs];
if (label_size == 0 || label_size > domain_size - 1
|| offs + label_size > query_size) {
NET_DBG("could not get domain for '%s.%s...'", service,
proto);
return -EINVAL;
} else {
strncpy(domain, &query[offs + 1], label_size);
domain[label_size] = '\0';
offs += label_size + 1;
}
/* Check that we have reached the DNS terminator */
if (query[offs] != 0) {
NET_DBG("ignoring request for '%s.%s.%s...'",
service, proto, domain);
return -EINVAL;
}
offs++;
record->service = service;
record->proto = proto;
record->domain = domain;
return offs;
}

141
subsys/net/lib/dns/dns_sd.h Normal file
View file

@ -0,0 +1,141 @@
/*
* Copyright (c) 2020 Friedt Professional Engineering Services, Inc
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef DNS_SD_H_
#define DNS_SD_H_
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <net/dns_sd.h>
#include <net/net_ip.h>
#include "dns_pack.h"
/* TODO: Move these into Kconfig */
#define DNS_SD_PTR_TTL 4500
#define DNS_SD_TXT_TTL 4500
#define DNS_SD_SRV_TTL 120
#define DNS_SD_A_TTL 120
#define DNS_SD_AAAA_TTL 120
#define DNS_SD_PTR_MASK (NS_CMPRSFLGS << 8)
#ifdef __cplusplus
extern "C" {
#endif
#define DNS_SD_FOREACH(it) \
Z_STRUCT_SECTION_FOREACH(dns_sd_rec, it)
/**
* @brief Extract the Service, Protocol, and Domain from a DNS-SD PTR query
*
* This function zero-initializes @p record and populates the appropriate
* fields so that @p record may be subsequently passed to @ref dns_sd_rec_match.
*
* If a query with a supported format is found, the function returns the
* length of the initial, variable-length portion of the query.
*
* For example, if the query begins with "._foo._tcp.local.", where
* the '.' character represents a length of the subsequent string value,
* then this function will return 17.
*
* @param query a pointer to the start of the query
* @param query_size the number of bytes contained in the query
* @param[out] record the DNS-SD record to initialize and populate
* @param service buffer to store the null-terminated service
* @param service_size the size of @p service
* @param proto buffer to store the null-terminated proto
* @param proto_size the size of @p proto
* @param domain buffer to store the null-terminated domain
* @param domain_size the size of @p domain
* @return on success, a positive number representing length of the query
* @return on failure, a negative errno value
*/
int dns_sd_extract_service_proto_domain(const uint8_t *query,
size_t query_size, struct dns_sd_rec *record, char *service,
size_t service_size, char *proto, size_t proto_size,
char *domain, size_t domain_size);
/**
* @brief See if the DNS SD @p filter matches the @p record
*
* The fields in @p filter should be populated with filter elements to
* identify a possible match. If pointer fields are set to NULL, they
* act as a wildcard in the matching process. I.e. they will match
* anything. Similarly, the @ref dns_sd_rec.port field may be set to 0
* to be used as a wildcard.
*
* The @ref dns_sd_rec.text and @ref dns_ds_rec.text_size fields
* are not included in the matching process.
*
* For example, the filter below can be used to match any
* "_http._tcp" records.
*
* @code{c}
* const struct dns_sd_rec *it;
* struct dns_sd_rec filter = {
* // match any instance
* .instance = NULL,
* // match records with service "_http"
* .service = "_http",
* // match records with protocol "_tcp"
* .proto = "_tcp",
* // match any domain
* .domain = NULL,
* // match any port
* .port = 0,
* };
*
* DNS_SD_FOREACH(it) {
* if (dns_sd_rec_match(it, filter)) {
* // found a match!
* }
* }
* @endcode{c}
*
* @param record The reference DNS-SD record
* @param filter The DNS-SD record filter
*
* @return true if the @p record matches the @p filter
* @return false if @p record is not a match for @p filter
* @return false if either @p record or @p filter are invalid
*/
bool dns_sd_rec_match(const struct dns_sd_rec *record,
const struct dns_sd_rec *filter);
/**
* @brief Handle a DNS PTR Query with DNS Service Discovery
*
* This function should be called once for each DNS-SD record that
* matches a particular DNS PTR query.
*
* If there is no IPv4 address to advertise, then @p addr4 should be
* NULL.
*
* If there is no IPv6 address to advertise, then @p addr6 should be
* NULL.
*
* @param inst the DNS-SD record for to advertise
* @param addr4 pointer to the IPv4 address
* @param addr6 pointer to the IPv6 address
* @param buf output buffer
* @param buf_size size of the output buffer
*
* @return on success, number of bytes written to @p buf
* @return on failure, a negative errno value
*/
int dns_sd_handle_ptr_query(const struct dns_sd_rec *inst,
const struct in_addr *addr4, const struct in6_addr *addr6,
uint8_t *buf, uint16_t buf_size);
#ifdef __cplusplus
};
#endif
#endif /* DNS_SD_H_ */