* zyparser.y -- yacc grammar for (DNS) zone files

%{
/*
* zyparser.y -- yacc grammar for (DNS) zone files
*
* Copyright (c) 2001-2006, NLnet Labs. All rights reserved.
*
* See LICENSE for the license.
*
*/

#include "config.h"

#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#include "dname.h"
#include "namedb.h"
#include "zonec.h"

/* these need to be global, otherwise they cannot be used inside yacc */
zparser_type *parser;

#ifdef __cplusplus
extern "C"
#endif /* __cplusplus */
int yywrap(void);

/* this hold the nxt bits */
static uint8_t nxtbits[16];
static int dlv_warn = 1;

/* 256 windows of 256 bits (32 bytes) */
/* still need to reset the bastard somewhere */
static uint8_t nsecbits[NSEC_WINDOW_COUNT][NSEC_WINDOW_BITS_SIZE];

/* hold the highest rcode seen in a NSEC rdata , BUG #106 */
uint16_t nsec_highest_rcode;

void yyerror(const char *message);

#ifdef NSEC3
/* parse nsec3 parameters and add the (first) rdata elements */
static void
nsec3_add_params(const char* hash_algo_str, const char* flag_str,
const char* iter_str, const char* salt_str, int salt_len);
#endif /* NSEC3 */

%}
%union {
domain_type *domain;
const dname_type *dname;
struct lex_data data;
uint32_t ttl;
uint16_t klass;
uint16_t type;
uint16_t *unknown;
}

/*
* Tokens to represent the known RR types of DNS.
*/
%token <type> T_A T_NS T_MX T_TXT T_CNAME T_AAAA T_PTR T_NXT T_KEY T_SOA T_SIG
%token <type> T_SRV T_CERT T_LOC T_MD T_MF T_MB T_MG T_MR T_NULL T_WKS T_HINFO
%token <type> T_MINFO T_RP T_AFSDB T_X25 T_ISDN T_RT T_NSAP T_NSAP_PTR T_PX
%token <type> T_GPOS T_EID T_NIMLOC T_ATMA T_NAPTR T_KX T_A6 T_DNAME T_SINK
%token <type> T_OPT T_APL T_UINFO T_UID T_GID T_UNSPEC T_TKEY T_TSIG T_IXFR
%token <type> T_AXFR T_MAILB T_MAILA T_DS T_DLV T_SSHFP T_RRSIG T_NSEC T_DNSKEY
%token <type> T_SPF T_NSEC3 T_IPSECKEY T_DHCID T_NSEC3PARAM T_TLSA T_URI
%token <type> T_NID T_L32 T_L64 T_LP T_EUI48 T_EUI64 T_CAA T_CDS T_CDNSKEY
%token <type> T_OPENPGPKEY T_CSYNC T_ZONEMD T_AVC T_SMIMEA T_SVCB T_HTTPS

/* other tokens */
%token DOLLAR_TTL DOLLAR_ORIGIN NL SP
%token <data> QSTR STR PREV BITLAB
%token <ttl> T_TTL
%token <klass> T_RRCLASS

/* unknown RRs */
%token URR
%token <type> T_UTYPE

%type <type> type_and_rdata
%type <domain> owner dname abs_dname
%type <dname> rel_dname label
%type <data> wire_dname wire_abs_dname wire_rel_dname wire_label
%type <data> str concatenated_str_seq str_sp_seq str_dot_seq
%type <data> unquoted_dotted_str dotted_str svcparam svcparams
%type <data> nxt_seq nsec_more
%type <unknown> rdata_unknown

%%
lines: /* empty file */
| lines line
;

line: NL
| sp NL
| PREV NL {} /* Lines containing only whitespace. */
| ttl_directive
{
region_free_all(parser->rr_region);
parser->current_rr.type = 0;
parser->current_rr.rdata_count = 0;
parser->current_rr.rdatas = parser->temporary_rdatas;
parser->error_occurred = 0;
}
| origin_directive
{
region_free_all(parser->rr_region);
parser->current_rr.type = 0;
parser->current_rr.rdata_count = 0;
parser->current_rr.rdatas = parser->temporary_rdatas;
parser->error_occurred = 0;
}
| rr
{ /* rr should be fully parsed */
if (!parser->error_occurred) {
parser->current_rr.rdatas
=(rdata_atom_type *)region_alloc_array_init(
parser->region,
parser->current_rr.rdatas,
parser->current_rr.rdata_count,
sizeof(rdata_atom_type));

process_rr();
}

region_free_all(parser->rr_region);

parser->current_rr.type = 0;
parser->current_rr.rdata_count = 0;
parser->current_rr.rdatas = parser->temporary_rdatas;
parser->error_occurred = 0;
}
| error NL
;

/* needed to cope with ( and ) in arbitrary places */
sp: SP
| sp SP
;

str: STR | QSTR;

trail: NL
| sp NL
;

ttl_directive: DOLLAR_TTL sp str trail
{
parser->default_ttl = zparser_ttl2int($3.str, &(parser->error_occurred));
if (parser->error_occurred == 1) {
parser->default_ttl = DEFAULT_TTL;
parser->error_occurred = 0;
}
}
;

