diff options
Diffstat (limited to 'src/mslookup/mdns.c')
| -rw-r--r-- | src/mslookup/mdns.c | 425 |
1 files changed, 425 insertions, 0 deletions
diff --git a/src/mslookup/mdns.c b/src/mslookup/mdns.c new file mode 100644 index 0000000..4742a7c --- /dev/null +++ b/src/mslookup/mdns.c @@ -0,0 +1,425 @@ +/* mslookup specific functions for encoding and decoding mslookup queries/results into mDNS packets, using the high + * level functions from mdns_msg.c and mdns_record.c to build the request/answer messages. */ + +/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de> + * + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <osmocom/hlr/logging.h> +#include <osmocom/core/msgb.h> +#include <osmocom/mslookup/mslookup.h> +#include <osmocom/mslookup/mdns_msg.h> +#include <osmocom/mslookup/mdns_rfc.h> +#include <errno.h> +#include <inttypes.h> + +static struct msgb *osmo_mdns_msgb_alloc(const char *label) +{ + return msgb_alloc(1024, label); +} + +/*! Combine the mslookup query service, ID and ID type into a domain string. + * \param[in] domain_suffix is appended to each domain in the queries to avoid colliding with the top-level domains + * administrated by IANA. Example: "mdns.osmocom.org" + * \returns allocated buffer with the resulting domain (i.e. "sip.voice.123.msisdn.mdns.osmocom.org") on success, + * NULL on failure. + */ +static char *domain_from_query(void *ctx, const struct osmo_mslookup_query *query, const char *domain_suffix) +{ + const char *id; + + /* Get id from query */ + switch (query->id.type) { + case OSMO_MSLOOKUP_ID_IMSI: + id = query->id.imsi; + break; + case OSMO_MSLOOKUP_ID_MSISDN: + id = query->id.msisdn; + break; + default: + LOGP(DMSLOOKUP, LOGL_ERROR, "can't encode mslookup query id type %i", query->id.type); + return NULL; + } + + return talloc_asprintf(ctx, "%s.%s.%s.%s", query->service, id, osmo_mslookup_id_type_name(query->id.type), + domain_suffix); +} + +/*! Split up query service, ID and ID type from a domain string into a mslookup query. + * \param[in] domain with domain_suffix, e.g. "sip.voice.123.msisdn.mdns.osmocom.org" + * \param[in] domain_suffix is appended to each domain in the queries to avoid colliding with the top-level domains + * administrated by IANA. It is not part of the resulting struct osmo_mslookup_query, so we + * remove it in this function. Example: "mdns.osmocom.org" + */ +int query_from_domain(struct osmo_mslookup_query *query, const char *domain, const char *domain_suffix) +{ + int domain_len = strlen(domain) - strlen(domain_suffix) - 1; + char domain_buf[OSMO_MDNS_RFC_MAX_NAME_LEN]; + + if (domain_len <= 0 || domain_len >= sizeof(domain_buf)) + return -EINVAL; + + if (domain[domain_len] != '.' || strcmp(domain + domain_len + 1, domain_suffix) != 0) + return -EINVAL; + + memcpy(domain_buf, domain, domain_len); + domain_buf[domain_len] = '\0'; + return osmo_mslookup_query_init_from_domain_str(query, domain_buf); +} + +/*! Encode a mslookup query into a mDNS packet. + * \param[in] domain_suffix is appended to each domain in the queries to avoid colliding with the top-level domains + * administrated by IANA. Example: "mdns.osmocom.org" + * \returns msgb, or NULL on error. + */ +struct msgb *osmo_mdns_query_encode(void *ctx, uint16_t packet_id, const struct osmo_mslookup_query *query, + const char *domain_suffix) +{ + struct osmo_mdns_msg_request req = {0}; + struct msgb *msg = osmo_mdns_msgb_alloc(__func__); + + req.id = packet_id; + req.type = OSMO_MDNS_RFC_RECORD_TYPE_ALL; + req.domain = domain_from_query(ctx, query, domain_suffix); + if (!req.domain) + goto error; + if (osmo_mdns_msg_request_encode(ctx, msg, &req)) + goto error; + talloc_free(req.domain); + return msg; +error: + msgb_free(msg); + talloc_free(req.domain); + return NULL; +} + +/*! Decode a mDNS request packet into a mslookup query. + * \param[out] packet_id the result must be sent with the same packet_id. + * \param[in] domain_suffix is appended to each domain in the queries to avoid colliding with the top-level domains + * administrated by IANA. Example: "mdns.osmocom.org" + * \returns allocated mslookup query on success, NULL on error. + */ +struct osmo_mslookup_query *osmo_mdns_query_decode(void *ctx, const uint8_t *data, size_t data_len, + uint16_t *packet_id, const char *domain_suffix) +{ + struct osmo_mdns_msg_request *req = NULL; + struct osmo_mslookup_query *query = NULL; + + req = osmo_mdns_msg_request_decode(ctx, data, data_len); + if (!req) + return NULL; + + query = talloc_zero(ctx, struct osmo_mslookup_query); + OSMO_ASSERT(query); + if (query_from_domain(query, req->domain, domain_suffix) < 0) + goto error_free; + + *packet_id = req->id; + talloc_free(req); + return query; +error_free: + talloc_free(req); + talloc_free(query); + return NULL; +} + +/*! Parse sockaddr_str from mDNS record, so the mslookup result can be filled with it. + * \param[out] sockaddr_str resulting IPv4 or IPv6 sockaddr_str. + * \param[in] rec single record of the abstracted list of mDNS records + * \returns 0 on success, -EINVAL on error. + */ +static int sockaddr_str_from_mdns_record(struct osmo_sockaddr_str *sockaddr_str, struct osmo_mdns_record *rec) +{ + switch (rec->type) { + case OSMO_MDNS_RFC_RECORD_TYPE_A: + if (rec->length != 4) { + LOGP(DMSLOOKUP, LOGL_ERROR, "unexpected length of A record\n"); + return -EINVAL; + } + osmo_sockaddr_str_from_32(sockaddr_str, *(uint32_t *)rec->data, 0); + break; + case OSMO_MDNS_RFC_RECORD_TYPE_AAAA: + if (rec->length != 16) { + LOGP(DMSLOOKUP, LOGL_ERROR, "unexpected length of AAAA record\n"); + return -EINVAL; + } + osmo_sockaddr_str_from_in6_addr(sockaddr_str, (struct in6_addr*)rec->data, 0); + break; + default: + LOGP(DMSLOOKUP, LOGL_ERROR, "unexpected record type\n"); + return -EINVAL; + } + return 0; +} + +/*! Encode a successful mslookup result, along with the original query and packet_id into one mDNS answer packet. + * + * The records in the packet are ordered as follows: + * 1) "age", ip_v4/v6, "port" (only IPv4 or IPv6 present) or + * 2) "age", ip_v4, "port", ip_v6, "port" (both IPv4 and v6 present). + * "age" and "port" are TXT records, ip_v4 is an A record, ip_v6 is an AAAA record. + * + * \param[in] packet_id as received in osmo_mdns_query_decode(). + * \param[in] query the original query, so we can send the domain back in the answer (i.e. "sip.voice.1234.msisdn"). + * \param[in] result holds the age, IPs and ports of the queried service. + * \param[in] domain_suffix is appended to each domain in the queries to avoid colliding with the top-level domains + * administrated by IANA. Example: "mdns.osmocom.org" + * \returns msg on success, NULL on error. + */ +struct msgb *osmo_mdns_result_encode(void *ctx, uint16_t packet_id, const struct osmo_mslookup_query *query, + const struct osmo_mslookup_result *result, const char *domain_suffix) +{ + struct osmo_mdns_msg_answer ans = {}; + struct osmo_mdns_record *rec_age = NULL; + struct osmo_mdns_record rec_ip_v4 = {0}; + struct osmo_mdns_record rec_ip_v6 = {0}; + struct osmo_mdns_record *rec_ip_v4_port = NULL; + struct osmo_mdns_record *rec_ip_v6_port = NULL; + struct in_addr rec_ip_v4_in; + struct in6_addr rec_ip_v6_in; + struct msgb *msg = osmo_mdns_msgb_alloc(__func__); + char buf[256]; + + ctx = talloc_named(ctx, 0, "osmo_mdns_result_encode"); + + /* Prepare answer (ans) */ + ans.domain = domain_from_query(ctx, query, domain_suffix); + if (!ans.domain) + goto error; + ans.id = packet_id; + INIT_LLIST_HEAD(&ans.records); + + /* Record for age */ + rec_age = osmo_mdns_record_txt_keyval_encode(ctx, "age", "%"PRIu32, result->age); + OSMO_ASSERT(rec_age); + llist_add_tail(&rec_age->list, &ans.records); + + /* Records for IPv4 */ + if (osmo_sockaddr_str_is_set(&result->host_v4)) { + if (osmo_sockaddr_str_to_in_addr(&result->host_v4, &rec_ip_v4_in) < 0) { + LOGP(DMSLOOKUP, LOGL_ERROR, "failed to encode ipv4: %s\n", + osmo_mslookup_result_name_b(buf, sizeof(buf), query, result)); + goto error; + } + rec_ip_v4.type = OSMO_MDNS_RFC_RECORD_TYPE_A; + rec_ip_v4.data = (uint8_t *)&rec_ip_v4_in; + rec_ip_v4.length = sizeof(rec_ip_v4_in); + llist_add_tail(&rec_ip_v4.list, &ans.records); + + rec_ip_v4_port = osmo_mdns_record_txt_keyval_encode(ctx, "port", "%"PRIu16, result->host_v4.port); + OSMO_ASSERT(rec_ip_v4_port); + llist_add_tail(&rec_ip_v4_port->list, &ans.records); + } + + /* Records for IPv6 */ + if (osmo_sockaddr_str_is_set(&result->host_v6)) { + if (osmo_sockaddr_str_to_in6_addr(&result->host_v6, &rec_ip_v6_in) < 0) { + LOGP(DMSLOOKUP, LOGL_ERROR, "failed to encode ipv6: %s\n", + osmo_mslookup_result_name_b(buf, sizeof(buf), query, result)); + goto error; + } + rec_ip_v6.type = OSMO_MDNS_RFC_RECORD_TYPE_AAAA; + rec_ip_v6.data = (uint8_t *)&rec_ip_v6_in; + rec_ip_v6.length = sizeof(rec_ip_v6_in); + llist_add_tail(&rec_ip_v6.list, &ans.records); + + rec_ip_v6_port = osmo_mdns_record_txt_keyval_encode(ctx, "port", "%"PRIu16, result->host_v6.port); + OSMO_ASSERT(rec_ip_v6_port); + llist_add_tail(&rec_ip_v6_port->list, &ans.records); + } + + if (osmo_mdns_msg_answer_encode(ctx, msg, &ans)) { + LOGP(DMSLOOKUP, LOGL_ERROR, "failed to encode mDNS answer: %s\n", + osmo_mslookup_result_name_b(buf, sizeof(buf), query, result)); + goto error; + } + talloc_free(ctx); + return msg; +error: + msgb_free(msg); + talloc_free(ctx); + return NULL; +} + +static int decode_uint32_t(const char *str, uint32_t *val) +{ + long long int lld; + char *endptr = NULL; + *val = 0; + errno = 0; + lld = strtoll(str, &endptr, 10); + if (errno || !endptr || *endptr) + return -EINVAL; + if (lld < 0 || lld > UINT32_MAX) + return -EINVAL; + *val = lld; + return 0; +} + +static int decode_port(const char *str, uint16_t *port) +{ + uint32_t val; + if (decode_uint32_t(str, &val)) + return -EINVAL; + if (val > 65535) + return -EINVAL; + *port = val; + return 0; +} + +/*! Read expected mDNS records into mslookup result. + * + * The records in the packet must be ordered as follows: + * 1) "age", ip_v4/v6, "port" (only IPv4 or IPv6 present) or + * 2) "age", ip_v4, "port", ip_v6, "port" (both IPv4 and v6 present). + * "age" and "port" are TXT records, ip_v4 is an A record, ip_v6 is an AAAA record. + * + * \param[out] result holds the age, IPs and ports of the queried service. + * \param[in] ans abstracted mDNS answer with a list of resource records. + * \returns 0 on success, -EINVAL on error. + */ +int osmo_mdns_result_from_answer(struct osmo_mslookup_result *result, const struct osmo_mdns_msg_answer *ans) +{ + struct osmo_mdns_record *rec; + char txt_key[64]; + char txt_value[64]; + bool found_age = false; + bool found_ip_v4 = false; + bool found_ip_v6 = false; + struct osmo_sockaddr_str *expect_port_for = NULL; + + *result = (struct osmo_mslookup_result){}; + + result->rc = OSMO_MSLOOKUP_RC_NONE; + + llist_for_each_entry(rec, &ans->records, list) { + switch (rec->type) { + case OSMO_MDNS_RFC_RECORD_TYPE_A: + if (expect_port_for) { + LOGP(DMSLOOKUP, LOGL_ERROR, + "'A' record found, but still expecting a 'port' value first\n"); + return -EINVAL; + } + if (found_ip_v4) { + LOGP(DMSLOOKUP, LOGL_ERROR, "'A' record found twice in mDNS answer\n"); + return -EINVAL; + } + found_ip_v4 = true; + expect_port_for = &result->host_v4; + if (sockaddr_str_from_mdns_record(expect_port_for, rec)) { + LOGP(DMSLOOKUP, LOGL_ERROR, "'A' record with invalid address data\n"); + return -EINVAL; + } + break; + case OSMO_MDNS_RFC_RECORD_TYPE_AAAA: + if (expect_port_for) { + LOGP(DMSLOOKUP, LOGL_ERROR, + "'AAAA' record found, but still expecting a 'port' value first\n"); + return -EINVAL; + } + if (found_ip_v6) { + LOGP(DMSLOOKUP, LOGL_ERROR, "'AAAA' record found twice in mDNS answer\n"); + return -EINVAL; + } + found_ip_v6 = true; + expect_port_for = &result->host_v6; + if (sockaddr_str_from_mdns_record(expect_port_for, rec) != 0) { + LOGP(DMSLOOKUP, LOGL_ERROR, "'AAAA' record with invalid address data\n"); + return -EINVAL; + } + break; + case OSMO_MDNS_RFC_RECORD_TYPE_TXT: + if (osmo_mdns_record_txt_keyval_decode(rec, txt_key, sizeof(txt_key), + txt_value, sizeof(txt_value)) != 0) { + LOGP(DMSLOOKUP, LOGL_ERROR, "failed to decode txt record\n"); + return -EINVAL; + } + if (strcmp(txt_key, "age") == 0) { + if (found_age) { + LOGP(DMSLOOKUP, LOGL_ERROR, "duplicate 'TXT' record for 'age'\n"); + return -EINVAL; + } + found_age = true; + if (decode_uint32_t(txt_value, &result->age)) { + LOGP(DMSLOOKUP, LOGL_ERROR, + "'TXT' record: invalid 'age' value ('age=%s')\n", txt_value); + return -EINVAL; + } + } else if (strcmp(txt_key, "port") == 0) { + if (!expect_port_for) { + LOGP(DMSLOOKUP, LOGL_ERROR, + "'TXT' record for 'port' without previous 'A' or 'AAAA' record\n"); + return -EINVAL; + } + if (decode_port(txt_value, &expect_port_for->port)) { + LOGP(DMSLOOKUP, LOGL_ERROR, + "'TXT' record: invalid 'port' value ('port=%s')\n", txt_value); + return -EINVAL; + } + expect_port_for = NULL; + } else { + LOGP(DMSLOOKUP, LOGL_ERROR, "unexpected key '%s' in TXT record\n", txt_key); + return -EINVAL; + } + break; + default: + LOGP(DMSLOOKUP, LOGL_ERROR, "unexpected record type\n"); + return -EINVAL; + } + } + + /* Check if everything was found */ + if (!found_age || !(found_ip_v4 || found_ip_v6) || expect_port_for) { + LOGP(DMSLOOKUP, LOGL_ERROR, "missing resource records in mDNS answer\n"); + return -EINVAL; + } + + result->rc = OSMO_MSLOOKUP_RC_RESULT; + return 0; +} + +/*! Decode a mDNS answer packet into a mslookup result, query and packet_id. + * \param[out] packet_id same ID as sent in the request packet. + * \param[out] query the original query (service, ID, ID type). + * \param[out] result holds the age, IPs and ports of the queried service. + * \param[in] domain_suffix is appended to each domain in the queries to avoid colliding with the top-level domains + * administrated by IANA. Example: "mdns.osmocom.org" + * \returns 0 on success, -EINVAL on error. + */ +int osmo_mdns_result_decode(void *ctx, const uint8_t *data, size_t data_len, uint16_t *packet_id, + struct osmo_mslookup_query *query, struct osmo_mslookup_result *result, + const char *domain_suffix) +{ + int rc = -EINVAL; + struct osmo_mdns_msg_answer *ans; + ans = osmo_mdns_msg_answer_decode(ctx, data, data_len); + if (!ans) + goto exit_free; + + if (query_from_domain(query, ans->domain, domain_suffix) < 0) + goto exit_free; + + if (osmo_mdns_result_from_answer(result, ans) < 0) + goto exit_free; + + *packet_id = ans->id; + rc = 0; + +exit_free: + talloc_free(ans); + return rc; +} |