/*
 * dns.c -- DNS definitions.
 *
 * Copyright (c) 2001-2006, NLnet Labs. All rights reserved.
 *
 * See LICENSE for the license.
 *
 */

#include "config.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <netdb.h>
#include <string.h>
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif

#include "dns.h"
#include "rdata.h"

/* Taken from RFC 1035, section 3.2.4.  */
static lookup_table_type dns_rrclasses[] = {
	{ CLASS_IN, "IN" },	/* the Internet */
	{ CLASS_CS, "CS" },	/* the CSNET class (Obsolete) */
	{ CLASS_CH, "CH" },	/* the CHAOS class */
	{ CLASS_HS, "HS" },	/* Hesiod */
	{ 0, NULL }
};

/* For a standard field, it is not optional, has no rdata field functions. */
#define FIELD(name, size) { name, 0 /* is_optional */, size, NULL /* calc_len_func */, NULL /* calc_len_uncompressed_wire_func */ }

/* For a field entry with all values, for optional fields, or with defined
 * rdata field functions. */
#define FIELD_ENTRY(name, is_optional, size, calc_len_func, cal_len_uncompressed_wire_func ) { name, is_optional, size, calc_len_func, cal_len_uncompressed_wire_func }

static const struct nsd_rdata_descriptor generic_rdata_fields[] = {
	FIELD("", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor a_rdata_fields[] = {
	FIELD("address", 4)
};

static const struct nsd_rdata_descriptor ns_rdata_fields[] = {
	FIELD("host", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor md_rdata_fields[] = {
	FIELD("madname", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor mf_rdata_fields[] = {
	FIELD("madname", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor cname_rdata_fields[] = {
	FIELD("host", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor soa_rdata_fields[] = {
	FIELD("primary", RDATA_COMPRESSED_DNAME),
	FIELD("mailbox", RDATA_COMPRESSED_DNAME),
	FIELD("serial", 4),
	FIELD("refresh", 4),
	FIELD("retry", 4),
	FIELD("expire", 4),
	FIELD("minimum", 4)
};

static const struct nsd_rdata_descriptor mb_rdata_fields[] = {
	FIELD("madname", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor mg_rdata_fields[] = {
	FIELD("mgmname", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor mr_rdata_fields[] = {
	FIELD("newname", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor wks_rdata_fields[] = {
	FIELD("address", 4),
	FIELD("protocol", 1),
	FIELD("bitmap", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor ptr_rdata_fields[] = {
	FIELD("ptrdname", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor hinfo_rdata_fields[] = {
	FIELD("cpu", RDATA_STRING),
	FIELD("os", RDATA_STRING)
};

static const struct nsd_rdata_descriptor minfo_rdata_fields[] = {
	FIELD("rmailbx", RDATA_COMPRESSED_DNAME),
	FIELD("emailbx", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor mx_rdata_fields[] = {
	FIELD("priority", 2),
	FIELD("hostname", RDATA_COMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor txt_rdata_fields[] = {
	FIELD("text", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor rp_rdata_fields[] = {
	FIELD("mailbox", RDATA_UNCOMPRESSED_DNAME),
	FIELD("text", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor afsdb_rdata_fields[] = {
	FIELD("subtype", 2),
	FIELD("hostname", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor x25_rdata_fields[] = {
	FIELD("address", RDATA_STRING)
};

static const struct nsd_rdata_descriptor isdn_rdata_fields[] = {
	FIELD("address", RDATA_STRING),
	FIELD_ENTRY("subaddress", 1, RDATA_STRING, NULL, NULL)
};

static const struct nsd_rdata_descriptor rt_rdata_fields[] = {
	FIELD("preference", 2),
	FIELD("hostname", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor nsap_rdata_fields[] = {
	FIELD("address", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor nsap_ptr_rdata_fields[] = {
	FIELD("hostname", RDATA_STRING)
};

static const struct nsd_rdata_descriptor sig_rdata_fields[] = {
	FIELD("sigtype", 2),
	FIELD("algorithm", 1),
	FIELD("labels", 1),
	FIELD("origttl", 4),
	FIELD("expire", 4),
	FIELD("inception", 4),
	FIELD("keytag", 2),
	FIELD("signer", RDATA_LITERAL_DNAME),
	FIELD("signature", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor key_rdata_fields[] = {
	FIELD("flags", 2),
	FIELD("protocol", 1),
	FIELD("algorithm", 1),
	FIELD("publickey", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor px_rdata_fields[] = {
	FIELD("preference", 2),
	FIELD("map822", RDATA_UNCOMPRESSED_DNAME),
	FIELD("mapx400", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor gpos_rdata_fields[] = {
	FIELD("latitude", RDATA_STRING),
	FIELD("longitude", RDATA_STRING),
	FIELD("altitude", RDATA_STRING)
};

static const struct nsd_rdata_descriptor aaaa_rdata_fields[] = {
	FIELD("address", 16)
};

static const struct nsd_rdata_descriptor loc_rdata_fields[] = {
	FIELD("version", 1),
	FIELD("size", 1),
	FIELD("horizontal precision", 1),
	FIELD("vertical precision", 1),
	FIELD("latitude", 4),
	FIELD("longitude", 4),
	FIELD("altitude", 4),
};

static const struct nsd_rdata_descriptor nxt_rdata_fields[] = {
	FIELD("next domain name", RDATA_UNCOMPRESSED_DNAME),
	FIELD("type bit map", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor eid_rdata_fields[] = {
	FIELD("end point identifier", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor nimloc_rdata_fields[] = {
	FIELD("nimrod locator", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor srv_rdata_fields[] = {
	FIELD("priority", 2),
	FIELD("weight", 2),
	FIELD("port", 2),
	FIELD("target", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor atma_rdata_fields[] = {
	FIELD("address", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor naptr_rdata_fields[] = {
	FIELD("order", 2),
	FIELD("preference", 2),
	FIELD("flags", RDATA_STRING),
	FIELD("services", RDATA_STRING),
	FIELD("regex", RDATA_STRING),
	FIELD("replacement", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor kx_rdata_fields[] = {
	FIELD("preference", 2),
	FIELD("exchanger", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor cert_rdata_fields[] = {
	FIELD("type", 2),
	FIELD("key tag", 2),
	FIELD("algorithm", 1),
	FIELD("certificate", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor a6_rdata_fields[] = {
	FIELD("address", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor dname_rdata_fields[] = {
	FIELD("source", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor sink_rdata_fields[] = {
	FIELD("coding", 1),
	FIELD("subcoding", 1),
	FIELD("data", RDATA_REMAINDER),
};

static const struct nsd_rdata_descriptor apl_rdata_fields[] = {
	FIELD_ENTRY("prefix", 1, RDATA_REMAINDER, NULL, NULL)
};

static const struct nsd_rdata_descriptor ds_rdata_fields[] = {
	FIELD("keytag", 2),
	FIELD("algorithm", 1),
	FIELD("digtype", 1),
	FIELD("digest", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor sshfp_rdata_fields[] = {
	FIELD("algorithm", 1),
	FIELD("ftype", 1),
	FIELD("fingerprint", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor ipseckey_rdata_fields[] = {
	FIELD("precedence", 1),
	FIELD("gateway type", 1),
	FIELD("algorithm", 1),
	FIELD_ENTRY("gateway", 0, RDATA_IPSECGATEWAY,
		ipseckey_gateway_length, ipseckey_gateway_length),
	FIELD_ENTRY("public key", 1, RDATA_REMAINDER, NULL, NULL)
};

static const struct nsd_rdata_descriptor rrsig_rdata_fields[] = {
	FIELD("rrtype", 2),
	FIELD("algorithm", 1),
	FIELD("labels", 1),
	FIELD("origttl", 4),
	FIELD("expire", 4),
	FIELD("inception", 4),
	FIELD("keytag", 2),
	FIELD("signer", RDATA_LITERAL_DNAME),
	FIELD("signature", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor nsec_rdata_fields[] = {
	FIELD("next", RDATA_LITERAL_DNAME),
	FIELD("types", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor dnskey_rdata_fields[] = {
	FIELD("flags", 2),
	FIELD("protocol", 1),
	FIELD("algorithm", 1),
	FIELD("publickey", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor dhcid_rdata_fields[] = {
	FIELD("dhcpinfo", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor nsec3_rdata_fields[] = {
	FIELD("algorithm", 1),
	FIELD("flags", 1),
	FIELD("iterations", 2),
	FIELD("salt", RDATA_BINARY),
	FIELD("next", RDATA_BINARY),
	FIELD("types", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor nsec3param_rdata_fields[] = {
	FIELD("algorithm", 1),
	FIELD("flags", 1),
	FIELD("iterations", 2),
	FIELD("salt", RDATA_BINARY)
};

static const struct nsd_rdata_descriptor tlsa_rdata_fields[] = {
	FIELD("usage", 1),
	FIELD("selector", 1),
	FIELD("matching type", 1),
	FIELD("certificate association data", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor smimea_rdata_fields[] = {
	FIELD("usage", 1),
	FIELD("selector", 1),
	FIELD("matching type", 1),
	FIELD("certificate association data", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor hip_rdata_fields[] = {
	FIELD("hip", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor ninfo_rdata_fields[] = {
	FIELD("text", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor rkey_rdata_fields[] = {
	FIELD("flags", 2),
	FIELD("protocol", 1),
	FIELD("algorithm", 1),
	FIELD("publickey", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor talink_rdata_fields[] = {
	FIELD("start or previous", RDATA_LITERAL_DNAME),
	FIELD("end or next", RDATA_LITERAL_DNAME)
};

static const struct nsd_rdata_descriptor cds_rdata_fields[] = {
	FIELD("keytag", 2),
	FIELD("algorithm", 1),
	FIELD("digtype", 1),
	FIELD("digest", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor cdnskey_rdata_fields[] = {
	FIELD("flags", 2),
	FIELD("protocol", 1),
	FIELD("algorithm", 1),
	FIELD("publickey", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor openpgpkey_rdata_fields[] = {
	FIELD("key", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor csync_rdata_fields[] = {
	FIELD("serial", 4),
	FIELD("flags", 2),
	FIELD("types", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor zonemd_rdata_fields[] = {
	FIELD("serial", 4),
	FIELD("scheme", 1),
	FIELD("algorithm", 1),
	FIELD("digest", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor svcb_rdata_fields[] = {
	FIELD("priority", 2),
	FIELD("target", RDATA_UNCOMPRESSED_DNAME),
	FIELD("params", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor https_rdata_fields[] = {
	FIELD("priority", 2),
	FIELD("target", RDATA_UNCOMPRESSED_DNAME),
	FIELD("params", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor dsync_rdata_fields[] = {
	FIELD("rrtype", 2),
	FIELD("scheme", 1),
	FIELD("port", 2),
	FIELD("target", RDATA_LITERAL_DNAME)
};

static const struct nsd_rdata_descriptor spf_rdata_fields[] = {
	FIELD("text", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor nid_rdata_fields[] = {
	FIELD("nid", 2),
	FIELD("locator", 8)
};

static const struct nsd_rdata_descriptor l32_rdata_fields[] = {
	FIELD("preference", 2),
	FIELD("locator", 4)
};

static const struct nsd_rdata_descriptor l64_rdata_fields[] = {
	FIELD("preference", 2),
	FIELD("locator", 8)
};

static const struct nsd_rdata_descriptor lp_rdata_fields[] = {
	FIELD("preference", 2),
	FIELD("pointer", RDATA_UNCOMPRESSED_DNAME)
};

static const struct nsd_rdata_descriptor eui48_rdata_fields[] = {
	FIELD("address", 6)
};

static const struct nsd_rdata_descriptor eui64_rdata_fields[] = {
	FIELD("address", 8)
};

static const struct nsd_rdata_descriptor uri_rdata_fields[] = {
	FIELD("priority", 2),
	FIELD("weight", 2),
	FIELD("target", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor caa_rdata_fields[] = {
	FIELD("flags", 1),
	FIELD("tag", RDATA_STRING),
	FIELD("value", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor avc_rdata_fields[] = {
	FIELD("text", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor doa_rdata_fields[] = {
	FIELD("enterprise", 4),
	FIELD("type", 4),
	FIELD("location", 1),
	FIELD("media type", RDATA_STRING),
	FIELD("data", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor amtrelay_rdata_fields[] = {
	FIELD("precedence", 1),
	FIELD("discovery_type", 1),
	FIELD_ENTRY("relay", 0, RDATA_AMTRELAY_RELAY,
		amtrelay_relay_length, amtrelay_relay_length)
};

static const struct nsd_rdata_descriptor resinfo_rdata_fields[] = {
	FIELD("text", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor wallet_rdata_fields[] = {
	FIELD("wallet", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor cla_rdata_fields[] = {
	FIELD("CLA", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor ipn_rdata_fields[] = {
	FIELD("CBHE Node Number", 8)
};

static const struct nsd_rdata_descriptor ta_rdata_fields[] = {
	FIELD("key", 2),
	FIELD("algorithm", 1),
	FIELD("type", 1),
	FIELD("digest", RDATA_REMAINDER)
};

static const struct nsd_rdata_descriptor dlv_rdata_fields[] = {
	FIELD("key", 2),
	FIELD("algorithm", 1),
	FIELD("type", 1),
	FIELD("digest", RDATA_REMAINDER)
};

#define TYPE(name, code, bools, read, write, print, fields) \
  { code, name, bools, read, write, print, { sizeof(fields)/sizeof(fields[0]), fields } }

#define UNKNOWN_TYPE(code) \
  { code, NULL /* mnemonic */, 0 /* has_references */, 0 /* is_compressible */, 0 /* has_dnames */, read_generic_rdata, write_generic_rdata, print_generic_rdata, { sizeof(generic_rdata_fields)/sizeof(generic_rdata_fields[0]), generic_rdata_fields } }

/* The RR type has no references, it is a binary wireformat.
 * has_references, is_compressible, has_dnames. */
#define TYPE_HAS_NO_REFS 0, 0, 0
/* The RR type has references, it has compressed dnames. */
#define TYPE_HAS_COMPRESSED_DNAME 1, 1, 1
/* The RR type has references, it has uncompressed dnames. */
#define TYPE_HAS_UNCOMPRESSED_DNAME 1, 0, 1
/* The RR type has no references, it has literal dnames. */
#define TYPE_HAS_LITERAL_DNAME 0, 0, 1
/* Set the bools, has_references, is_compressible, has_dnames. */
#define TYPE_HAS_FLAGS(has_references, is_compressible, has_dnames) has_references, is_compressible, has_dnames

const nsd_type_descriptor_type type_descriptors[] = {
	/* 0 */
	UNKNOWN_TYPE(0), /* Type 0 - Reserved [RFC 6895] */
	/* 1 */
	TYPE("A", TYPE_A, TYPE_HAS_NO_REFS,
		read_a_rdata, write_generic_rdata,
		print_a_rdata, a_rdata_fields),
	/* 2 */
	TYPE("NS", TYPE_NS, TYPE_HAS_COMPRESSED_DNAME,
		read_compressed_name_rdata, write_compressed_name_rdata,
		print_name_rdata, ns_rdata_fields),
	/* 3 */
	TYPE("MD", TYPE_MD, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_uncompressed_name_rdata, write_uncompressed_name_rdata,
		print_name_rdata, md_rdata_fields),
	/* 4 */
	TYPE("MF", TYPE_MF, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_uncompressed_name_rdata, write_uncompressed_name_rdata,
		print_name_rdata, mf_rdata_fields),
	/* 5 */
	TYPE("CNAME", TYPE_CNAME, TYPE_HAS_COMPRESSED_DNAME,
		read_compressed_name_rdata, write_compressed_name_rdata,
		print_name_rdata, cname_rdata_fields),
	/* 6 */
	TYPE("SOA", TYPE_SOA, TYPE_HAS_COMPRESSED_DNAME,
		read_soa_rdata, write_soa_rdata,
		print_soa_rdata, soa_rdata_fields),
	/* 7 */
	TYPE("MB", TYPE_MB, TYPE_HAS_COMPRESSED_DNAME,
		read_compressed_name_rdata, write_compressed_name_rdata,
		print_name_rdata, mb_rdata_fields),
	/* 8 */
	TYPE("MG", TYPE_MG, TYPE_HAS_COMPRESSED_DNAME,
		read_compressed_name_rdata, write_compressed_name_rdata,
		print_name_rdata, mg_rdata_fields),
	/* 9 */
	TYPE("MR", TYPE_MR, TYPE_HAS_COMPRESSED_DNAME,
		read_compressed_name_rdata, write_compressed_name_rdata,
		print_name_rdata, mr_rdata_fields),
	/* 10 */
	TYPE("NULL", TYPE_NULL, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata,
		print_generic_rdata, generic_rdata_fields),
	/* 11 */
	TYPE("WKS", TYPE_WKS, TYPE_HAS_NO_REFS,
		read_wks_rdata, write_generic_rdata,
		print_wks_rdata, wks_rdata_fields),
	/* 12 */
	TYPE("PTR", TYPE_PTR, TYPE_HAS_COMPRESSED_DNAME,
		read_compressed_name_rdata, write_compressed_name_rdata,
		print_name_rdata, ptr_rdata_fields),
	/* 13 */
	TYPE("HINFO", TYPE_HINFO, TYPE_HAS_NO_REFS,
		read_hinfo_rdata, write_generic_rdata,
		print_hinfo_rdata, hinfo_rdata_fields),
	/* 14 */
	TYPE("MINFO", TYPE_MINFO, TYPE_HAS_COMPRESSED_DNAME,
		read_minfo_rdata, write_minfo_rdata,
		print_minfo_rdata, minfo_rdata_fields),
	/* 15 */
	TYPE("MX", TYPE_MX, TYPE_HAS_COMPRESSED_DNAME,
		read_mx_rdata, write_mx_rdata,
		print_mx_rdata, mx_rdata_fields),
	/* 16 */
	TYPE("TXT", TYPE_TXT, TYPE_HAS_NO_REFS,
		read_txt_rdata, write_generic_rdata,
		print_txt_rdata, txt_rdata_fields),
	/* 17 */
	TYPE("RP", TYPE_RP, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_rp_rdata, write_rp_rdata, print_rp_rdata,
		rp_rdata_fields),
	/* 18 */
	TYPE("AFSDB", TYPE_AFSDB, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_afsdb_rdata, write_afsdb_rdata, print_afsdb_rdata,
		afsdb_rdata_fields),
	/* 19 */
	TYPE("X25", TYPE_X25, TYPE_HAS_NO_REFS,
		read_x25_rdata, write_generic_rdata, print_x25_rdata,
		x25_rdata_fields),
	/* 20 */
	TYPE("ISDN", TYPE_ISDN, TYPE_HAS_NO_REFS,
		read_isdn_rdata, write_generic_rdata, print_isdn_rdata,
		isdn_rdata_fields),
	/* 21 */
	TYPE("RT", TYPE_RT, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_rt_rdata, write_rt_rdata, print_mx_rdata,
		rt_rdata_fields),
	/* 22 */
	TYPE("NSAP", TYPE_NSAP, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata, print_nsap_rdata,
		nsap_rdata_fields),
	/* 23 */
	TYPE("NSAP-PTR", TYPE_NSAP_PTR, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata,
		print_nsap_ptr_rdata, nsap_ptr_rdata_fields),
	/* 24 */
	TYPE("SIG", TYPE_SIG, TYPE_HAS_LITERAL_DNAME,
		read_rrsig_rdata, write_generic_rdata, print_rrsig_rdata,
		sig_rdata_fields),
	/* 25 */
	TYPE("KEY", TYPE_KEY, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata, print_key_rdata,
		key_rdata_fields),
	/* 26 */
	TYPE("PX", TYPE_PX, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_px_rdata, write_px_rdata, print_px_rdata,
		px_rdata_fields),
	/* 27 */
	TYPE("GPOS", TYPE_GPOS, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata, print_gpos_rdata,
		gpos_rdata_fields),
	/* 28 */
	TYPE("AAAA", TYPE_AAAA, TYPE_HAS_NO_REFS,
		read_aaaa_rdata, write_generic_rdata, print_aaaa_rdata,
		aaaa_rdata_fields),
	/* 29 */
	TYPE("LOC", TYPE_LOC, TYPE_HAS_NO_REFS,
		read_loc_rdata, write_generic_rdata, print_loc_rdata,
		loc_rdata_fields),
	/* 30 */
	TYPE("NXT", TYPE_NXT, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_nxt_rdata, write_nxt_rdata, print_nxt_rdata,
		nxt_rdata_fields),
	/* 31 */
	TYPE("EID", TYPE_EID, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata, print_eid_rdata,
		eid_rdata_fields),
	/* 32 */
	TYPE("NIMLOC", TYPE_NIMLOC, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata, print_nimloc_rdata,
		nimloc_rdata_fields),
	/* 33 */
	TYPE("SRV", TYPE_SRV, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_srv_rdata, write_srv_rdata,
		print_srv_rdata, srv_rdata_fields),
	/* 34 */
	TYPE("ATMA", TYPE_ATMA, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata, print_atma_rdata,
		atma_rdata_fields),
	/* 35 */
	TYPE("NAPTR", TYPE_NAPTR, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_naptr_rdata, write_naptr_rdata,
		print_naptr_rdata, naptr_rdata_fields),
	/* 36 */
	TYPE("KX", TYPE_KX, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_kx_rdata, write_kx_rdata,
		print_mx_rdata, kx_rdata_fields),
	/* 37 */
	TYPE("CERT", TYPE_CERT, TYPE_HAS_NO_REFS,
		read_cert_rdata, write_generic_rdata,
		print_cert_rdata, cert_rdata_fields),
	/* 38 */
	TYPE("A6", TYPE_A6, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata,
		print_generic_rdata, a6_rdata_fields),
	/* 39 */
	TYPE("DNAME", TYPE_DNAME, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_uncompressed_name_rdata, write_uncompressed_name_rdata,
		print_name_rdata, dname_rdata_fields),
	/* 40 */
	TYPE("SINK", TYPE_SINK, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata, print_sink_rdata,
		sink_rdata_fields),

	UNKNOWN_TYPE(41), /* Type 41 - OPT */

	/* 42 */
	TYPE("APL", TYPE_APL, TYPE_HAS_NO_REFS,
		read_apl_rdata, write_generic_rdata,
		print_apl_rdata, apl_rdata_fields),
	/* 43 */
	TYPE("DS", TYPE_DS, TYPE_HAS_NO_REFS,
		read_ds_rdata, write_generic_rdata,
		print_ds_rdata, ds_rdata_fields),
	/* 44 */
	TYPE("SSHFP", TYPE_SSHFP, TYPE_HAS_NO_REFS,
		read_sshfp_rdata, write_generic_rdata,
		print_sshfp_rdata, sshfp_rdata_fields),
	/* 45 */
	TYPE("IPSECKEY", TYPE_IPSECKEY, TYPE_HAS_LITERAL_DNAME,
		read_ipseckey_rdata, write_generic_rdata,
		print_ipseckey_rdata, ipseckey_rdata_fields),
	/* 46 */
	TYPE("RRSIG", TYPE_RRSIG, TYPE_HAS_LITERAL_DNAME,
		read_rrsig_rdata, write_generic_rdata,
		print_rrsig_rdata, rrsig_rdata_fields),
	/* 47 */
	TYPE("NSEC", TYPE_NSEC, TYPE_HAS_LITERAL_DNAME,
		read_nsec_rdata, write_generic_rdata,
		print_nsec_rdata, nsec_rdata_fields),
	/* 48 */
	TYPE("DNSKEY", TYPE_DNSKEY, TYPE_HAS_NO_REFS,
		read_dnskey_rdata, write_generic_rdata,
		print_dnskey_rdata, dnskey_rdata_fields),
	/* 49 */
	TYPE("DHCID", TYPE_DHCID, TYPE_HAS_NO_REFS,
		read_dhcid_rdata, write_generic_rdata,
		print_dhcid_rdata, dhcid_rdata_fields),
	/* 50 */
	TYPE("NSEC3", TYPE_NSEC3, TYPE_HAS_NO_REFS,
		read_nsec3_rdata, write_generic_rdata,
		print_nsec3_rdata, nsec3_rdata_fields),
	/* 51 */
	TYPE("NSEC3PARAM", TYPE_NSEC3PARAM, TYPE_HAS_NO_REFS,
		read_nsec3param_rdata, write_generic_rdata,
		print_nsec3param_rdata, nsec3param_rdata_fields),
	/* 52 */
	TYPE("TLSA", TYPE_TLSA, TYPE_HAS_NO_REFS,
		read_tlsa_rdata, write_generic_rdata,
		print_tlsa_rdata, tlsa_rdata_fields),
	/* 53 */
	TYPE("SMIMEA", TYPE_SMIMEA, TYPE_HAS_NO_REFS,
		read_tlsa_rdata, write_generic_rdata,
		print_tlsa_rdata, smimea_rdata_fields),

	UNKNOWN_TYPE(54),

	/* 55 */
	TYPE("HIP", TYPE_HIP, TYPE_HAS_LITERAL_DNAME,
		read_hip_rdata, write_generic_rdata,
		print_hip_rdata, hip_rdata_fields),
	/* 56 */
	TYPE("NINFO", TYPE_NINFO, TYPE_HAS_NO_REFS,
		read_txt_rdata, write_generic_rdata,
		print_txt_rdata, ninfo_rdata_fields),
	/* 57 */
	TYPE("RKEY", TYPE_RKEY, TYPE_HAS_NO_REFS,
		read_rkey_rdata, write_generic_rdata,
		print_rkey_rdata, rkey_rdata_fields),
	/* 58 */
	TYPE("TALINK", TYPE_TALINK, TYPE_HAS_LITERAL_DNAME,
		read_talink_rdata, write_generic_rdata,
		print_talink_rdata, talink_rdata_fields),
	/* 59 */
	TYPE("CDS", TYPE_CDS, TYPE_HAS_NO_REFS,
		read_ds_rdata, write_generic_rdata,
		print_ds_rdata, cds_rdata_fields),
	/* 60 */
	TYPE("CDNSKEY", TYPE_CDNSKEY, TYPE_HAS_NO_REFS,
		read_dnskey_rdata, write_generic_rdata,
		print_dnskey_rdata, cdnskey_rdata_fields),
	/* 61 */
	TYPE("OPENPGPKEY", TYPE_OPENPGPKEY, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata,
		print_openpgpkey_rdata, openpgpkey_rdata_fields),
	/* 62 */
	TYPE("CSYNC", TYPE_CSYNC, TYPE_HAS_NO_REFS,
		read_csync_rdata, write_generic_rdata,
		print_csync_rdata, csync_rdata_fields),
	/* 63 */
	TYPE("ZONEMD", TYPE_ZONEMD, TYPE_HAS_NO_REFS,
		read_zonemd_rdata, write_generic_rdata,
		print_zonemd_rdata, zonemd_rdata_fields),
	/* 64 */
	TYPE("SVCB", TYPE_SVCB, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_svcb_rdata, write_svcb_rdata,
		print_svcb_rdata, svcb_rdata_fields),
	/* 65 */
	TYPE("HTTPS", TYPE_HTTPS, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_svcb_rdata, write_svcb_rdata,
		print_svcb_rdata, https_rdata_fields),
	/* 66 */
	TYPE("DSYNC", TYPE_DSYNC, TYPE_HAS_LITERAL_DNAME,
		read_dsync_rdata, write_generic_rdata,
		print_dsync_rdata, dsync_rdata_fields),

	UNKNOWN_TYPE(67),
	UNKNOWN_TYPE(68),
	UNKNOWN_TYPE(69),
	UNKNOWN_TYPE(70),
	UNKNOWN_TYPE(71),
	UNKNOWN_TYPE(72),
	UNKNOWN_TYPE(73),
	UNKNOWN_TYPE(74),
	UNKNOWN_TYPE(75),
	UNKNOWN_TYPE(76),
	UNKNOWN_TYPE(77),
	UNKNOWN_TYPE(78),
	UNKNOWN_TYPE(79),
	UNKNOWN_TYPE(80),
	UNKNOWN_TYPE(81),
	UNKNOWN_TYPE(82),
	UNKNOWN_TYPE(83),
	UNKNOWN_TYPE(84),
	UNKNOWN_TYPE(85),
	UNKNOWN_TYPE(86),
	UNKNOWN_TYPE(87),
	UNKNOWN_TYPE(88),
	UNKNOWN_TYPE(89),
	UNKNOWN_TYPE(90),
	UNKNOWN_TYPE(91),
	UNKNOWN_TYPE(92),
	UNKNOWN_TYPE(93),
	UNKNOWN_TYPE(94),
	UNKNOWN_TYPE(95),
	UNKNOWN_TYPE(96),
	UNKNOWN_TYPE(97),
	UNKNOWN_TYPE(98),

	/* 99 */
	TYPE("SPF", TYPE_SPF, TYPE_HAS_NO_REFS,
		read_txt_rdata, write_generic_rdata,
		print_txt_rdata, spf_rdata_fields),

	UNKNOWN_TYPE(100), /* Type 100 - UINFO [The RR type code is reserved, no reference] */
	UNKNOWN_TYPE(101), /* Type 101 - UID [The RR type code is reserved, no reference] */
	UNKNOWN_TYPE(102), /* Type 102 - GID [The RR type code is reserved, no reference] */
	UNKNOWN_TYPE(103), /* Type 103 - UNSPEC [The RR type code is reserved, no reference] */

	/* 104 */
	TYPE("NID", TYPE_NID, TYPE_HAS_NO_REFS,
		read_nid_rdata, write_generic_rdata,
		print_nid_rdata, nid_rdata_fields),
	/* 105 */
	TYPE("L32", TYPE_L32, TYPE_HAS_NO_REFS,
		read_l32_rdata, write_generic_rdata,
		print_l32_rdata, l32_rdata_fields),
	/* 106 */
	TYPE("L64", TYPE_L64, TYPE_HAS_NO_REFS,
		read_l64_rdata, write_generic_rdata,
		print_l64_rdata, l64_rdata_fields),
	/* 107 */
	TYPE("LP", TYPE_LP, TYPE_HAS_UNCOMPRESSED_DNAME,
		read_lp_rdata, write_lp_rdata,
		print_lp_rdata, lp_rdata_fields),
	/* 108 */
	TYPE("EUI48", TYPE_EUI48, TYPE_HAS_NO_REFS,
		read_eui48_rdata, write_generic_rdata,
		print_eui48_rdata, eui48_rdata_fields),
	/* 109 */
	TYPE("EUI64", TYPE_EUI64, TYPE_HAS_NO_REFS,
		read_eui64_rdata, write_generic_rdata,
		print_eui64_rdata, eui64_rdata_fields),

	UNKNOWN_TYPE(110),
	UNKNOWN_TYPE(111),
	UNKNOWN_TYPE(112),
	UNKNOWN_TYPE(113),
	UNKNOWN_TYPE(114),
	UNKNOWN_TYPE(115),
	UNKNOWN_TYPE(116),
	UNKNOWN_TYPE(117),
	UNKNOWN_TYPE(118),
	UNKNOWN_TYPE(119),
	UNKNOWN_TYPE(120),
	UNKNOWN_TYPE(121),
	UNKNOWN_TYPE(122),
	UNKNOWN_TYPE(123),
	UNKNOWN_TYPE(124),
	UNKNOWN_TYPE(125),
	UNKNOWN_TYPE(126),
	UNKNOWN_TYPE(127),

	/* 128 */
	/* The mnemonic is included so it can be printed in type bitmaps.*/
	TYPE("NXNAME", TYPE_NXNAME, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata,
		print_generic_rdata, generic_rdata_fields),

	UNKNOWN_TYPE(129),
	UNKNOWN_TYPE(130),
	UNKNOWN_TYPE(131),
	UNKNOWN_TYPE(132),
	UNKNOWN_TYPE(133),
	UNKNOWN_TYPE(134),
	UNKNOWN_TYPE(135),
	UNKNOWN_TYPE(136),
	UNKNOWN_TYPE(137),
	UNKNOWN_TYPE(138),
	UNKNOWN_TYPE(139),
	UNKNOWN_TYPE(140),
	UNKNOWN_TYPE(141),
	UNKNOWN_TYPE(142),
	UNKNOWN_TYPE(143),
	UNKNOWN_TYPE(144),
	UNKNOWN_TYPE(145),
	UNKNOWN_TYPE(146),
	UNKNOWN_TYPE(147),
	UNKNOWN_TYPE(148),
	UNKNOWN_TYPE(149),
	UNKNOWN_TYPE(150),
	UNKNOWN_TYPE(151),
	UNKNOWN_TYPE(152),
	UNKNOWN_TYPE(153),
	UNKNOWN_TYPE(154),
	UNKNOWN_TYPE(155),
	UNKNOWN_TYPE(156),
	UNKNOWN_TYPE(157),
	UNKNOWN_TYPE(158),
	UNKNOWN_TYPE(159),
	UNKNOWN_TYPE(160),
	UNKNOWN_TYPE(161),
	UNKNOWN_TYPE(162),
	UNKNOWN_TYPE(163),
	UNKNOWN_TYPE(164),
	UNKNOWN_TYPE(165),
	UNKNOWN_TYPE(166),
	UNKNOWN_TYPE(167),
	UNKNOWN_TYPE(168),
	UNKNOWN_TYPE(169),
	UNKNOWN_TYPE(170),
	UNKNOWN_TYPE(171),
	UNKNOWN_TYPE(172),
	UNKNOWN_TYPE(173),
	UNKNOWN_TYPE(174),
	UNKNOWN_TYPE(175),
	UNKNOWN_TYPE(176),
	UNKNOWN_TYPE(177),
	UNKNOWN_TYPE(178),
	UNKNOWN_TYPE(179),
	UNKNOWN_TYPE(180),
	UNKNOWN_TYPE(181),
	UNKNOWN_TYPE(182),
	UNKNOWN_TYPE(183),
	UNKNOWN_TYPE(184),
	UNKNOWN_TYPE(185),
	UNKNOWN_TYPE(186),
	UNKNOWN_TYPE(187),
	UNKNOWN_TYPE(188),
	UNKNOWN_TYPE(189),
	UNKNOWN_TYPE(190),
	UNKNOWN_TYPE(191),
	UNKNOWN_TYPE(192),
	UNKNOWN_TYPE(193),
	UNKNOWN_TYPE(194),
	UNKNOWN_TYPE(195),
	UNKNOWN_TYPE(196),
	UNKNOWN_TYPE(197),
	UNKNOWN_TYPE(198),
	UNKNOWN_TYPE(199),
	UNKNOWN_TYPE(200),
	UNKNOWN_TYPE(201),
	UNKNOWN_TYPE(202),
	UNKNOWN_TYPE(203),
	UNKNOWN_TYPE(204),
	UNKNOWN_TYPE(205),
	UNKNOWN_TYPE(206),
	UNKNOWN_TYPE(207),
	UNKNOWN_TYPE(208),
	UNKNOWN_TYPE(209),
	UNKNOWN_TYPE(210),
	UNKNOWN_TYPE(211),
	UNKNOWN_TYPE(212),
	UNKNOWN_TYPE(213),
	UNKNOWN_TYPE(214),
	UNKNOWN_TYPE(215),
	UNKNOWN_TYPE(216),
	UNKNOWN_TYPE(217),
	UNKNOWN_TYPE(218),
	UNKNOWN_TYPE(219),
	UNKNOWN_TYPE(220),
	UNKNOWN_TYPE(221),
	UNKNOWN_TYPE(222),
	UNKNOWN_TYPE(223),
	UNKNOWN_TYPE(224),
	UNKNOWN_TYPE(225),
	UNKNOWN_TYPE(226),
	UNKNOWN_TYPE(227),
	UNKNOWN_TYPE(228),
	UNKNOWN_TYPE(229),
	UNKNOWN_TYPE(230),
	UNKNOWN_TYPE(231),
	UNKNOWN_TYPE(232),
	UNKNOWN_TYPE(233),
	UNKNOWN_TYPE(234),
	UNKNOWN_TYPE(235),
	UNKNOWN_TYPE(236),
	UNKNOWN_TYPE(237),
	UNKNOWN_TYPE(238),
	UNKNOWN_TYPE(239),
	UNKNOWN_TYPE(240),
	UNKNOWN_TYPE(241),
	UNKNOWN_TYPE(242),
	UNKNOWN_TYPE(243),
	UNKNOWN_TYPE(244),
	UNKNOWN_TYPE(245),
	UNKNOWN_TYPE(246),
	UNKNOWN_TYPE(247),
	UNKNOWN_TYPE(248),
	UNKNOWN_TYPE(249), /* Type 249 - TKEY [RFC 2930] */
	UNKNOWN_TYPE(250), /* Type 250 - TSIG */
	UNKNOWN_TYPE(251), /* Type 251 - IXFR */
	UNKNOWN_TYPE(252), /* Type 252 - AXFR */
	UNKNOWN_TYPE(253), /* Type 253 - MAILB */
	UNKNOWN_TYPE(254), /* Type 254 - MAILA */
	UNKNOWN_TYPE(255), /* Type 255 - ANY */

	/* 256 */
	TYPE("URI", TYPE_URI, TYPE_HAS_NO_REFS,
		read_uri_rdata, write_generic_rdata,
		print_uri_rdata, uri_rdata_fields),
	/* 257 */
	TYPE("CAA", TYPE_CAA, TYPE_HAS_NO_REFS,
		read_caa_rdata, write_generic_rdata,
		print_caa_rdata, caa_rdata_fields),
	/* 258 */
	TYPE("AVC", TYPE_AVC, TYPE_HAS_NO_REFS,
		read_txt_rdata, write_generic_rdata,
		print_txt_rdata, avc_rdata_fields),
	/* 259 */
	TYPE("DOA", TYPE_DOA, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata,
		print_doa_rdata, doa_rdata_fields),
	/* 260 */
	TYPE("AMTRELAY", TYPE_AMTRELAY, TYPE_HAS_LITERAL_DNAME,
		read_amtrelay_rdata, write_generic_rdata,
		print_amtrelay_rdata, amtrelay_rdata_fields),
	/* 261 */
	TYPE("RESINFO", TYPE_RESINFO, TYPE_HAS_NO_REFS,
		read_txt_rdata, write_generic_rdata,
		print_resinfo_rdata, resinfo_rdata_fields),
	/* 262 */
	TYPE("WALLET", TYPE_WALLET, TYPE_HAS_NO_REFS,
		read_txt_rdata, write_generic_rdata,
		print_txt_rdata, wallet_rdata_fields),
	/* 263 */
	TYPE("CLA", TYPE_CLA, TYPE_HAS_NO_REFS,
		read_txt_rdata, write_generic_rdata,
		print_txt_rdata, cla_rdata_fields),
	/* 264 */
	TYPE("IPN", TYPE_IPN, TYPE_HAS_NO_REFS,
		read_generic_rdata, write_generic_rdata,
		print_ipn_rdata, ipn_rdata_fields),

	/* 32768 */
	TYPE("TA", TYPE_TA, TYPE_HAS_NO_REFS,
		read_dlv_rdata, write_generic_rdata,
		print_dlv_rdata, ta_rdata_fields),
	/* 32769 */
	TYPE("DLV", TYPE_DLV, TYPE_HAS_NO_REFS,
		read_dlv_rdata, write_generic_rdata,
		print_dlv_rdata, dlv_rdata_fields)
};

#undef UNKNOWN_TYPE
#undef TYPE
#undef FIELD
#undef FIELD_ENTRY
#undef TYPE_HAS_NO_REFS
#undef TYPE_HAS_COMPRESSED_DNAME
#undef TYPE_HAS_UNCOMPRESSED_DNAME
#undef TYPE_HAS_LITERAL_DNAME
#undef TYPE_HAS_FLAGS

const char *
rrtype_to_string(uint16_t rrtype)
{
	static char buf[20];
	const nsd_type_descriptor_type *descriptor =
		nsd_type_descriptor(rrtype);
	if (descriptor->name) {
		return descriptor->name;
	} else {
		snprintf(buf, sizeof(buf), "TYPE%d", (int) rrtype);
		return buf;
	}
}

/*
 * Lookup the type in the ztypes lookup table.  If not found, check if
 * the type uses the "TYPExxx" notation for unknown types.
 *
 * Return 0 if no type matches.
 */
uint16_t
rrtype_from_string(const char *name)
{
	char *end;
	long rrtype;

	/* Because this routine is called during zone parse for every record,
	 * we optimise for frequently occurring records.
	 * Also, we optimise for 'IN' and numbers are not rr types, because
	 * during parse this routine is called for every rr class and TTL
	 * to determine that it is not an RR type */
	switch(name[0]) {
	case 'r':
	case 'R':
		if(strcasecmp(name+1, "RSIG") == 0) return TYPE_RRSIG;
		break;
	case 'n':
	case 'N':
		switch(name[1]) {
		case 's':
		case 'S':
			switch(name[2]) {
			case 0: return TYPE_NS;
			case 'e':
			case 'E':
				if(strcasecmp(name+2, "EC") == 0) return TYPE_NSEC;
				if(strcasecmp(name+2, "EC3") == 0) return TYPE_NSEC3;
				if(strcasecmp(name+2, "EC3PARAM") == 0) return TYPE_NSEC3PARAM;
				break;
			}
			break;
		}
		break;
	case 'd':
	case 'D':
		switch(name[1]) {
		case 's':
		case 'S':
			if(name[2]==0) return TYPE_DS;
			break;
		case 'n':
		case 'N':
			if(strcasecmp(name+2, "SKEY") == 0) return TYPE_DNSKEY;
			break;
		}
		break;
	case 'a':
	case 'A':
		switch(name[1]) {
		case 0:	return TYPE_A;
		case 'a':
		case 'A':
			if(strcasecmp(name+2, "AA") == 0) return TYPE_AAAA;
			break;
		}
		break;
	case 's':
	case 'S':
		if(strcasecmp(name+1, "OA") == 0) return TYPE_SOA;
		break;
	case 't':
	case 'T':
		if(strcasecmp(name+1, "XT") == 0) return TYPE_TXT;
		break;
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
		return 0; /* no RR types start with 0-9 */
	case 'i':
	case 'I':
		switch(name[1]) {
		case 'n':
		case 'N':
			return 0; /* 'IN' is a class not a type */
		}
		break;
	}

	for (int i=0, n=sizeof(type_descriptors)/sizeof(type_descriptors[0]); i < n; i++) {
		if (type_descriptors[i].name && strcasecmp(type_descriptors[i].name, name) == 0)
			return type_descriptors[i].type;
	}

	if (strlen(name) < 5)
		return 0;

	if (strncasecmp(name, "TYPE", 4) != 0)
		return 0;

	if (!isdigit((unsigned char)name[4]))
		return 0;

	/* The rest from the string must be a number.  */
	rrtype = strtol(name + 4, &end, 10);
	if (*end != '\0')
		return 0;
	if (rrtype < 0 || rrtype > 65535L)
		return 0;

	return (uint16_t) rrtype;
}

const char *
rrclass_to_string(uint16_t rrclass)
{
	static char buf[20];
	lookup_table_type *entry = lookup_by_id(dns_rrclasses, rrclass);
	if (entry) {
		assert(strlen(entry->name) < sizeof(buf));
		strlcpy(buf, entry->name, sizeof(buf));
	} else {
		snprintf(buf, sizeof(buf), "CLASS%d", (int) rrclass);
	}
	return buf;
}

uint16_t
rrclass_from_string(const char *name)
{
        char *end;
        long rrclass;
	lookup_table_type *entry;

	entry = lookup_by_name(dns_rrclasses, name);
	if (entry) {
		return (uint16_t) entry->id;
	}

	if (strlen(name) < 6)
		return 0;

	if (strncasecmp(name, "CLASS", 5) != 0)
		return 0;

	if (!isdigit((unsigned char)name[5]))
		return 0;

	/* The rest from the string must be a number.  */
	rrclass = strtol(name + 5, &end, 10);
	if (*end != '\0')
		return 0;
	if (rrclass < 0 || rrclass > 65535L)
		return 0;

	return (uint16_t) rrclass;
}