origin_directive: DOLLAR_ORIGIN sp abs_dname trail
{
/* if previous origin is unused, remove it, do not leak it */
if(parser->origin != error_domain && parser->origin != $3) {
/* protect $3 from deletion, because deldomain walks up */
$3->usage ++;
domain_table_deldomain(parser->db, parser->origin);
$3->usage --;
}
parser->origin = $3;
}
| DOLLAR_ORIGIN sp rel_dname trail
{
zc_error_prev_line("$ORIGIN directive requires absolute domain name");
}
;

rr: owner classttl type_and_rdata
{
parser->current_rr.owner = $1;
parser->current_rr.type = $3;
}
;

owner: dname sp
{
parser->prev_dname = $1;
$$ = $1;
}
| PREV
{
$$ = parser->prev_dname;
}
;

classttl: /* empty - fill in the default, def. ttl and IN class */
{
parser->current_rr.ttl = parser->default_ttl;
parser->current_rr.klass = parser->default_class;
}
| T_RRCLASS sp /* no ttl */
{
parser->current_rr.ttl = parser->default_ttl;
parser->current_rr.klass = $1;
}
| T_TTL sp /* no class */
{
parser->current_rr.ttl = $1;
parser->current_rr.klass = parser->default_class;
}
| T_TTL sp T_RRCLASS sp /* the lot */
{
parser->current_rr.ttl = $1;
parser->current_rr.klass = $3;
}
| T_RRCLASS sp T_TTL sp /* the lot - reversed */
{
parser->current_rr.ttl = $3;
parser->current_rr.klass = $1;
}
;

dname: abs_dname
| rel_dname
{
if ($1 == error_dname) {
$$ = error_domain;
} else if(parser->origin == error_domain) {
zc_error("cannot concatenate origin to domain name, because origin failed to parse");
$$ = error_domain;
} else if ($1->name_size + domain_dname(parser->origin)->name_size - 1 > MAXDOMAINLEN) {
zc_error("domain name exceeds %d character limit", MAXDOMAINLEN);
$$ = error_domain;
} else {
$$ = domain_table_insert(
parser->db->domains,
dname_concatenate(
parser->rr_region,
$1,
domain_dname(parser->origin)));
}
}
;

abs_dname: '.'
{
$$ = parser->db->domains->root;
}
| '@'
{
$$ = parser->origin;
}
| rel_dname '.'
{
if ($1 != error_dname) {
$$ = domain_table_insert(parser->db->domains, $1);
} else {
$$ = error_domain;
}
}
;

label: str
{
if ($1.len > MAXLABELLEN) {
zc_error("label exceeds %d character limit", MAXLABELLEN);
$$ = error_dname;
} else if ($1.len <= 0) {
zc_error("zero label length");
$$ = error_dname;
} else {
$$ = dname_make_from_label(parser->rr_region,
(uint8_t *) $1.str,
$1.len);
}
}
| BITLAB
{
zc_error("bitlabels are now deprecated. RFC2673 is obsoleted.");
$$ = error_dname;
}
;

rel_dname: label
| rel_dname '.' label
{
if ($1 == error_dname || $3 == error_dname) {
$$ = error_dname;
} else if ($1->name_size + $3->name_size - 1 > MAXDOMAINLEN) {
zc_error("domain name exceeds %d character limit",
MAXDOMAINLEN);
$$ = error_dname;
} else {
$$ = dname_concatenate(parser->rr_region, $1, $3);
}
}
;

/*
* Some dnames in rdata are handled as opaque blobs
*/

wire_dname: wire_abs_dname
| wire_rel_dname
{
/* terminate in root label and copy the origin in there */
if(parser->origin && domain_dname(parser->origin)) {
$$.len = $1.len + domain_dname(parser->origin)->name_size;
if ($$.len > MAXDOMAINLEN)
zc_error("domain name exceeds %d character limit",
MAXDOMAINLEN);
$$.str = (char *) region_alloc(parser->rr_region, $$.len);
memmove($$.str, $1.str, $1.len);
memmove($$.str + $1.len, dname_name(domain_dname(parser->origin)),
domain_dname(parser->origin)->name_size);
} else {
$$.len = $1.len + 1;
if ($$.len > MAXDOMAINLEN)
zc_error("domain name exceeds %d character limit",
MAXDOMAINLEN);
$$.str = (char *) region_alloc(parser->rr_region, $$.len);
memmove($$.str, $1.str, $1.len);
$$.str[ $1.len ] = 0;
}
}
;

wire_abs_dname: '.'
{
char *result = (char *) region_alloc(parser->rr_region, 1);
result[0] = 0;
$$.str = result;
$$.len = 1;
}
| '@'
{
if(parser->origin && domain_dname(parser->origin)) {
$$.len = domain_dname(parser->origin)->name_size;
$$.str = (char *) region_alloc(parser->rr_region, $$.len);
memmove($$.str, dname_name(domain_dname(parser->origin)), $$.len);
} else {
$$.len = 1;
$$.str = (char *) region_alloc(parser->rr_region, $$.len);
$$.str[0] = 0;
}
}
| wire_rel_dname '.'
{
$$.len = $1.len + 1;
if ($$.len > MAXDOMAINLEN)
zc_error("domain name exceeds %d character limit",
MAXDOMAINLEN);
$$.str = (char *) region_alloc(parser->rr_region, $$.len);
memcpy($$.str, $1.str, $1.len);
$$.str[$1.len] = 0;
}
;

