2014-01-30 10:04:43 -06:00
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* /brief getdns support functions for DNS Resource Records
|
|
|
|
|
*
|
|
|
|
|
* This file contains the tables with the information needed by getdns about
|
|
|
|
|
* individual RRs, such as their name and rdata fields and types.
|
|
|
|
|
* This information is provided via the response dict.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
/*
|
2014-02-25 07:12:33 -06:00
|
|
|
* Copyright (c) 2013, NLnet Labs, Verisign, Inc.
|
2014-01-30 10:04:43 -06:00
|
|
|
* All rights reserved.
|
2014-02-05 12:47:46 -06:00
|
|
|
*
|
2014-01-30 10:04:43 -06:00
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
|
* * Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2014-02-25 07:23:19 -06:00
|
|
|
* * Neither the names of the copyright holders nor the
|
2014-01-30 10:04:43 -06:00
|
|
|
* names of its contributors may be used to endorse or promote products
|
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL Verisign, Inc. BE LIABLE FOR ANY
|
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "rr-dict.h"
|
2015-02-18 17:20:13 -06:00
|
|
|
#include "gldns/gbuffer.h"
|
2015-02-18 08:44:09 -06:00
|
|
|
#include "util-internal.h"
|
2014-01-30 10:04:43 -06:00
|
|
|
#include "types-internal.h"
|
|
|
|
|
#include "context.h"
|
2014-02-06 15:09:00 -06:00
|
|
|
#include "dict.h"
|
2014-01-30 10:04:43 -06:00
|
|
|
|
|
|
|
|
#define ALEN(a) (sizeof(a)/sizeof(a[0]))
|
2014-09-02 15:31:50 -05:00
|
|
|
#define UNKNOWN_RDATA NULL
|
2014-01-30 10:04:43 -06:00
|
|
|
|
2015-02-18 08:44:09 -06:00
|
|
|
static uint8_t *
|
|
|
|
|
apl_n_rdf_end(uint8_t *pkt, uint8_t *pkt_end, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
return rdf < pkt_end ? rdf + 1 : NULL;
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
apl_n_dict_set_value(getdns_dict *dict, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
return getdns_dict_set_int(dict, "n", (*rdf >> 7));
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
2015-02-18 13:39:56 -06:00
|
|
|
apl_n_list_append_value(getdns_list *list, uint8_t *rdf)
|
2015-02-18 08:44:09 -06:00
|
|
|
{
|
|
|
|
|
return getdns_list_append_int(list, (*rdf >> 7));
|
|
|
|
|
}
|
|
|
|
|
static priv_getdns_rdf_special apl_n = {
|
2015-02-18 13:39:56 -06:00
|
|
|
apl_n_rdf_end, apl_n_dict_set_value, apl_n_list_append_value
|
2015-02-18 08:44:09 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static uint8_t *
|
|
|
|
|
apl_afdpart_rdf_end(uint8_t *pkt, uint8_t *pkt_end, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *end = rdf + (rdf[-1] & 0x7F);
|
|
|
|
|
return end <= pkt_end ? end : NULL;
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
apl_afdpart_dict_set_value(getdns_dict *dict, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
getdns_bindata bindata = { (rdf[-1] & 0x7F), rdf };
|
|
|
|
|
return getdns_dict_set_bindata(dict, "afdpart", &bindata);
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
2015-02-18 13:39:56 -06:00
|
|
|
apl_afdpart_list_append_value(getdns_list *list, uint8_t *rdf)
|
2015-02-18 08:44:09 -06:00
|
|
|
{
|
|
|
|
|
getdns_bindata bindata = { (rdf[-1] & 0x7F), rdf };
|
|
|
|
|
return getdns_list_append_bindata(list, &bindata);
|
|
|
|
|
}
|
|
|
|
|
static priv_getdns_rdf_special apl_afdpart = {
|
2015-02-18 13:39:56 -06:00
|
|
|
apl_afdpart_rdf_end,
|
|
|
|
|
apl_afdpart_dict_set_value, apl_afdpart_list_append_value
|
2015-02-18 08:44:09 -06:00
|
|
|
};
|
|
|
|
|
|
2015-02-18 16:36:32 -06:00
|
|
|
static uint8_t *
|
|
|
|
|
ipseckey_gateway_rdf_end(uint8_t *pkt, uint8_t *pkt_end, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *end;
|
|
|
|
|
|
|
|
|
|
if (rdf - 5 < pkt)
|
|
|
|
|
return NULL;
|
|
|
|
|
switch (rdf[-2]) {
|
|
|
|
|
case 0: end = rdf;
|
|
|
|
|
break;
|
|
|
|
|
case 1: end = rdf + 4;
|
|
|
|
|
break;
|
|
|
|
|
case 2: end = rdf + 16;
|
|
|
|
|
break;
|
|
|
|
|
case 3: for (end = rdf; end < pkt_end; end += *end + 1)
|
|
|
|
|
if ((*end & 0xC0) == 0xC0)
|
|
|
|
|
end += 2;
|
|
|
|
|
else if (*end & 0xC0)
|
|
|
|
|
return NULL;
|
|
|
|
|
else if (!*end) {
|
|
|
|
|
end += 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return end <= pkt_end ? end : NULL;
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
ipseckey_gateway_equip_bindata(uint8_t *rdf, getdns_bindata *bindata)
|
|
|
|
|
{
|
|
|
|
|
bindata->data = rdf;
|
|
|
|
|
switch (rdf[-2]) {
|
|
|
|
|
case 0: bindata->size = 0;
|
|
|
|
|
break;
|
|
|
|
|
case 1: bindata->size = 4;
|
|
|
|
|
break;
|
|
|
|
|
case 2: bindata->size = 16;
|
|
|
|
|
break;
|
|
|
|
|
case 3: while (*rdf)
|
|
|
|
|
if ((*rdf & 0xC0) == 0xC0)
|
|
|
|
|
rdf += 2;
|
|
|
|
|
else if (*rdf & 0xC0)
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
else
|
|
|
|
|
rdf += *rdf + 1;
|
|
|
|
|
bindata->size = rdf + 1 - bindata->data;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
|
|
|
|
return GETDNS_RETURN_GOOD;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
ipseckey_gateway_dict_set_value(getdns_dict *dict, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
getdns_bindata bindata;
|
|
|
|
|
|
|
|
|
|
if (ipseckey_gateway_equip_bindata(rdf, &bindata))
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
|
|
|
|
|
else if (! bindata.size)
|
|
|
|
|
return GETDNS_RETURN_GOOD;
|
|
|
|
|
else
|
|
|
|
|
return getdns_dict_set_bindata(dict, "gateway", &bindata);
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
ipseckey_gateway_list_append_value(getdns_list *list, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
getdns_bindata bindata;
|
|
|
|
|
|
|
|
|
|
if (ipseckey_gateway_equip_bindata(rdf, &bindata))
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
|
|
|
|
|
else if (! bindata.size)
|
|
|
|
|
return GETDNS_RETURN_GOOD;
|
|
|
|
|
else
|
|
|
|
|
return getdns_list_append_bindata(list, &bindata);
|
|
|
|
|
}
|
|
|
|
|
static priv_getdns_rdf_special ipseckey_gateway = {
|
|
|
|
|
ipseckey_gateway_rdf_end,
|
|
|
|
|
ipseckey_gateway_dict_set_value, ipseckey_gateway_list_append_value
|
|
|
|
|
};
|
2015-02-18 17:21:37 -06:00
|
|
|
|
2015-02-18 17:20:13 -06:00
|
|
|
static uint8_t *
|
|
|
|
|
hip_pk_algorithm_rdf_end(uint8_t *pkt, uint8_t *pkt_end, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
return rdf + 4 > pkt_end ? NULL
|
|
|
|
|
: rdf + 4 + *rdf + gldns_read_uint16(rdf + 2) > pkt_end ? NULL
|
|
|
|
|
: rdf + 1;
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
hip_pk_algorithm_dict_set_value(getdns_dict *dict, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
return getdns_dict_set_int(dict, "pk_algorithm", rdf[1]);
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
hip_pk_algorithm_list_append_value(getdns_list *list, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
return getdns_list_append_int(list, rdf[1]);
|
|
|
|
|
}
|
|
|
|
|
static priv_getdns_rdf_special hip_pk_algorithm = {
|
|
|
|
|
hip_pk_algorithm_rdf_end,
|
|
|
|
|
hip_pk_algorithm_dict_set_value, hip_pk_algorithm_list_append_value
|
|
|
|
|
};
|
2015-02-18 17:21:37 -06:00
|
|
|
|
2015-02-18 17:20:13 -06:00
|
|
|
static uint8_t *
|
|
|
|
|
hip_hit_rdf_end(uint8_t *pkt, uint8_t *pkt_end, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
return rdf + 3 > pkt_end ? NULL
|
|
|
|
|
: rdf + 3 + rdf[-1] + gldns_read_uint16(rdf + 1) > pkt_end ? NULL
|
|
|
|
|
: rdf + 1;
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
hip_hit_dict_set_value(getdns_dict *dict, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
getdns_bindata bindata = { rdf[-1], rdf + 3 };
|
|
|
|
|
return getdns_dict_set_bindata(dict, "hit", &bindata);
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
hip_hit_list_append_value(getdns_list *list, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
getdns_bindata bindata = { rdf[-1], rdf + 3 };
|
|
|
|
|
return getdns_list_append_bindata(list, &bindata);
|
|
|
|
|
}
|
|
|
|
|
static priv_getdns_rdf_special hip_hit = {
|
|
|
|
|
hip_hit_rdf_end, hip_hit_dict_set_value, hip_hit_list_append_value
|
|
|
|
|
};
|
2015-02-18 17:21:37 -06:00
|
|
|
|
2015-02-18 17:20:13 -06:00
|
|
|
static uint8_t *
|
|
|
|
|
hip_public_key_rdf_end(uint8_t *pkt, uint8_t *pkt_end, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
return rdf + 2 > pkt_end ? NULL
|
|
|
|
|
: rdf + 2 + rdf[-2] + gldns_read_uint16(rdf) > pkt_end ? NULL
|
|
|
|
|
: rdf + 2 + rdf[-2] + gldns_read_uint16(rdf);
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
hip_public_key_dict_set_value(getdns_dict *dict, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
getdns_bindata bindata = { gldns_read_uint16(rdf), rdf + 2 + rdf[-2] };
|
|
|
|
|
return getdns_dict_set_bindata(dict, "public_key", &bindata);
|
|
|
|
|
}
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
hip_public_key_list_append_value(getdns_list *list, uint8_t *rdf)
|
|
|
|
|
{
|
|
|
|
|
getdns_bindata bindata = { gldns_read_uint16(rdf), rdf + 2 + rdf[-2] };
|
|
|
|
|
return getdns_list_append_bindata(list, &bindata);
|
|
|
|
|
}
|
|
|
|
|
static priv_getdns_rdf_special hip_public_key = {
|
|
|
|
|
hip_public_key_rdf_end,
|
|
|
|
|
hip_public_key_dict_set_value, hip_public_key_list_append_value
|
|
|
|
|
};
|
2015-02-18 16:36:32 -06:00
|
|
|
|
2015-02-18 17:21:37 -06:00
|
|
|
|
2015-02-14 04:44:13 -06:00
|
|
|
static priv_getdns_rdata_def a_rdata[] = {
|
|
|
|
|
{ "ipv4_address" , GETDNS_RDF_A }};
|
|
|
|
|
static priv_getdns_rdata_def ns_rdata[] = {
|
|
|
|
|
{ "nsdname" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def md_rdata[] = {
|
|
|
|
|
{ "madname" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def cname_rdata[] = {
|
|
|
|
|
{ "cname" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def soa_rdata[] = {
|
|
|
|
|
{ "mname" , GETDNS_RDF_N_C },
|
|
|
|
|
{ "rname" , GETDNS_RDF_N_C },
|
|
|
|
|
{ "serial" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "refresh" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "refresh" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "retry" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "expire" , GETDNS_RDF_I4 }};
|
|
|
|
|
static priv_getdns_rdata_def mg_rdata[] = {
|
|
|
|
|
{ "mgmname" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def mr_rdata[] = {
|
|
|
|
|
{ "newname" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def null_rdata[] = {
|
|
|
|
|
{ "anything" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def wks_rdata[] = {
|
|
|
|
|
{ "address" , GETDNS_RDF_A },
|
|
|
|
|
{ "protocol" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "bitmap" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def ptr_rdata[] = {
|
|
|
|
|
{ "ptrdname" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def hinfo_rdata[] = {
|
|
|
|
|
{ "cpu" , GETDNS_RDF_S },
|
|
|
|
|
{ "os" , GETDNS_RDF_S }};
|
|
|
|
|
static priv_getdns_rdata_def minfo_rdata[] = {
|
|
|
|
|
{ "rmailbx" , GETDNS_RDF_N_C },
|
|
|
|
|
{ "emailbx" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def mx_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "exchange" , GETDNS_RDF_N_C }};
|
|
|
|
|
static priv_getdns_rdata_def txt_rdata[] = {
|
|
|
|
|
{ "txt_strings" , GETDNS_RDF_S_M }};
|
|
|
|
|
static priv_getdns_rdata_def rp_rdata[] = {
|
|
|
|
|
{ "mbox_dname" , GETDNS_RDF_N },
|
|
|
|
|
{ "txt_dname" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def afsdb_rdata[] = {
|
|
|
|
|
{ "subtype" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "hostname" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def x25_rdata[] = {
|
|
|
|
|
{ "psdn_address" , GETDNS_RDF_S }};
|
|
|
|
|
static priv_getdns_rdata_def isdn_rdata[] = {
|
|
|
|
|
{ "isdn_address" , GETDNS_RDF_S },
|
|
|
|
|
{ "sa" , GETDNS_RDF_S }};
|
|
|
|
|
static priv_getdns_rdata_def rt_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "intermediate_host" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def nsap_rdata[] = {
|
|
|
|
|
{ "nsap" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def sig_rdata[] = {
|
|
|
|
|
{ "sig_obsolete" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def key_rdata[] = {
|
|
|
|
|
{ "key_obsolete" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def px_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "map822" , GETDNS_RDF_N },
|
|
|
|
|
{ "mapx400" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def gpos_rdata[] = {
|
|
|
|
|
{ "longitude" , GETDNS_RDF_S },
|
|
|
|
|
{ "latitude" , GETDNS_RDF_S },
|
|
|
|
|
{ "altitude" , GETDNS_RDF_S }};
|
|
|
|
|
static priv_getdns_rdata_def aaaa_rdata[] = {
|
|
|
|
|
{ "ipv6_address" , GETDNS_RDF_AAAA }};
|
|
|
|
|
static priv_getdns_rdata_def loc_rdata[] = {
|
|
|
|
|
{ "loc_obsolete" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def nxt_rdata[] = {
|
|
|
|
|
{ "nxt_obsolete" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def srv_rdata[] = {
|
|
|
|
|
{ "priority" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "weight" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "port" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "target" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def atma_rdata[] = {
|
|
|
|
|
{ "format" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def naptr_rdata[] = {
|
|
|
|
|
{ "order" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "flags" , GETDNS_RDF_S },
|
|
|
|
|
{ "service" , GETDNS_RDF_S },
|
|
|
|
|
{ "regexp" , GETDNS_RDF_S },
|
|
|
|
|
{ "replacement" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def kx_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "exchanger" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def cert_rdata[] = {
|
|
|
|
|
{ "type" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "key_tag" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "certificate_or_crl" , GETDNS_RDF_B }};
|
|
|
|
|
static priv_getdns_rdata_def a6_rdata[] = {
|
|
|
|
|
{ "a6_obsolete" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def dname_rdata[] = {
|
|
|
|
|
{ "target" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def opt_rdata[] = {
|
|
|
|
|
{ "options" , GETDNS_RDF_R },
|
|
|
|
|
{ "option_code" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "option_data" , GETDNS_RDF_X_2 }};
|
|
|
|
|
static priv_getdns_rdata_def apl_rdata[] = {
|
|
|
|
|
{ "apitems" , GETDNS_RDF_R },
|
|
|
|
|
{ "address_family" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "prefix" , GETDNS_RDF_I1 },
|
2015-02-18 08:44:09 -06:00
|
|
|
{ "n" , GETDNS_RDF_SPECIAL, &apl_n },
|
|
|
|
|
{ "afdpart" , GETDNS_RDF_SPECIAL, &apl_afdpart }};
|
2015-02-14 04:44:13 -06:00
|
|
|
static priv_getdns_rdata_def ds_rdata[] = {
|
|
|
|
|
{ "key_tag" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "digest_type" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "digest" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def sshfp_rdata[] = {
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "fp_type" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "fingerprint" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def ipseckey_rdata[] = {
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "gateway_type" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "precedence" , GETDNS_RDF_I1 },
|
2015-02-18 16:36:32 -06:00
|
|
|
{ "gateway" , GETDNS_RDF_SPECIAL, &ipseckey_gateway },
|
2015-02-14 04:44:13 -06:00
|
|
|
{ "public_key" , GETDNS_RDF_B }};
|
|
|
|
|
static priv_getdns_rdata_def rrsig_rdata[] = {
|
|
|
|
|
{ "type_covered" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "labels" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "original_ttl" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "signature_expiration" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "signature_inception" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "key_tag" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "signers_name" , GETDNS_RDF_N },
|
|
|
|
|
{ "signature" , GETDNS_RDF_B }};
|
|
|
|
|
static priv_getdns_rdata_def nsec_rdata[] = {
|
|
|
|
|
{ "next_domain_name" , GETDNS_RDF_N },
|
|
|
|
|
{ "type_bit_maps" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def dnskey_rdata[] = {
|
|
|
|
|
{ "flags" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "protocol" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "public_key" , GETDNS_RDF_B }};
|
|
|
|
|
static priv_getdns_rdata_def dhcid_rdata[] = {
|
|
|
|
|
{ "dhcid_opaque" , GETDNS_RDF_B }};
|
|
|
|
|
static priv_getdns_rdata_def nsec3_rdata[] = {
|
|
|
|
|
{ "hash_algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "flags" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "iterations" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "salt" , GETDNS_RDF_X_C },
|
|
|
|
|
{ "next_hashed_owner_name" , GETDNS_RDF_B32_C},
|
|
|
|
|
{ "type_bit_maps" , GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def nsec3param_rdata[] = {
|
|
|
|
|
{ "hash_algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "flags" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "iterations" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "salt" , GETDNS_RDF_X_C }};
|
|
|
|
|
static priv_getdns_rdata_def tlsa_rdata[] = {
|
|
|
|
|
{ "certificate_usage" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "selector" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "matching_type" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "certificate_association_data", GETDNS_RDF_X }};
|
|
|
|
|
static priv_getdns_rdata_def hip_rdata[] = {
|
2015-02-18 17:20:13 -06:00
|
|
|
{ "pk_algorithm" , GETDNS_RDF_SPECIAL, &hip_pk_algorithm },
|
|
|
|
|
{ "hit" , GETDNS_RDF_SPECIAL, &hip_hit },
|
|
|
|
|
{ "public_key" , GETDNS_RDF_SPECIAL, &hip_public_key },
|
2015-02-14 04:44:13 -06:00
|
|
|
{ "rendezvous_servers" , GETDNS_RDF_N_M }};
|
|
|
|
|
static priv_getdns_rdata_def spf_rdata[] = {
|
|
|
|
|
{ "text" , GETDNS_RDF_S_M }};
|
|
|
|
|
static priv_getdns_rdata_def nid_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "node_id" , GETDNS_RDF_X8 }};
|
|
|
|
|
static priv_getdns_rdata_def l32_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "locator32" , GETDNS_RDF_A }};
|
|
|
|
|
static priv_getdns_rdata_def l64_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "locator64" , GETDNS_RDF_X8 }};
|
|
|
|
|
static priv_getdns_rdata_def lp_rdata[] = {
|
|
|
|
|
{ "preference" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "fqdn" , GETDNS_RDF_N }};
|
|
|
|
|
static priv_getdns_rdata_def eui48_rdata[] = {
|
|
|
|
|
{ "eui48_address" , GETDNS_RDF_X6 }};
|
|
|
|
|
static priv_getdns_rdata_def eui64_rdata[] = {
|
|
|
|
|
{ "eui64_address" , GETDNS_RDF_X8 }};
|
|
|
|
|
static priv_getdns_rdata_def tkey_rdata[] = {
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_N },
|
|
|
|
|
{ "inception" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "expiration" , GETDNS_RDF_I4 },
|
|
|
|
|
{ "mode" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "error" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "key_data" , GETDNS_RDF_X_2 },
|
|
|
|
|
{ "other_data" , GETDNS_RDF_X_2 }};
|
|
|
|
|
static priv_getdns_rdata_def tsig_rdata[] = {
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_N },
|
|
|
|
|
{ "time_signed" , GETDNS_RDF_I6 },
|
|
|
|
|
{ "fudge" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "mac" , GETDNS_RDF_X_2 },
|
|
|
|
|
{ "original_id" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "error" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "other_data" , GETDNS_RDF_X_2 }};
|
|
|
|
|
static priv_getdns_rdata_def uri_rdata[] = {
|
|
|
|
|
{ "priority" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "weight" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "target" , GETDNS_RDF_S_M }};
|
|
|
|
|
static priv_getdns_rdata_def caa_rdata[] = {
|
|
|
|
|
{ "flags" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "tag" , GETDNS_RDF_S },
|
|
|
|
|
{ "value" , GETDNS_RDF_S_M }};
|
|
|
|
|
static priv_getdns_rdata_def dlv_rdata[] = {
|
|
|
|
|
{ "key_tag" , GETDNS_RDF_I2 },
|
|
|
|
|
{ "algorithm" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "digest_type" , GETDNS_RDF_I1 },
|
|
|
|
|
{ "digest" , GETDNS_RDF_X }};
|
|
|
|
|
|
|
|
|
|
static priv_getdns_rr_def priv_getdns_rr_defs[] = {
|
2014-01-30 10:04:43 -06:00
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ "A", a_rdata, ALEN( a_rdata) }, /* 1 - */
|
|
|
|
|
{ "NS", ns_rdata, ALEN( ns_rdata) },
|
|
|
|
|
{ "MD", md_rdata, ALEN( md_rdata) },
|
2015-02-14 04:44:13 -06:00
|
|
|
{ "MF", md_rdata, ALEN( md_rdata) },
|
2014-01-30 10:04:43 -06:00
|
|
|
{ "CNAME", cname_rdata, ALEN( cname_rdata) },
|
|
|
|
|
{ "SOA", soa_rdata, ALEN( soa_rdata) },
|
2015-02-14 04:44:13 -06:00
|
|
|
{ "MB", md_rdata, ALEN( md_rdata) },
|
2014-01-30 10:04:43 -06:00
|
|
|
{ "MG", mg_rdata, ALEN( mg_rdata) },
|
|
|
|
|
{ "MR", mr_rdata, ALEN( mr_rdata) },
|
|
|
|
|
{ "NULL", null_rdata, ALEN( null_rdata) },
|
|
|
|
|
{ "WKS", wks_rdata, ALEN( wks_rdata) },
|
|
|
|
|
{ "PTR", ptr_rdata, ALEN( ptr_rdata) },
|
|
|
|
|
{ "HINFO", hinfo_rdata, ALEN( hinfo_rdata) },
|
|
|
|
|
{ "MINFO", minfo_rdata, ALEN( minfo_rdata) },
|
|
|
|
|
{ "MX", mx_rdata, ALEN( mx_rdata) },
|
|
|
|
|
{ "TXT", txt_rdata, ALEN( txt_rdata) },
|
|
|
|
|
{ "RP", rp_rdata, ALEN( rp_rdata) },
|
|
|
|
|
{ "AFSDB", afsdb_rdata, ALEN( afsdb_rdata) },
|
|
|
|
|
{ "X25", x25_rdata, ALEN( x25_rdata) },
|
|
|
|
|
{ "ISDN", isdn_rdata, ALEN( isdn_rdata) },
|
|
|
|
|
{ "RT", rt_rdata, ALEN( rt_rdata) },
|
|
|
|
|
{ "NSAP", nsap_rdata, ALEN( nsap_rdata) }, /* - 22 */
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ "SIG", sig_rdata, ALEN( sig_rdata) }, /* 24 - */
|
|
|
|
|
{ "KEY", key_rdata, ALEN( key_rdata) },
|
|
|
|
|
{ "PX", px_rdata, ALEN( px_rdata) },
|
|
|
|
|
{ "GPOS", gpos_rdata, ALEN( gpos_rdata) },
|
|
|
|
|
{ "AAAA", aaaa_rdata, ALEN( aaaa_rdata) },
|
|
|
|
|
{ "LOC", loc_rdata, ALEN( loc_rdata) },
|
|
|
|
|
{ "NXT", nxt_rdata, ALEN( nxt_rdata) },
|
2014-09-02 15:31:50 -05:00
|
|
|
{ "EID", UNKNOWN_RDATA, 0 },
|
|
|
|
|
{ "NIMLOC", UNKNOWN_RDATA, 0 },
|
2014-01-30 10:04:43 -06:00
|
|
|
{ "SRV", srv_rdata, ALEN( srv_rdata) },
|
|
|
|
|
{ "ATMA", atma_rdata, ALEN( atma_rdata) },
|
|
|
|
|
{ "NAPTR", naptr_rdata, ALEN( naptr_rdata) },
|
|
|
|
|
{ "KX", kx_rdata, ALEN( kx_rdata) },
|
|
|
|
|
{ "CERT", cert_rdata, ALEN( cert_rdata) },
|
|
|
|
|
{ "A6", a6_rdata, ALEN( a6_rdata) },
|
|
|
|
|
{ "DNAME", dname_rdata, ALEN( dname_rdata) },
|
2014-09-02 15:31:50 -05:00
|
|
|
{ "SINK", UNKNOWN_RDATA, 0 },
|
2014-01-30 10:04:43 -06:00
|
|
|
{ "OPT", opt_rdata, ALEN( opt_rdata) },
|
|
|
|
|
{ "APL", apl_rdata, ALEN( apl_rdata) },
|
|
|
|
|
{ "DS", ds_rdata, ALEN( ds_rdata) },
|
|
|
|
|
{ "SSHFP", sshfp_rdata, ALEN( sshfp_rdata) },
|
|
|
|
|
{ "IPSECKEY", ipseckey_rdata, ALEN( ipseckey_rdata) },
|
|
|
|
|
{ "RRSIG", rrsig_rdata, ALEN( rrsig_rdata) },
|
|
|
|
|
{ "NSEC", nsec_rdata, ALEN( nsec_rdata) },
|
|
|
|
|
{ "DNSKEY", dnskey_rdata, ALEN( dnskey_rdata) },
|
|
|
|
|
{ "DHCID", dhcid_rdata, ALEN( dhcid_rdata) },
|
|
|
|
|
{ "NSEC3", nsec3_rdata, ALEN( nsec3_rdata) },
|
|
|
|
|
{ "NSEC3PARAM", nsec3param_rdata, ALEN(nsec3param_rdata) },
|
|
|
|
|
{ "TLSA", tlsa_rdata, ALEN( tlsa_rdata) }, /* - 52 */
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ "HIP", hip_rdata, ALEN( hip_rdata) }, /* 55 - */
|
2014-09-02 15:31:50 -05:00
|
|
|
{ "NINFO", UNKNOWN_RDATA, 0 },
|
|
|
|
|
{ "RKEY", UNKNOWN_RDATA, 0 },
|
|
|
|
|
{ "TALINK", UNKNOWN_RDATA, 0 },
|
2014-08-25 04:04:43 -05:00
|
|
|
{ "CDS", ds_rdata, ALEN( ds_rdata) },
|
|
|
|
|
{ "CDNSKEY", dnskey_rdata, ALEN( dnskey_rdata) },
|
2015-02-19 07:07:42 -06:00
|
|
|
{ "OPENPGPKEY", UNKNOWN_RDATA, 0 }, /* 61 - */
|
|
|
|
|
{ "CSYNC", UNKNOWN_RDATA, 0 }, /* - 62 */
|
2014-01-30 10:04:43 -06:00
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ "SPF", spf_rdata, ALEN( spf_rdata) }, /* 99 - */
|
2014-09-02 15:31:50 -05:00
|
|
|
{ "UINFO", UNKNOWN_RDATA, 0 },
|
|
|
|
|
{ "UID", UNKNOWN_RDATA, 0 },
|
|
|
|
|
{ "GID", UNKNOWN_RDATA, 0 },
|
|
|
|
|
{ "UNSPEC", UNKNOWN_RDATA, 0 },
|
2014-01-30 10:04:43 -06:00
|
|
|
{ "NID", nid_rdata, ALEN( nid_rdata) },
|
|
|
|
|
{ "L32", l32_rdata, ALEN( l32_rdata) },
|
|
|
|
|
{ "L64", l64_rdata, ALEN( l64_rdata) },
|
|
|
|
|
{ "LP", lp_rdata, ALEN( lp_rdata) },
|
|
|
|
|
{ "EUI48", eui48_rdata, ALEN( eui48_rdata) },
|
|
|
|
|
{ "EUI64", eui64_rdata, ALEN( eui64_rdata) }, /* - 109 */
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ "TKEY", tkey_rdata, ALEN( tkey_rdata) }, /* 249 - */
|
|
|
|
|
{ "TSIG", tsig_rdata, ALEN( tsig_rdata) }, /* - 250 */
|
|
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ NULL, NULL, 0 },
|
2014-09-02 15:31:50 -05:00
|
|
|
{ "MAILB", UNKNOWN_RDATA, 0 }, /* 253 - */
|
|
|
|
|
{ "MAILA", UNKNOWN_RDATA, 0 }, /* - 254 */
|
2014-01-30 10:04:43 -06:00
|
|
|
{ NULL, NULL, 0 },
|
|
|
|
|
{ "URI", uri_rdata, ALEN( uri_rdata) }, /* 256 - */
|
|
|
|
|
{ "CAA", caa_rdata, ALEN( caa_rdata) }, /* - 257 */
|
2014-09-02 15:31:50 -05:00
|
|
|
{ "TA", UNKNOWN_RDATA, 0 }, /* 32768 */
|
2014-01-30 10:04:43 -06:00
|
|
|
{ "DLV", dlv_rdata, ALEN( dlv_rdata) } /* 32769 */
|
|
|
|
|
};
|
|
|
|
|
|
2015-02-14 04:44:13 -06:00
|
|
|
const priv_getdns_rr_def *
|
|
|
|
|
priv_getdns_rr_def_lookup(uint16_t rr_type)
|
2014-01-30 10:04:43 -06:00
|
|
|
{
|
|
|
|
|
if (rr_type <= 257)
|
2015-02-14 04:44:13 -06:00
|
|
|
return &priv_getdns_rr_defs[rr_type];
|
2014-01-30 10:04:43 -06:00
|
|
|
else if (rr_type == 32768)
|
2015-02-14 04:44:13 -06:00
|
|
|
return &priv_getdns_rr_defs[258];
|
2014-01-30 10:04:43 -06:00
|
|
|
else if (rr_type == 32769)
|
2015-02-14 04:44:13 -06:00
|
|
|
return &priv_getdns_rr_defs[259];
|
|
|
|
|
return priv_getdns_rr_defs;
|
2014-01-30 10:04:43 -06:00
|
|
|
}
|
|
|
|
|
|
2014-01-30 17:16:34 -06:00
|
|
|
const char *
|
|
|
|
|
priv_getdns_rr_type_name(int rr_type)
|
|
|
|
|
{
|
2015-02-14 04:44:13 -06:00
|
|
|
return priv_getdns_rr_def_lookup(rr_type)->name;
|
2014-01-30 17:16:34 -06:00
|
|
|
}
|
|
|
|
|
|
2014-02-05 12:47:46 -06:00
|
|
|
/* list of txt records */
|
2014-01-30 16:38:55 -06:00
|
|
|
static getdns_return_t
|
2014-02-05 12:47:46 -06:00
|
|
|
priv_getdns_equip_dict_with_txt_rdfs(struct getdns_dict* rdata, ldns_rr* rr,
|
2015-02-14 04:44:13 -06:00
|
|
|
const priv_getdns_rr_def* def,
|
2014-02-05 12:47:46 -06:00
|
|
|
struct getdns_context* context) {
|
|
|
|
|
size_t i;
|
|
|
|
|
struct getdns_bindata bindata;
|
2014-02-06 13:12:49 -06:00
|
|
|
uint8_t buffer[LDNS_MAX_RDFLEN];
|
2014-02-05 12:47:46 -06:00
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
|
|
|
|
struct getdns_list* records = getdns_list_create_with_context(context);
|
|
|
|
|
if (!records) {
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < ldns_rr_rd_count(rr) && r == GETDNS_RETURN_GOOD; ++i) {
|
|
|
|
|
ldns_rdf* rdf = ldns_rr_rdf(rr, i);
|
|
|
|
|
int rdf_size = (int) ldns_rdf_size(rdf);
|
|
|
|
|
uint8_t* rdf_data = ldns_rdf_data(rdf);
|
|
|
|
|
if (rdf_size < 1) {
|
|
|
|
|
r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2014-02-06 13:12:49 -06:00
|
|
|
int txt_size = (int) rdf_data[0];
|
2014-02-05 12:47:46 -06:00
|
|
|
if (rdf_size < txt_size) {
|
|
|
|
|
r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2014-02-06 13:12:49 -06:00
|
|
|
bindata.size = txt_size + 1;
|
|
|
|
|
memcpy(buffer, rdf_data + 1, txt_size);
|
|
|
|
|
buffer[txt_size] = 0;
|
|
|
|
|
bindata.data = buffer;
|
2014-02-05 16:17:46 -06:00
|
|
|
|
2014-02-05 12:47:46 -06:00
|
|
|
r = getdns_list_set_bindata(records, i, &bindata);
|
|
|
|
|
}
|
2014-02-06 13:12:49 -06:00
|
|
|
if (r == GETDNS_RETURN_GOOD) {
|
2014-02-05 12:47:46 -06:00
|
|
|
r = getdns_dict_set_list(rdata, def->rdata[0].name, records);
|
|
|
|
|
}
|
2014-02-06 13:12:49 -06:00
|
|
|
getdns_list_destroy(records);
|
2014-02-05 12:47:46 -06:00
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-06 11:16:16 -06:00
|
|
|
/* heavily borrowed/copied from ldns 1.6.17 */
|
|
|
|
|
static
|
|
|
|
|
getdns_return_t getdns_rdf_hip_get_alg_hit_pk(ldns_rdf *rdf, uint8_t* alg,
|
|
|
|
|
struct getdns_bindata* hit,
|
|
|
|
|
struct getdns_bindata* pk)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *data;
|
|
|
|
|
size_t rdf_size;
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 11:16:16 -06:00
|
|
|
if ((rdf_size = ldns_rdf_size(rdf)) < 6) {
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
|
|
|
|
data = ldns_rdf_data(rdf);
|
|
|
|
|
hit->size = data[0];
|
|
|
|
|
*alg = data[1];
|
|
|
|
|
pk->size = ldns_read_uint16(data + 2);
|
|
|
|
|
hit->data = data + 4;
|
|
|
|
|
pk->data = data + 4 + hit->size;
|
|
|
|
|
if (hit->size == 0 || pk->size == 0 ||
|
|
|
|
|
rdf_size < (size_t) hit->size + pk->size + 4) {
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
|
|
|
|
return GETDNS_RETURN_GOOD;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-05 16:17:46 -06:00
|
|
|
static getdns_return_t
|
|
|
|
|
priv_getdns_equip_dict_with_hip_rdfs(struct getdns_dict* rdata, ldns_rr* rr,
|
2015-02-14 04:44:13 -06:00
|
|
|
const priv_getdns_rr_def* def,
|
2014-02-05 16:17:46 -06:00
|
|
|
struct getdns_context* context) {
|
|
|
|
|
uint8_t alg;
|
|
|
|
|
getdns_return_t r;
|
|
|
|
|
struct getdns_bindata hit_data;
|
|
|
|
|
struct getdns_bindata key_data;
|
|
|
|
|
/* first rdf contains the key data */
|
|
|
|
|
ldns_rdf* rdf = ldns_rr_rdf(rr, 0);
|
|
|
|
|
/* ask LDNS to parse it for us */
|
2014-02-06 11:16:16 -06:00
|
|
|
r = getdns_rdf_hip_get_alg_hit_pk(rdf, &alg, &hit_data, &key_data);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD) {
|
2014-02-05 16:17:46 -06:00
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
2014-02-06 10:10:09 -06:00
|
|
|
|
2014-02-05 16:17:46 -06:00
|
|
|
r = getdns_dict_set_int(rdata, def->rdata[0].name, alg);
|
|
|
|
|
r |= getdns_dict_set_bindata(rdata, def->rdata[1].name, &hit_data);
|
|
|
|
|
r |= getdns_dict_set_bindata(rdata, def->rdata[2].name, &key_data);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD) {
|
2014-02-20 14:42:10 -06:00
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
2014-02-05 16:17:46 -06:00
|
|
|
}
|
2014-02-06 10:10:09 -06:00
|
|
|
|
2014-02-05 16:17:46 -06:00
|
|
|
if (ldns_rr_rd_count(rr) > 1) {
|
|
|
|
|
/* servers */
|
|
|
|
|
size_t i;
|
|
|
|
|
struct getdns_bindata server_data;
|
|
|
|
|
struct getdns_list* servers = getdns_list_create_with_context(context);
|
|
|
|
|
if (!servers) {
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
}
|
|
|
|
|
for (i = 1; i < ldns_rr_rd_count(rr) && r == GETDNS_RETURN_GOOD; ++i) {
|
|
|
|
|
ldns_rdf* server_rdf = ldns_rr_rdf(rr, i);
|
2014-02-06 10:10:09 -06:00
|
|
|
server_data.size = ldns_rdf_size(server_rdf);
|
|
|
|
|
server_data.data = ldns_rdf_data(server_rdf);
|
2014-02-05 16:17:46 -06:00
|
|
|
r = getdns_list_set_bindata(servers, i - 1, &server_data);
|
|
|
|
|
}
|
2014-02-06 13:12:49 -06:00
|
|
|
if (r == GETDNS_RETURN_GOOD) {
|
2014-02-05 16:17:46 -06:00
|
|
|
r = getdns_dict_set_list(rdata, def->rdata[3].name, servers);
|
|
|
|
|
}
|
2014-02-06 13:12:49 -06:00
|
|
|
/* always clean up */
|
|
|
|
|
getdns_list_destroy(servers);
|
2014-02-20 14:42:10 -06:00
|
|
|
if (r != GETDNS_RETURN_GOOD) {
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
2014-02-05 16:17:46 -06:00
|
|
|
}
|
2014-02-06 10:10:09 -06:00
|
|
|
|
2014-02-05 16:17:46 -06:00
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-06 13:12:49 -06:00
|
|
|
static getdns_return_t
|
2015-02-14 04:44:13 -06:00
|
|
|
priv_append_apl_record(getdns_list* records, ldns_rdf* rdf,
|
|
|
|
|
const priv_getdns_rr_def* def, getdns_context* context)
|
|
|
|
|
{
|
2014-02-06 13:12:49 -06:00
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
|
|
|
|
uint8_t* data;
|
|
|
|
|
size_t size;
|
|
|
|
|
uint16_t family;
|
|
|
|
|
uint8_t prefix;
|
|
|
|
|
uint8_t negation;
|
|
|
|
|
size_t addr_len;
|
|
|
|
|
size_t pos = 0;
|
|
|
|
|
size_t index = 0;
|
|
|
|
|
struct getdns_bindata addr_data;
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 13:12:49 -06:00
|
|
|
if (ldns_rdf_get_type(rdf) != LDNS_RDF_TYPE_APL) {
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
|
|
|
|
getdns_list_get_length(records, &index);
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 13:12:49 -06:00
|
|
|
data = ldns_rdf_data(rdf);
|
|
|
|
|
size = ldns_rdf_size(rdf);
|
|
|
|
|
if (size < 4) {
|
|
|
|
|
/* not enough for the fam, prefix, n, and data len */
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
|
|
|
|
while (pos < size && r == GETDNS_RETURN_GOOD) {
|
|
|
|
|
struct getdns_dict* apl_dict;
|
|
|
|
|
family = ldns_read_uint16(data + pos);
|
|
|
|
|
prefix = data[pos + 2];
|
|
|
|
|
negation = (data[pos + 3] & 0x80) > 1 ? 1 : 0;
|
|
|
|
|
addr_len = data[pos + 3] & 0x7F;
|
|
|
|
|
if (size < 4 + addr_len) {
|
|
|
|
|
/* not enough.. */
|
|
|
|
|
return GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
}
|
|
|
|
|
addr_data.size = addr_len;
|
|
|
|
|
addr_data.data = data + 4 + pos;
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 13:12:49 -06:00
|
|
|
/* add to a dictionary */
|
|
|
|
|
apl_dict = getdns_dict_create_with_context(context);
|
|
|
|
|
if (!apl_dict) {
|
|
|
|
|
/* memory fail */
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
}
|
|
|
|
|
r |= getdns_dict_set_int(apl_dict, def->rdata[1].name, family);
|
|
|
|
|
r |= getdns_dict_set_int(apl_dict, def->rdata[2].name, prefix);
|
|
|
|
|
r |= getdns_dict_set_int(apl_dict, def->rdata[3].name, negation);
|
|
|
|
|
r |= getdns_dict_set_bindata(apl_dict, def->rdata[4].name, &addr_data);
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 13:12:49 -06:00
|
|
|
if (r == GETDNS_RETURN_GOOD) {
|
|
|
|
|
r = getdns_list_set_dict(records, index, apl_dict);
|
|
|
|
|
}
|
|
|
|
|
pos += addr_data.size + 4;
|
|
|
|
|
++index;
|
|
|
|
|
/* always clean up */
|
|
|
|
|
getdns_dict_destroy(apl_dict);
|
|
|
|
|
}
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 13:12:49 -06:00
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-06 11:16:16 -06:00
|
|
|
static getdns_return_t
|
|
|
|
|
priv_getdns_equip_dict_with_apl_rdfs(struct getdns_dict* rdata, ldns_rr* rr,
|
2015-02-14 04:44:13 -06:00
|
|
|
const priv_getdns_rr_def* def,
|
2014-02-06 11:16:16 -06:00
|
|
|
struct getdns_context* context) {
|
2014-02-06 13:12:49 -06:00
|
|
|
size_t i;
|
|
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
|
|
|
|
struct getdns_list* records = getdns_list_create_with_context(context);
|
|
|
|
|
if (!records) {
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < ldns_rr_rd_count(rr) && r == GETDNS_RETURN_GOOD; ++i) {
|
|
|
|
|
r = priv_append_apl_record(records, ldns_rr_rdf(rr, i),
|
|
|
|
|
def, context);
|
|
|
|
|
}
|
|
|
|
|
if (r == GETDNS_RETURN_GOOD) {
|
|
|
|
|
getdns_dict_set_list(rdata, def->rdata[0].name, records);
|
|
|
|
|
}
|
|
|
|
|
getdns_list_destroy(records);
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 11:16:16 -06:00
|
|
|
return GETDNS_RETURN_GOOD;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
priv_getdns_equip_dict_with_spf_rdfs(struct getdns_dict* rdata, ldns_rr* rr,
|
2015-02-14 04:44:13 -06:00
|
|
|
const priv_getdns_rr_def* def,
|
2014-02-06 11:16:16 -06:00
|
|
|
struct getdns_context* context) {
|
2014-02-06 13:12:49 -06:00
|
|
|
size_t i;
|
|
|
|
|
struct getdns_bindata bindata;
|
|
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
|
|
|
|
int num_copied = 0;
|
|
|
|
|
bindata.size = 0;
|
|
|
|
|
/* one giant bindata */
|
|
|
|
|
/* validate and calculate size */
|
|
|
|
|
for (i = 0; i < ldns_rr_rd_count(rr) && r == GETDNS_RETURN_GOOD; ++i) {
|
|
|
|
|
ldns_rdf* rdf = ldns_rr_rdf(rr, i);
|
|
|
|
|
int rdf_size = (int) ldns_rdf_size(rdf);
|
|
|
|
|
uint8_t* rdf_data = ldns_rdf_data(rdf);
|
|
|
|
|
if (rdf_size < 1) {
|
|
|
|
|
r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
/* txt size without null byte */
|
|
|
|
|
int txt_size = (int) rdf_data[0];
|
|
|
|
|
if (rdf_size < txt_size) {
|
|
|
|
|
r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
bindata.size += txt_size;
|
2014-02-05 16:17:46 -06:00
|
|
|
}
|
2014-02-06 13:12:49 -06:00
|
|
|
/* add one for the null byte */
|
|
|
|
|
bindata.size++;
|
2014-02-12 15:39:27 -06:00
|
|
|
|
2014-02-06 13:12:49 -06:00
|
|
|
if (r != GETDNS_RETURN_GOOD) {
|
|
|
|
|
/* validations failed */
|
|
|
|
|
return r;
|
|
|
|
|
}
|
2014-02-19 09:56:00 -06:00
|
|
|
bindata.data = context
|
|
|
|
|
? GETDNS_XMALLOC(context->my_mf, uint8_t, bindata.size)
|
|
|
|
|
: malloc(bindata.size);
|
2014-02-06 13:12:49 -06:00
|
|
|
if (!bindata.data) {
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
}
|
|
|
|
|
/* copy in */
|
|
|
|
|
for (i = 0; i < ldns_rr_rd_count(rr) && r == GETDNS_RETURN_GOOD; ++i) {
|
|
|
|
|
ldns_rdf* rdf = ldns_rr_rdf(rr, i);
|
|
|
|
|
/* safe to trust these now */
|
|
|
|
|
uint8_t* rdf_data = ldns_rdf_data(rdf);
|
|
|
|
|
int txt_size = (int) rdf_data[0];
|
|
|
|
|
memcpy(bindata.data + num_copied, rdf_data + 1, txt_size);
|
|
|
|
|
num_copied += txt_size;
|
|
|
|
|
}
|
|
|
|
|
bindata.data[num_copied] = 0;
|
|
|
|
|
r = getdns_dict_set_bindata(rdata, def->rdata[0].name, &bindata);
|
2014-02-19 09:56:00 -06:00
|
|
|
if (context)
|
|
|
|
|
GETDNS_FREE(context->my_mf, bindata.data);
|
|
|
|
|
else
|
|
|
|
|
free(bindata.data);
|
2014-02-05 16:17:46 -06:00
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-06 11:16:16 -06:00
|
|
|
|
2014-02-05 12:47:46 -06:00
|
|
|
static getdns_return_t
|
|
|
|
|
priv_getdns_equip_dict_with_rdfs(struct getdns_dict *rdata, ldns_rr *rr,
|
|
|
|
|
struct getdns_context* context)
|
2014-01-30 16:38:55 -06:00
|
|
|
{
|
|
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
2015-02-14 04:44:13 -06:00
|
|
|
const priv_getdns_rr_def *def;
|
2014-01-30 16:38:55 -06:00
|
|
|
struct getdns_bindata bindata;
|
|
|
|
|
size_t i;
|
|
|
|
|
|
2014-09-02 15:31:50 -05:00
|
|
|
struct getdns_bindata *rdata_raw;
|
|
|
|
|
const char *sptr;
|
|
|
|
|
char *dptr, tmpbuf[100];
|
|
|
|
|
|
2015-02-14 04:44:13 -06:00
|
|
|
uint8_t *rdf_data;
|
|
|
|
|
size_t rdf_size;
|
|
|
|
|
|
2014-01-30 16:38:55 -06:00
|
|
|
assert(rdata);
|
|
|
|
|
assert(rr);
|
|
|
|
|
|
2015-02-14 04:44:13 -06:00
|
|
|
def = priv_getdns_rr_def_lookup(ldns_rr_get_type(rr));
|
2014-02-05 12:47:46 -06:00
|
|
|
/* specialty handlers */
|
2014-02-06 11:16:16 -06:00
|
|
|
/* TODO: convert generic one into function w/ similar signature and store in the
|
|
|
|
|
* def? */
|
2014-02-05 12:47:46 -06:00
|
|
|
if (def->rdata == txt_rdata) {
|
|
|
|
|
return priv_getdns_equip_dict_with_txt_rdfs(rdata, rr, def, context);
|
2014-02-05 16:17:46 -06:00
|
|
|
} else if (def->rdata == hip_rdata) {
|
|
|
|
|
return priv_getdns_equip_dict_with_hip_rdfs(rdata, rr, def, context);
|
2014-02-06 11:16:16 -06:00
|
|
|
} else if (def->rdata == apl_rdata) {
|
|
|
|
|
return priv_getdns_equip_dict_with_apl_rdfs(rdata, rr, def, context);
|
|
|
|
|
} else if (def->rdata == spf_rdata) {
|
|
|
|
|
return priv_getdns_equip_dict_with_spf_rdfs(rdata, rr, def, context);
|
2014-09-02 15:31:50 -05:00
|
|
|
} else if (def->name &&
|
|
|
|
|
strlen(def->name) <= sizeof(tmpbuf) - 9 /* strlen("_unknown")+1 */ &&
|
|
|
|
|
(def->rdata == UNKNOWN_RDATA ||
|
|
|
|
|
ldns_rr_descriptor_field_type(
|
|
|
|
|
ldns_rr_descript(ldns_rr_get_type(rr)), 0) == LDNS_RDF_TYPE_UNKNOWN)) {
|
|
|
|
|
|
|
|
|
|
r = getdns_dict_get_bindata(rdata, "rdata_raw", &rdata_raw);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
return r;
|
|
|
|
|
|
|
|
|
|
sptr = def->name;
|
|
|
|
|
dptr = tmpbuf;
|
|
|
|
|
do *dptr++ = tolower(*sptr);
|
|
|
|
|
while (*sptr++); /* Including terminating '\0' */
|
|
|
|
|
|
|
|
|
|
return getdns_dict_set_bindata(
|
|
|
|
|
rdata, strcat(tmpbuf, "_unknown"), rdata_raw);
|
2014-02-05 12:47:46 -06:00
|
|
|
}
|
|
|
|
|
/* generic */
|
2014-08-21 07:25:42 -05:00
|
|
|
if (ldns_rr_rd_count(rr) != def->n_rdata_fields)
|
|
|
|
|
return r;
|
|
|
|
|
|
2015-02-14 04:44:13 -06:00
|
|
|
for (i = 0; !r && i < ldns_rr_rd_count(rr)
|
|
|
|
|
&& i < def->n_rdata_fields; i++) {
|
2014-01-30 16:38:55 -06:00
|
|
|
|
2015-02-14 04:44:13 -06:00
|
|
|
if (! (def->rdata[i].type & GETDNS_RDF_INTEGER)) {
|
|
|
|
|
bindata.size = ldns_rdf_size(ldns_rr_rdf(rr, i));
|
|
|
|
|
bindata.data = ldns_rdf_data(ldns_rr_rdf(rr, i));
|
|
|
|
|
r = getdns_dict_set_bindata(
|
|
|
|
|
rdata, (char*)def->rdata[i].name, &bindata);
|
|
|
|
|
continue;
|
2014-01-30 16:38:55 -06:00
|
|
|
}
|
2015-02-14 04:44:13 -06:00
|
|
|
rdf_size = ldns_rdf_size(ldns_rr_rdf(rr, i));
|
|
|
|
|
rdf_data = ldns_rdf_data(ldns_rr_rdf(rr, i));
|
|
|
|
|
r = getdns_dict_set_int(rdata, (char *)def->rdata[i].name,
|
|
|
|
|
rdf_size == 1 ? *rdf_data
|
|
|
|
|
: rdf_size == 2 ? ldns_read_uint16(rdf_data)
|
|
|
|
|
: rdf_size == 4 ? ldns_read_uint32(rdf_data) : -1);
|
2014-01-30 16:38:55 -06:00
|
|
|
}
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-30 10:04:43 -06:00
|
|
|
static getdns_return_t
|
|
|
|
|
priv_getdns_create_dict_from_rdfs(
|
|
|
|
|
struct getdns_context *context, ldns_rr *rr, struct getdns_dict** rdata)
|
|
|
|
|
{
|
|
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
|
|
|
|
struct getdns_bindata rdata_raw;
|
|
|
|
|
uint8_t *data_ptr;
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
assert(rr);
|
2014-01-30 17:32:39 -06:00
|
|
|
assert(rdata);
|
2014-01-30 10:04:43 -06:00
|
|
|
|
|
|
|
|
*rdata = getdns_dict_create_with_context(context);
|
|
|
|
|
if (! *rdata)
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
do { /* break on error (to cleanup *rdata) */
|
|
|
|
|
|
|
|
|
|
/* Count and reserve "raw" rdata space */
|
|
|
|
|
rdata_raw.size = 0;
|
|
|
|
|
for (i = 0; i < ldns_rr_rd_count(rr); i++)
|
|
|
|
|
rdata_raw.size += ldns_rdf_size(ldns_rr_rdf(rr, i));
|
2014-02-19 09:56:00 -06:00
|
|
|
rdata_raw.data = context
|
|
|
|
|
? GETDNS_XMALLOC(context->mf, uint8_t, rdata_raw.size)
|
|
|
|
|
: malloc(rdata_raw.size);
|
2014-01-30 10:04:43 -06:00
|
|
|
if (! rdata_raw.data) {
|
|
|
|
|
r = GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
/* Copy rdata fields to rdata space */
|
|
|
|
|
data_ptr = rdata_raw.data;
|
|
|
|
|
for (i = 0; i < ldns_rr_rd_count(rr); i++) {
|
|
|
|
|
(void) memcpy(data_ptr,
|
|
|
|
|
ldns_rdf_data(ldns_rr_rdf(rr, i)),
|
|
|
|
|
ldns_rdf_size(ldns_rr_rdf(rr, i)));
|
|
|
|
|
data_ptr += ldns_rdf_size(ldns_rr_rdf(rr, i));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set "rdata_raw" attribute" */
|
|
|
|
|
r = getdns_dict_set_bindata(*rdata, "rdata_raw", &rdata_raw);
|
2014-02-19 09:56:00 -06:00
|
|
|
if (context)
|
|
|
|
|
GETDNS_FREE(context->mf, rdata_raw.data);
|
|
|
|
|
else
|
|
|
|
|
free(rdata_raw.data);
|
2014-01-30 10:04:43 -06:00
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
|
2014-01-30 16:38:55 -06:00
|
|
|
/* Now set the RR type specific attributes */
|
2014-02-05 12:47:46 -06:00
|
|
|
r = priv_getdns_equip_dict_with_rdfs(*rdata, rr, context);
|
2014-01-30 16:38:55 -06:00
|
|
|
if (r == GETDNS_RETURN_GOOD)
|
|
|
|
|
return r;
|
2014-01-30 10:04:43 -06:00
|
|
|
} while(0);
|
|
|
|
|
getdns_dict_destroy(*rdata);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
getdns_return_t
|
|
|
|
|
priv_getdns_create_dict_from_rr(
|
|
|
|
|
struct getdns_context *context, ldns_rr *rr, struct getdns_dict** rr_dict)
|
|
|
|
|
{
|
|
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
|
|
|
|
struct getdns_bindata name;
|
|
|
|
|
struct getdns_dict *rdata;
|
|
|
|
|
|
|
|
|
|
assert(rr);
|
2014-01-30 17:32:39 -06:00
|
|
|
assert(rr_dict);
|
2014-01-30 10:04:43 -06:00
|
|
|
|
|
|
|
|
*rr_dict = getdns_dict_create_with_context(context);
|
|
|
|
|
if (! *rr_dict)
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
do { /* break on error (to cleanup *rr_dict) */
|
|
|
|
|
r = getdns_dict_set_int(*rr_dict,
|
|
|
|
|
"type", ldns_rr_get_type(rr));
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
r = getdns_dict_set_int(*rr_dict,
|
|
|
|
|
"class", ldns_rr_get_class(rr));
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
r = getdns_dict_set_int(*rr_dict, "ttl", ldns_rr_ttl(rr));
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* "name" attribute.
|
|
|
|
|
* ldns_rr_owner(rr) is already uncompressed!
|
|
|
|
|
*/
|
|
|
|
|
name.size = ldns_rdf_size(ldns_rr_owner(rr));
|
|
|
|
|
name.data = ldns_rdf_data(ldns_rr_owner(rr));
|
|
|
|
|
r = getdns_dict_set_bindata(*rr_dict, "name", &name);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* The "rdata" dict... copies of copies of copies :( */
|
|
|
|
|
r = priv_getdns_create_dict_from_rdfs(context, rr, &rdata);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
r = getdns_dict_set_dict(*rr_dict, "rdata", rdata);
|
2014-02-03 15:36:42 -06:00
|
|
|
getdns_dict_destroy(rdata);
|
2014-01-30 10:04:43 -06:00
|
|
|
if (r == GETDNS_RETURN_GOOD)
|
|
|
|
|
return r;
|
|
|
|
|
} while (0);
|
|
|
|
|
getdns_dict_destroy(*rr_dict);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
2014-01-30 17:32:39 -06:00
|
|
|
|
2014-02-06 15:09:00 -06:00
|
|
|
static getdns_return_t priv_getdns_construct_wire_rdata_from_rdata(
|
|
|
|
|
struct getdns_dict *rdata, uint32_t rr_type,
|
|
|
|
|
uint8_t **wire, size_t *wire_size)
|
|
|
|
|
{
|
|
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
|
|
|
|
const ldns_rr_descriptor *rr_descript;
|
2015-02-14 04:44:13 -06:00
|
|
|
const priv_getdns_rr_def *def;
|
2014-02-06 15:09:00 -06:00
|
|
|
size_t i, size;
|
|
|
|
|
struct getdns_bindata *bindata;
|
|
|
|
|
uint32_t value;
|
|
|
|
|
uint8_t *ptr;
|
|
|
|
|
|
|
|
|
|
assert(rdata);
|
|
|
|
|
assert(wire);
|
|
|
|
|
assert(wire_size);
|
|
|
|
|
|
2015-02-14 04:44:13 -06:00
|
|
|
def = priv_getdns_rr_def_lookup(rr_type);
|
2014-02-06 15:09:00 -06:00
|
|
|
rr_descript = ldns_rr_descript(rr_type);
|
|
|
|
|
|
|
|
|
|
/* First calculate needed size */
|
|
|
|
|
size = 0;
|
2015-02-14 04:44:13 -06:00
|
|
|
for (i = 0; !r && i < def->n_rdata_fields; i++) {
|
|
|
|
|
if (def->rdata[i].type & GETDNS_RDF_BINDATA)
|
|
|
|
|
if ((r = getdns_dict_get_bindata(rdata,
|
|
|
|
|
def->rdata[i].name, &bindata)))
|
2014-02-06 15:09:00 -06:00
|
|
|
break;
|
2015-02-14 04:44:13 -06:00
|
|
|
else {
|
|
|
|
|
size += bindata->size;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if (!(def->rdata[i].type & GETDNS_RDF_INTEGER)) {
|
|
|
|
|
r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
switch (ldns_rr_descriptor_field_type(rr_descript, i)) {
|
|
|
|
|
|
|
|
|
|
case LDNS_RDF_TYPE_CLASS:
|
|
|
|
|
case LDNS_RDF_TYPE_ALG :
|
|
|
|
|
case LDNS_RDF_TYPE_INT8 : size += 1;
|
|
|
|
|
break;
|
|
|
|
|
case LDNS_RDF_TYPE_TYPE :
|
|
|
|
|
case LDNS_RDF_TYPE_CERT_ALG:
|
|
|
|
|
case LDNS_RDF_TYPE_INT16: size += 2;
|
|
|
|
|
break;
|
|
|
|
|
case LDNS_RDF_TYPE_TIME :
|
|
|
|
|
case LDNS_RDF_TYPE_PERIOD:
|
|
|
|
|
case LDNS_RDF_TYPE_INT32: size += 4;
|
|
|
|
|
break;
|
|
|
|
|
default: r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
break;
|
2014-02-06 15:09:00 -06:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*wire_size = size + 2;
|
|
|
|
|
*wire = ptr = GETDNS_XMALLOC(rdata->mf, uint8_t, size + 2);
|
|
|
|
|
if (! ptr)
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
|
|
|
|
|
ptr[0] = (uint8_t) (size >> 8) & 0xff;
|
|
|
|
|
ptr[1] = (uint8_t) size & 0xff;
|
|
|
|
|
ptr += 2;
|
2015-02-14 04:44:13 -06:00
|
|
|
for (i = 0; !r && i < def->n_rdata_fields; i++) {
|
|
|
|
|
if (def->rdata[i].type & GETDNS_RDF_BINDATA)
|
|
|
|
|
if ((r = getdns_dict_get_bindata(rdata,
|
|
|
|
|
def->rdata[i].name, &bindata)))
|
|
|
|
|
break;
|
|
|
|
|
else {
|
2014-02-06 15:09:00 -06:00
|
|
|
(void) memcpy(ptr, bindata->data,
|
|
|
|
|
bindata->size);
|
|
|
|
|
ptr += bindata->size;
|
2015-02-14 04:44:13 -06:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if (!(def->rdata[i].type & GETDNS_RDF_INTEGER)) {
|
|
|
|
|
r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if ((r = getdns_dict_get_int(
|
|
|
|
|
rdata, def->rdata[i].name, &value)))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
switch (ldns_rr_descriptor_field_type(rr_descript, i)) {
|
|
|
|
|
|
|
|
|
|
case LDNS_RDF_TYPE_CLASS:
|
|
|
|
|
case LDNS_RDF_TYPE_ALG :
|
|
|
|
|
case LDNS_RDF_TYPE_INT8 : ptr[0] = (uint8_t) value & 0xff;
|
|
|
|
|
ptr += 1;
|
|
|
|
|
break;
|
|
|
|
|
case LDNS_RDF_TYPE_TYPE :
|
|
|
|
|
case LDNS_RDF_TYPE_CERT_ALG:
|
|
|
|
|
case LDNS_RDF_TYPE_INT16: ptr[0] = (uint8_t)(value>> 8) & 0xff;
|
|
|
|
|
ptr[1] = (uint8_t) value & 0xff;
|
|
|
|
|
ptr += 2;
|
|
|
|
|
break;
|
|
|
|
|
case LDNS_RDF_TYPE_TIME :
|
|
|
|
|
case LDNS_RDF_TYPE_PERIOD:
|
|
|
|
|
case LDNS_RDF_TYPE_INT32: ptr[0] = (uint8_t)(value>>24) & 0xff;
|
|
|
|
|
ptr[1] = (uint8_t)(value>>16) & 0xff;
|
|
|
|
|
ptr[2] = (uint8_t)(value>>8 ) & 0xff;
|
|
|
|
|
ptr[3] = (uint8_t) value & 0xff;
|
|
|
|
|
ptr += 4;
|
|
|
|
|
break;
|
|
|
|
|
default: r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
break;
|
2014-02-06 15:09:00 -06:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (r)
|
|
|
|
|
GETDNS_FREE(rdata->mf, ptr);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static getdns_return_t
|
|
|
|
|
priv_getdns_dict_get_raw_rdata(struct getdns_dict *rdata,
|
|
|
|
|
uint8_t **wire, size_t *wire_size)
|
|
|
|
|
{
|
|
|
|
|
getdns_return_t r;
|
|
|
|
|
struct getdns_bindata *bindata;
|
|
|
|
|
|
|
|
|
|
if ((r = getdns_dict_get_bindata(rdata, "rdata_raw", &bindata)))
|
|
|
|
|
return r;
|
|
|
|
|
|
|
|
|
|
*wire_size = bindata->size + 2;
|
|
|
|
|
*wire = GETDNS_XMALLOC(rdata->mf, uint8_t, *wire_size);
|
|
|
|
|
if (! *wire)
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
|
|
|
|
|
(*wire)[0] = (uint8_t) (bindata->size >> 8) & 0xff;
|
|
|
|
|
(*wire)[1] = (uint8_t) bindata->size & 0xff;
|
|
|
|
|
|
|
|
|
|
(void) memcpy(*wire + 2, bindata->data, bindata->size);
|
|
|
|
|
return GETDNS_RETURN_GOOD;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-03 17:10:28 -06:00
|
|
|
getdns_return_t
|
|
|
|
|
priv_getdns_create_rr_from_dict(struct getdns_dict *rr_dict, ldns_rr **rr)
|
|
|
|
|
{
|
|
|
|
|
getdns_return_t r = GETDNS_RETURN_GOOD;
|
2014-02-06 15:09:00 -06:00
|
|
|
struct getdns_bindata *name;
|
2014-02-03 17:10:28 -06:00
|
|
|
struct getdns_dict *rdata;
|
|
|
|
|
uint32_t rr_type;
|
|
|
|
|
ldns_rdf *owner;
|
|
|
|
|
ldns_status s;
|
2014-02-06 15:09:00 -06:00
|
|
|
size_t pos;
|
|
|
|
|
uint8_t *wire;
|
|
|
|
|
size_t wire_size;
|
2014-02-03 17:10:28 -06:00
|
|
|
|
|
|
|
|
assert(rr_dict);
|
|
|
|
|
assert(rr);
|
|
|
|
|
|
|
|
|
|
*rr = ldns_rr_new();
|
|
|
|
|
if (! *rr)
|
|
|
|
|
return GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
do {
|
|
|
|
|
r = getdns_dict_get_bindata(rr_dict, "name", &name);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
2014-02-10 08:34:18 -06:00
|
|
|
owner = ldns_rdf_new_frm_data(
|
2014-02-03 17:10:28 -06:00
|
|
|
LDNS_RDF_TYPE_DNAME, name->size, name->data);
|
|
|
|
|
if (! owner) {
|
|
|
|
|
r = GETDNS_RETURN_MEMORY_ERROR;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
ldns_rr_set_owner(*rr, owner);
|
|
|
|
|
|
|
|
|
|
r = getdns_dict_get_int(rr_dict, "type", &rr_type);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
ldns_rr_set_type(*rr, rr_type);
|
|
|
|
|
|
|
|
|
|
r = getdns_dict_get_dict(rr_dict, "rdata", &rdata);
|
|
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
|
|
|
|
|
2014-02-06 15:09:00 -06:00
|
|
|
r = priv_getdns_dict_get_raw_rdata(rdata, &wire, &wire_size);
|
|
|
|
|
if (r == GETDNS_RETURN_NO_SUCH_DICT_NAME) {
|
|
|
|
|
r = priv_getdns_construct_wire_rdata_from_rdata(
|
|
|
|
|
rdata, rr_type, &wire, &wire_size);
|
|
|
|
|
}
|
2014-02-03 17:10:28 -06:00
|
|
|
if (r != GETDNS_RETURN_GOOD)
|
|
|
|
|
break;
|
2014-02-06 15:09:00 -06:00
|
|
|
pos = 0;
|
|
|
|
|
s = ldns_wire2rdf(*rr, wire, wire_size, &pos);
|
|
|
|
|
GETDNS_FREE(rr_dict->mf, wire);
|
2014-02-03 17:10:28 -06:00
|
|
|
if (s == LDNS_STATUS_OK)
|
|
|
|
|
return r;
|
|
|
|
|
r = GETDNS_RETURN_GENERIC_ERROR;
|
|
|
|
|
} while (0);
|
|
|
|
|
ldns_rr_free(*rr);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