wire_label: str
{
char *result = (char *) region_alloc(parser->rr_region,
$1.len + 1);

if ($1.len > MAXLABELLEN)
zc_error("label exceeds %d character limit", MAXLABELLEN);

/* make label anyway */
result[0] = $1.len;
memmove(result+1, $1.str, $1.len);

$$.str = result;
$$.len = $1.len + 1;
}
;

wire_rel_dname: wire_label
| wire_rel_dname '.' wire_label
{
$$.len = $1.len + $3.len;
if ($$.len > MAXDOMAINLEN)
zc_error("domain name exceeds %d character limit",
MAXDOMAINLEN);
$$.str = (char *) region_alloc(parser->rr_region, $$.len);
memmove($$.str, $1.str, $1.len);
memmove($$.str + $1.len, $3.str, $3.len);
}
;

str_seq: unquoted_dotted_str
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $1.str, $1.len), 1);
}
| QSTR
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $1.str, $1.len), 1);
}
| QSTR unquoted_dotted_str
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $1.str, $1.len), 1);
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $2.str, $2.len), 0);
}
| str_seq QSTR
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $2.str, $2.len), 0);
}
| str_seq QSTR unquoted_dotted_str
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $2.str, $2.len), 0);
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $3.str, $3.len), 0);
}
| str_seq sp unquoted_dotted_str
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $3.str, $3.len), 0);
}
| str_seq sp QSTR
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $3.str, $3.len), 0);
}
| str_seq sp QSTR unquoted_dotted_str
{
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $3.str, $3.len), 0);
zadd_rdata_txt_wireformat(zparser_conv_text(parser->rr_region, $4.str, $4.len), 0);
}
;

/*
* Generate a single string from multiple STR tokens, separated by
* spaces or dots.
*/
concatenated_str_seq: str
| '.'
{
$$.len = 1;
$$.str = region_strdup(parser->rr_region, ".");
}
| concatenated_str_seq sp str
{
$$.len = $1.len + $3.len + 1;
$$.str = (char *) region_alloc(parser->rr_region, $$.len + 1);
memcpy($$.str, $1.str, $1.len);
memcpy($$.str + $1.len, " ", 1);
memcpy($$.str + $1.len + 1, $3.str, $3.len);
$$.str[$$.len] = '\0';
}
| concatenated_str_seq '.' str
{
$$.len = $1.len + $3.len + 1;
$$.str = (char *) region_alloc(parser->rr_region, $$.len + 1);
memcpy($$.str, $1.str, $1.len);
memcpy($$.str + $1.len, ".", 1);
memcpy($$.str + $1.len + 1, $3.str, $3.len);
$$.str[$$.len] = '\0';
}
;

/* used to convert a nxt list of types */
nxt_seq: str
{
uint16_t type = rrtype_from_string($1.str);
if (type != 0 && type < 128) {
set_bit(nxtbits, type);
} else {
zc_error("bad type %d in NXT record", (int) type);
}
}
| nxt_seq sp str
{
uint16_t type = rrtype_from_string($3.str);
if (type != 0 && type < 128) {
set_bit(nxtbits, type);
} else {
zc_error("bad type %d in NXT record", (int) type);
}
}
;

nsec_more: SP nsec_more
{
}
| NL
{
}
| str nsec_seq
{
uint16_t type = rrtype_from_string($1.str);
if (type != 0) {
if (type > nsec_highest_rcode) {
nsec_highest_rcode = type;
}
set_bitnsec(nsecbits, type);
} else {
zc_error("bad type %d in NSEC record", (int) type);
}
}
;

nsec_seq: NL
| SP nsec_more
;

/*
* Sequence of STR tokens separated by spaces. The spaces are not
* preserved during concatenation.
*/
str_sp_seq: str
| str_sp_seq sp str
{
char *result = (char *) region_alloc(parser->rr_region,
$1.len + $3.len + 1);
memcpy(result, $1.str, $1.len);
memcpy(result + $1.len, $3.str, $3.len);
$$.str = result;
$$.len = $1.len + $3.len;
$$.str[$$.len] = '\0';
}
;

/*
* Sequence of STR tokens separated by dots. The dots are not
* preserved during concatenation.
*/
str_dot_seq: str
| str_dot_seq '.' str
{
char *result = (char *) region_alloc(parser->rr_region,
$1.len + $3.len + 1);
memcpy(result, $1.str, $1.len);
memcpy(result + $1.len, $3.str, $3.len);
$$.str = result;
$$.len = $1.len + $3.len;
$$.str[$$.len] = '\0';
}
;

/*
* A string that can contain dots.
*/
unquoted_dotted_str: STR
| '.'
{
$$.str = ".";
$$.len = 1;
}
| unquoted_dotted_str '.'
{
char *result = (char *) region_alloc(parser->rr_region,
$1.len + 2);
memcpy(result, $1.str, $1.len);
result[$1.len] = '.';
$$.str = result;
$$.len = $1.len + 1;
$$.str[$$.len] = '\0';
}
| unquoted_dotted_str '.' STR
{
char *result = (char *) region_alloc(parser->rr_region,
$1.len + $3.len + 2);
memcpy(result, $1.str, $1.len);
result[$1.len] = '.';
memcpy(result + $1.len + 1, $3.str, $3.len);
$$.str = result;
$$.len = $1.len + $3.len + 1;
$$.str[$$.len] = '\0';
}
;

/*
* A string that can contain dots or a quoted string.
*/
dotted_str: unquoted_dotted_str | QSTR

/* define what we can parse */
type_and_rdata:
/*
* All supported RR types. We don't support NULL and types marked obsolete.
*/
T_A sp rdata_a
| T_A sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NS sp rdata_domain_name
| T_NS sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_MD sp rdata_domain_name { zc_warning_prev_line("MD is obsolete"); }
| T_MD sp rdata_unknown
{
zc_warning_prev_line("MD is obsolete");
$$ = $1; parse_unknown_rdata($1, $3);
}
| T_MF sp rdata_domain_name { zc_warning_prev_line("MF is obsolete"); }
| T_MF sp rdata_unknown
{
zc_warning_prev_line("MF is obsolete");
$$ = $1;
parse_unknown_rdata($1, $3);
}
| T_CNAME sp rdata_domain_name
| T_CNAME sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_SOA sp rdata_soa
| T_SOA sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_MB sp rdata_domain_name { zc_warning_prev_line("MB is obsolete"); }
| T_MB sp rdata_unknown
{
zc_warning_prev_line("MB is obsolete");
$$ = $1;
parse_unknown_rdata($1, $3);
}
| T_MG sp rdata_domain_name
| T_MG sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_MR sp rdata_domain_name
| T_MR sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
/* NULL */
| T_WKS sp rdata_wks
| T_WKS sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_PTR sp rdata_domain_name
| T_PTR sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_HINFO sp rdata_hinfo
| T_HINFO sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_MINFO sp rdata_minfo /* Experimental */
| T_MINFO sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_MX sp rdata_mx
| T_MX sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_TXT sp rdata_txt
| T_TXT sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_SPF sp rdata_txt
| T_SPF sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_AVC sp rdata_txt
| T_AVC sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_RP sp rdata_rp /* RFC 1183 */
| T_RP sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_AFSDB sp rdata_afsdb /* RFC 1183 */
| T_AFSDB sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_X25 sp rdata_x25 /* RFC 1183 */
| T_X25 sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_ISDN sp rdata_isdn /* RFC 1183 */
| T_ISDN sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_IPSECKEY sp rdata_ipseckey /* RFC 4025 */
| T_IPSECKEY sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_DHCID sp rdata_dhcid
| T_DHCID sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_RT sp rdata_rt /* RFC 1183 */
| T_RT sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NSAP sp rdata_nsap /* RFC 1706 */
| T_NSAP sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_SIG sp rdata_rrsig
| T_SIG sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_KEY sp rdata_dnskey
| T_KEY sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_PX sp rdata_px /* RFC 2163 */
| T_PX sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_AAAA sp rdata_aaaa
| T_AAAA sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_LOC sp rdata_loc
| T_LOC sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NXT sp rdata_nxt
| T_NXT sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_SRV sp rdata_srv
| T_SRV sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NAPTR sp rdata_naptr /* RFC 2915 */
| T_NAPTR sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_KX sp rdata_kx /* RFC 2230 */
| T_KX sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_CERT sp rdata_cert /* RFC 2538 */
| T_CERT sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_DNAME sp rdata_domain_name /* RFC 2672 */
| T_DNAME sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_APL trail /* RFC 3123 */
| T_APL sp rdata_apl /* RFC 3123 */
| T_APL sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_DS sp rdata_ds
| T_DS sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_DLV sp rdata_dlv { if (dlv_warn) { dlv_warn = 0; zc_warning_prev_line("DLV is experimental"); } }
| T_DLV sp rdata_unknown { if (dlv_warn) { dlv_warn = 0; zc_warning_prev_line("DLV is experimental"); } $$ = $1; parse_unknown_rdata($1, $3); }
| T_SSHFP sp rdata_sshfp
| T_SSHFP sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); check_sshfp(); }
| T_RRSIG sp rdata_rrsig
| T_RRSIG sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NSEC sp rdata_nsec
| T_NSEC sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NSEC3 sp rdata_nsec3
| T_NSEC3 sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NSEC3PARAM sp rdata_nsec3_param
| T_NSEC3PARAM sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_DNSKEY sp rdata_dnskey
| T_DNSKEY sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_TLSA sp rdata_tlsa
| T_TLSA sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_SMIMEA sp rdata_smimea
| T_SMIMEA sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_NID sp rdata_nid
| T_NID sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_L32 sp rdata_l32
| T_L32 sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_L64 sp rdata_l64
| T_L64 sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_LP sp rdata_lp
| T_LP sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_EUI48 sp rdata_eui48
| T_EUI48 sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_EUI64 sp rdata_eui64
| T_EUI64 sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_CAA sp rdata_caa
| T_CAA sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_CDS sp rdata_ds
| T_CDS sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_CDNSKEY sp rdata_dnskey
| T_CDNSKEY sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_OPENPGPKEY sp rdata_openpgpkey
| T_OPENPGPKEY sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_CSYNC sp rdata_csync
| T_CSYNC sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_ZONEMD sp rdata_zonemd
| T_ZONEMD sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_SVCB sp rdata_svcb
| T_SVCB sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_HTTPS sp rdata_svcb
| T_HTTPS sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_URI sp rdata_uri
| T_URI sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| T_UTYPE sp rdata_unknown { $$ = $1; parse_unknown_rdata($1, $3); }
| str error NL
{
zc_error_prev_line("unrecognized RR type '%s'", $1.str);
}
;

/*
*
* below are all the definition for all the different rdata
*
*/

rdata_a: dotted_str trail
{
zadd_rdata_wireformat(zparser_conv_a(parser->region, $1.str));
}
;

rdata_domain_name: dname trail
{
/* convert a single dname record */
zadd_rdata_domain($1);
}
;

rdata_soa: dname sp dname sp str sp str sp str sp str sp str trail
{
/* convert the soa data */
zadd_rdata_domain($1); /* prim. ns */
zadd_rdata_domain($3); /* email */
zadd_rdata_wireformat(zparser_conv_serial(parser->region, $5.str)); /* serial */
zadd_rdata_wireformat(zparser_conv_period(parser->region, $7.str)); /* refresh */
zadd_rdata_wireformat(zparser_conv_period(parser->region, $9.str)); /* retry */
zadd_rdata_wireformat(zparser_conv_period(parser->region, $11.str)); /* expire */
zadd_rdata_wireformat(zparser_conv_period(parser->region, $13.str)); /* minimum */
}
;

rdata_wks: dotted_str sp str sp concatenated_str_seq trail
{
zadd_rdata_wireformat(zparser_conv_a(parser->region, $1.str)); /* address */
zadd_rdata_wireformat(zparser_conv_services(parser->region, $3.str, $5.str)); /* protocol and services */
}
;

rdata_hinfo: str sp str trail
{
zadd_rdata_wireformat(zparser_conv_text(parser->region, $1.str, $1.len)); /* CPU */
zadd_rdata_wireformat(zparser_conv_text(parser->region, $3.str, $3.len)); /* OS*/
}
;

rdata_minfo: dname sp dname trail
{
/* convert a single dname record */
zadd_rdata_domain($1);
zadd_rdata_domain($3);
}
;

rdata_mx: str sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* priority */
zadd_rdata_domain($3); /* MX host */
}
;

rdata_txt: str_seq trail
{
zadd_rdata_txt_clean_wireformat();
}
;

/* RFC 1183 */
rdata_rp: dname sp dname trail
{
zadd_rdata_domain($1); /* mbox d-name */
zadd_rdata_domain($3); /* txt d-name */
}
;

/* RFC 1183 */
rdata_afsdb: str sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* subtype */
zadd_rdata_domain($3); /* domain name */
}
;

/* RFC 1183 */
rdata_x25: str trail
{
zadd_rdata_wireformat(zparser_conv_text(parser->region, $1.str, $1.len)); /* X.25 address. */
}
;

/* RFC 1183 */
rdata_isdn: str trail
{
zadd_rdata_wireformat(zparser_conv_text(parser->region, $1.str, $1.len)); /* address */
}
| str sp str trail
{
zadd_rdata_wireformat(zparser_conv_text(parser->region, $1.str, $1.len)); /* address */
zadd_rdata_wireformat(zparser_conv_text(parser->region, $3.str, $3.len)); /* sub-address */
}
;

/* RFC 1183 */
rdata_rt: str sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* preference */
zadd_rdata_domain($3); /* intermediate host */
}
;

/* RFC 1706 */
rdata_nsap: str_dot_seq trail
{
/* String must start with "0x" or "0X". */
if (strncasecmp($1.str, "0x", 2) != 0) {
zc_error_prev_line("NSAP rdata must start with '0x'");
} else {
zadd_rdata_wireformat(zparser_conv_hex(parser->region, $1.str + 2, $1.len - 2)); /* NSAP */
}
}
;

/* RFC 2163 */
rdata_px: str sp dname sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* preference */
zadd_rdata_domain($3); /* MAP822 */
zadd_rdata_domain($5); /* MAPX400 */
}
;

rdata_aaaa: dotted_str trail
{
zadd_rdata_wireformat(zparser_conv_aaaa(parser->region, $1.str)); /* IPv6 address */
}
;

rdata_loc: concatenated_str_seq trail
{
zadd_rdata_wireformat(zparser_conv_loc(parser->region, $1.str)); /* Location */
}
;

rdata_nxt: dname sp nxt_seq trail
{
zadd_rdata_domain($1); /* nxt name */
zadd_rdata_wireformat(zparser_conv_nxt(parser->region, nxtbits)); /* nxt bitlist */
memset(nxtbits, 0, sizeof(nxtbits));
}
;

rdata_srv: str sp str sp str sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* prio */
zadd_rdata_wireformat(zparser_conv_short(parser->region, $3.str)); /* weight */
zadd_rdata_wireformat(zparser_conv_short(parser->region, $5.str)); /* port */
zadd_rdata_domain($7); /* target name */
}
;

/* RFC 2915 */
rdata_naptr: str sp str sp str sp str sp str sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* order */
zadd_rdata_wireformat(zparser_conv_short(parser->region, $3.str)); /* preference */
zadd_rdata_wireformat(zparser_conv_text(parser->region, $5.str, $5.len)); /* flags */
zadd_rdata_wireformat(zparser_conv_text(parser->region, $7.str, $7.len)); /* service */
zadd_rdata_wireformat(zparser_conv_text(parser->region, $9.str, $9.len)); /* regexp */
zadd_rdata_domain($11); /* target name */
}
;

/* RFC 2230 */
rdata_kx: str sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* preference */
zadd_rdata_domain($3); /* exchanger */
}
;

/* RFC 2538 */
rdata_cert: str sp str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_certificate_type(parser->region, $1.str)); /* type */
zadd_rdata_wireformat(zparser_conv_short(parser->region, $3.str)); /* key tag */
zadd_rdata_wireformat(zparser_conv_algorithm(parser->region, $5.str)); /* algorithm */
zadd_rdata_wireformat(zparser_conv_b64(parser->region, $7.str)); /* certificate or CRL */
}
;

/* RFC 3123 */
rdata_apl: rdata_apl_seq trail
;

rdata_apl_seq: dotted_str
{
zadd_rdata_wireformat(zparser_conv_apl_rdata(parser->region, $1.str));
}
| rdata_apl_seq sp dotted_str
{
zadd_rdata_wireformat(zparser_conv_apl_rdata(parser->region, $3.str));
}
;

rdata_ds: str sp str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* keytag */
zadd_rdata_wireformat(zparser_conv_algorithm(parser->region, $3.str)); /* alg */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $5.str)); /* type */
zadd_rdata_wireformat(zparser_conv_hex(parser->region, $7.str, $7.len)); /* hash */
}
;

rdata_dlv: str sp str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* keytag */
zadd_rdata_wireformat(zparser_conv_algorithm(parser->region, $3.str)); /* alg */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $5.str)); /* type */
zadd_rdata_wireformat(zparser_conv_hex(parser->region, $7.str, $7.len)); /* hash */
}
;

rdata_sshfp: str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $1.str)); /* alg */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $3.str)); /* fp type */
zadd_rdata_wireformat(zparser_conv_hex(parser->region, $5.str, $5.len)); /* hash */
check_sshfp();
}
;

rdata_dhcid: str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_b64(parser->region, $1.str)); /* data blob */
}
;

rdata_rrsig: str sp str sp str sp str sp str sp str sp str sp wire_dname sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_rrtype(parser->region, $1.str)); /* rr covered */
zadd_rdata_wireformat(zparser_conv_algorithm(parser->region, $3.str)); /* alg */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $5.str)); /* # labels */
zadd_rdata_wireformat(zparser_conv_period(parser->region, $7.str)); /* # orig TTL */
zadd_rdata_wireformat(zparser_conv_time(parser->region, $9.str)); /* sig exp */
zadd_rdata_wireformat(zparser_conv_time(parser->region, $11.str)); /* sig inc */
zadd_rdata_wireformat(zparser_conv_short(parser->region, $13.str)); /* key id */
zadd_rdata_wireformat(zparser_conv_dns_name(parser->region,
(const uint8_t*) $15.str,$15.len)); /* sig name */
zadd_rdata_wireformat(zparser_conv_b64(parser->region, $17.str)); /* sig data */
}
;

rdata_nsec: wire_dname nsec_seq
{
zadd_rdata_wireformat(zparser_conv_dns_name(parser->region,
(const uint8_t*) $1.str, $1.len)); /* nsec name */
zadd_rdata_wireformat(zparser_conv_nsec(parser->region, nsecbits)); /* nsec bitlist */
memset(nsecbits, 0, sizeof(nsecbits));
nsec_highest_rcode = 0;
}
;

rdata_nsec3: str sp str sp str sp str sp str nsec_seq
{
#ifdef NSEC3
nsec3_add_params($1.str, $3.str, $5.str, $7.str, $7.len);

zadd_rdata_wireformat(zparser_conv_b32(parser->region, $9.str)); /* next hashed name */
zadd_rdata_wireformat(zparser_conv_nsec(parser->region, nsecbits)); /* nsec bitlist */
memset(nsecbits, 0, sizeof(nsecbits));
nsec_highest_rcode = 0;
#else
zc_error_prev_line("nsec3 not supported");
#endif /* NSEC3 */
}
;

rdata_nsec3_param: str sp str sp str sp str trail
{
#ifdef NSEC3
nsec3_add_params($1.str, $3.str, $5.str, $7.str, $7.len);
#else
zc_error_prev_line("nsec3 not supported");
#endif /* NSEC3 */
}
;

rdata_tlsa: str sp str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $1.str)); /* usage */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $3.str)); /* selector */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $5.str)); /* matching type */
zadd_rdata_wireformat(zparser_conv_hex(parser->region, $7.str, $7.len)); /* ca data */
}
;

rdata_smimea: str sp str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $1.str)); /* usage */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $3.str)); /* selector */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $5.str)); /* matching type */
zadd_rdata_wireformat(zparser_conv_hex(parser->region, $7.str, $7.len)); /* ca data */
}
;

rdata_dnskey: str sp str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* flags */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $3.str)); /* proto */
zadd_rdata_wireformat(zparser_conv_algorithm(parser->region, $5.str)); /* alg */
zadd_rdata_wireformat(zparser_conv_b64(parser->region, $7.str)); /* hash */
}
;

rdata_ipsec_base: str sp str sp str sp dotted_str
{
const dname_type* name = 0;
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $1.str)); /* precedence */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $3.str)); /* gateway type */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $5.str)); /* algorithm */
switch(atoi($3.str)) {
case IPSECKEY_NOGATEWAY:
zadd_rdata_wireformat(alloc_rdata_init(parser->region, "", 0));
break;
case IPSECKEY_IP4:
zadd_rdata_wireformat(zparser_conv_a(parser->region, $7.str));
break;
case IPSECKEY_IP6:
zadd_rdata_wireformat(zparser_conv_aaaa(parser->region, $7.str));
break;
case IPSECKEY_DNAME:
/* convert and insert the dname */
if(strlen($7.str) == 0)
zc_error_prev_line("IPSECKEY must specify gateway name");
if(!(name = dname_parse(parser->region, $7.str))) {
zc_error_prev_line("IPSECKEY bad gateway dname %s", $7.str);
break;
}
if($7.str[strlen($7.str)-1] != '.') {
if(parser->origin == error_domain) {
zc_error("cannot concatenate origin to domain name, because origin failed to parse");
break;
} else if(name->name_size + domain_dname(parser->origin)->name_size - 1 > MAXDOMAINLEN) {
zc_error("ipsec gateway name exceeds %d character limit",
MAXDOMAINLEN);
break;
}
name = dname_concatenate(parser->rr_region, name,
domain_dname(parser->origin));
}
zadd_rdata_wireformat(alloc_rdata_init(parser->region,
dname_name(name), name->name_size));
break;
default:
zc_error_prev_line("unknown IPSECKEY gateway type");
}
}
;

rdata_ipseckey: rdata_ipsec_base sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_b64(parser->region, $3.str)); /* public key */
}
| rdata_ipsec_base trail
;

/* RFC 6742 */
rdata_nid: str sp dotted_str trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* preference */
zadd_rdata_wireformat(zparser_conv_ilnp64(parser->region, $3.str)); /* NodeID */
}
;

rdata_l32: str sp dotted_str trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* preference */
zadd_rdata_wireformat(zparser_conv_a(parser->region, $3.str)); /* Locator32 */
}
;

rdata_l64: str sp dotted_str trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* preference */
zadd_rdata_wireformat(zparser_conv_ilnp64(parser->region, $3.str)); /* Locator64 */
}
;

rdata_lp: str sp dname trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* preference */
zadd_rdata_domain($3); /* FQDN */
}
;

rdata_eui48: str trail
{
zadd_rdata_wireformat(zparser_conv_eui(parser->region, $1.str, 48));
}
;

rdata_eui64: str trail
{
zadd_rdata_wireformat(zparser_conv_eui(parser->region, $1.str, 64));
}
;

/* RFC7553 */
rdata_uri: str sp str sp dotted_str trail
{
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str)); /* priority */
zadd_rdata_wireformat(zparser_conv_short(parser->region, $3.str)); /* weight */
zadd_rdata_wireformat(zparser_conv_long_text(parser->region, $5.str, $5.len)); /* target */
}
;

/* RFC 6844 */
rdata_caa: str sp str sp dotted_str trail
{
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $1.str)); /* Flags */
zadd_rdata_wireformat(zparser_conv_tag(parser->region, $3.str, $3.len)); /* Tag */
zadd_rdata_wireformat(zparser_conv_long_text(parser->region, $5.str, $5.len)); /* Value */
}
;

/* RFC7929 */
rdata_openpgpkey: str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_b64(parser->region, $1.str));
}
;

/* RFC7477 */
rdata_csync: str sp str nsec_seq
{
zadd_rdata_wireformat(zparser_conv_serial(parser->region, $1.str));
zadd_rdata_wireformat(zparser_conv_short(parser->region, $3.str));
zadd_rdata_wireformat(zparser_conv_nsec(parser->region, nsecbits)); /* nsec bitlist */
memset(nsecbits, 0, sizeof(nsecbits));
nsec_highest_rcode = 0;
}
;

/* draft-ietf-dnsop-dns-zone-digest */
rdata_zonemd: str sp str sp str sp str_sp_seq trail
{
zadd_rdata_wireformat(zparser_conv_serial(parser->region, $1.str)); /* serial */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $3.str)); /* scheme */
zadd_rdata_wireformat(zparser_conv_byte(parser->region, $5.str)); /* hash algorithm */
zadd_rdata_wireformat(zparser_conv_hex(parser->region, $7.str, $7.len)); /* digest */
}
;

svcparam: dotted_str QSTR
{
zadd_rdata_wireformat(zparser_conv_svcbparam(
parser->region, $1.str, $1.len, $2.str, $2.len));
}
| dotted_str
{
zadd_rdata_wireformat(zparser_conv_svcbparam(
parser->region, $1.str, $1.len, NULL, 0));
}
;
svcparams: svcparam
| svcparams sp svcparam
;
/* draft-ietf-dnsop-svcb-https */
rdata_svcb_base: str sp dname
{
/* SvcFieldPriority */
zadd_rdata_wireformat(zparser_conv_short(parser->region, $1.str));
/* SvcDomainName */
zadd_rdata_domain($3);
};
rdata_svcb: rdata_svcb_base sp svcparams trail
{
zadd_rdata_svcb_check_wireformat();
}
| rdata_svcb_base trail
;

rdata_unknown: URR sp str sp str_sp_seq trail
{
/* $2 is the number of octets, currently ignored */
$$ = zparser_conv_hex(parser->rr_region, $5.str, $5.len);

}
| URR sp str trail
{
$$ = zparser_conv_hex(parser->rr_region, "", 0);
}
| URR error NL
{
$$ = zparser_conv_hex(parser->rr_region, "", 0);
}
;
%%

int
yywrap(void)
{
return 1;
}

/*
* Create the parser.
*/
zparser_type *
zparser_create(region_type *region, region_type *rr_region, namedb_type *db)
{
zparser_type *result;

result = (zparser_type *) region_alloc(region, sizeof(zparser_type));
result->region = region;
result->rr_region = rr_region;
result->db = db;

result->filename = NULL;
result->current_zone = NULL;
result->origin = NULL;
result->prev_dname = NULL;

result->temporary_rdatas = (rdata_atom_type *) region_alloc_array(
result->region, MAXRDATALEN, sizeof(rdata_atom_type));

return result;
}

/*
* Initialize the parser for a new zone file.
*/
void
zparser_init(const char *filename, uint32_t ttl, uint16_t klass,
const dname_type *origin)
{
memset(nxtbits, 0, sizeof(nxtbits));
memset(nsecbits, 0, sizeof(nsecbits));
nsec_highest_rcode = 0;

parser->default_ttl = ttl;
parser->default_class = klass;
parser->current_zone = NULL;
parser->origin = domain_table_insert(parser->db->domains, origin);
parser->prev_dname = parser->origin;
parser->error_occurred = 0;
parser->errors = 0;
parser->line = 1;
parser->filename = filename;
parser->current_rr.rdata_count = 0;
parser->current_rr.rdatas = parser->temporary_rdatas;
}

void
yyerror(const char *message)
{
zc_error("%s", message);
}

static void
error_va_list(unsigned line, const char *fmt, va_list args)
{
if (parser->filename) {
char message[MAXSYSLOGMSGLEN];
vsnprintf(message, sizeof(message), fmt, args);
log_msg(LOG_ERR, "%s:%u: %s", parser->filename, line, message);
}
else log_vmsg(LOG_ERR, fmt, args);

++parser->errors;
parser->error_occurred = 1;
}

/* the line counting sux, to say the least
* with this grose hack we try do give sane
* numbers back */
void
zc_error_prev_line(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
error_va_list(parser->line - 1, fmt, args);
va_end(args);
}

void
zc_error(const char *fmt, ...)
{
/* send an error message to stderr */
va_list args;
va_start(args, fmt);
error_va_list(parser->line, fmt, args);
va_end(args);
}

static void
warning_va_list(unsigned line, const char *fmt, va_list args)
{
if (parser->filename) {
char m[MAXSYSLOGMSGLEN];
vsnprintf(m, sizeof(m), fmt, args);
log_msg(LOG_WARNING, "%s:%u: %s", parser->filename, line, m);
}
else log_vmsg(LOG_WARNING, fmt, args);
}

void
zc_warning_prev_line(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
warning_va_list(parser->line - 1, fmt, args);
va_end(args);
}

void
zc_warning(const char *fmt, ... )
{
va_list args;
va_start(args, fmt);
warning_va_list(parser->line, fmt, args);
va_end(args);
}

#ifdef NSEC3
static void
nsec3_add_params(const char* hashalgo_str, const char* flag_str,
const char* iter_str, const char* salt_str, int salt_len)
{
zadd_rdata_wireformat(zparser_conv_byte(parser->region, hashalgo_str));
zadd_rdata_wireformat(zparser_conv_byte(parser->region, flag_str));
zadd_rdata_wireformat(zparser_conv_short(parser->region, iter_str));

/* salt */
if(strcmp(salt_str, "-") != 0)
zadd_rdata_wireformat(zparser_conv_hex_length(parser->region,
salt_str, salt_len));
else
zadd_rdata_wireformat(alloc_rdata_init(parser->region, "", 1));
}
#endif /* NSEC3 */