From f449f278dd3c70e479a035f50a9bb817a9b433ba Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 17:24:08 +0200 Subject: Adding upstream version 3.2.6. Signed-off-by: Daniel Baumann --- src/libzscanner/scanner_body.rl | 2326 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 2326 insertions(+) create mode 100644 src/libzscanner/scanner_body.rl (limited to 'src/libzscanner/scanner_body.rl') diff --git a/src/libzscanner/scanner_body.rl b/src/libzscanner/scanner_body.rl new file mode 100644 index 0000000..34d51cd --- /dev/null +++ b/src/libzscanner/scanner_body.rl @@ -0,0 +1,2326 @@ +/* Copyright (C) 2021 CZ.NIC, z.s.p.o. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + */ + +%%{ + machine zone_scanner; + + # Comeback function to calling state machine. + action _ret { + fhold; fret; + } + + # BEGIN - Blank space processing + action _newline { + s->line_counter++; + } + + action _check_multiline_begin { + if (s->multiline == true) { + ERR(ZS_LEFT_PARENTHESIS); + fhold; fgoto err_line; + } + s->multiline = true; + } + action _check_multiline_end { + if (s->multiline == false) { + ERR(ZS_RIGHT_PARENTHESIS); + fhold; fgoto err_line; + } + s->multiline = false; + } + + action _comment_init { + s->buffer_length = 0; + } + action _comment { + if (s->buffer_length < sizeof(s->buffer) - 1) { + s->buffer[s->buffer_length++] = fc; + } + } + action _comment_exit { + s->buffer[s->buffer_length++] = 0; + + // Execute the comment callback. + if (s->process.automatic && s->process.comment != NULL) { + s->process.comment(s); + + // Stop if required from the callback. + if (s->state == ZS_STATE_STOP) { + fbreak; + } + } + } + + action _rest_init { + s->buffer[0] = 0; + s->buffer_length = 0; + } + action _rest_error { + WARN(ZS_BAD_REST); + fhold; fgoto err_line; + } + + newline = '\n' $_newline; + comment = (';' . (^newline)* $_comment) >_comment_init %_comment_exit; + + # White space separation. With respect to parentheses and included comments. + sep = ( [ \t] # Blank characters. + | (comment? . newline) when { s->multiline } # Comment in multiline. + | '(' $_check_multiline_begin # Start of multiline. + | ')' $_check_multiline_end # End of multiline. + )+; # Apply more times. + + rest = (sep? :> comment?) >_rest_init $!_rest_error; # Comments. + + # Artificial machines which are used for next state transition only! + all_wchar = [ \t\n;()]; + end_wchar = [\n;] when { !s->multiline }; # For noncontinuous ending tokens. + # END + + # BEGIN - Error line processing + action _err_line_init { + s->buffer_length = 0; + } + action _err_line { + if (fc == '\r') { + ERR(ZS_DOS_NEWLINE); + } + + if (s->buffer_length < sizeof(s->buffer) - 1) { + s->buffer[s->buffer_length++] = fc; + } + } + action _err_line_exit { + // Terminate the error context string. + s->buffer[s->buffer_length++] = 0; + + // Error counter incrementation. + s->error.counter++; + + // Initialize the fcall stack. + top = 0; + + // Reset per-record contexts. + s->long_string = false; + s->comma_list = false; + + s->state = ZS_STATE_ERROR; + + // Execute the error callback. + if (s->process.automatic) { + fhold; + if (s->process.error != NULL) { + s->process.error(s); + + // Stop if required from the callback. + if (s->state == ZS_STATE_STOP) { + fbreak; + } + } + + // Stop the scanner if fatal error. + if (s->error.fatal) { + fbreak; + } + fgoto err_rest; + } else { + // Return if external processing. + fhold; fnext err_rest; fbreak; + } + } + + # Consume rest lines of defective multiline record. + err_rest := ( (any - newline - ')') + | newline when { s->multiline } + | ')' when { s->multiline } $_check_multiline_end + )* %{ fhold; fcall main; } <: newline; + + # Fill rest of the line to buffer and skip to main loop. + err_line := (^newline $_err_line)* >_err_line_init + %_err_line_exit . newline; + # END + + # BEGIN - Domain name labels processing + action _label_init { + s->item_length = 0; + s->item_length_position = s->dname_tmp_length++; + } + action _label_char { + // Check for maximum dname label length. + if (s->item_length < ZS_MAX_LABEL_LENGTH) { + (s->dname)[s->dname_tmp_length++] = fc; + s->item_length++; + } else { + WARN(ZS_LABEL_OVERFLOW); + fhold; fgoto err_line; + } + } + action _label_exit { + // Check for maximum dname length overflow after each label. + // (at least the next label length must follow). + if (s->dname_tmp_length < ZS_MAX_DNAME_LENGTH) { + (s->dname)[s->item_length_position] = + (uint8_t)(s->item_length); + } else { + WARN(ZS_DNAME_OVERFLOW); + fhold; fgoto err_line; + } + } + + action _label_dec_init { + if (s->item_length < ZS_MAX_LABEL_LENGTH) { + (s->dname)[s->dname_tmp_length] = 0; + s->item_length++; + } else { + WARN(ZS_LABEL_OVERFLOW); + fhold; fgoto err_line; + } + } + action _label_dec { + (s->dname)[s->dname_tmp_length] *= 10; + (s->dname)[s->dname_tmp_length] += digit_to_num[(uint8_t)fc]; + } + action _label_dec_exit { + s->dname_tmp_length++; + } + action _label_dec_error { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + + label_char = + ( (alnum | [*\-_/]) $_label_char # One common char. + | ('\\' . ^digit) @_label_char # One "\x" char. + | ('\\' %_label_dec_init # Initial "\" char. + . digit {3} $_label_dec %_label_dec_exit # "DDD" rest. + $!_label_dec_error + ) + ); + + label = label_char+ >_label_init %_label_exit; + labels = (label . '.')* . label; + # END + + # BEGIN - Domain name processing. + action _absolute_dname_exit { + // Enough room for the terminal label is guaranteed (_label_exit). + (s->dname)[s->dname_tmp_length++] = 0; + } + action _relative_dname_exit { + // Check for (relative + origin) dname length overflow. + if (s->dname_tmp_length + s->zone_origin_length <= ZS_MAX_DNAME_LENGTH) { + memcpy(s->dname + s->dname_tmp_length, + s->zone_origin, + s->zone_origin_length); + + s->dname_tmp_length += s->zone_origin_length; + } else { + WARN(ZS_DNAME_OVERFLOW); + fhold; fgoto err_line; + } + } + action _origin_dname_exit { + // Copy already verified zone origin. + memcpy(s->dname, + s->zone_origin, + s->zone_origin_length); + + s->dname_tmp_length = s->zone_origin_length; + } + + action _dname_init { + s->item_length_position = 0; + s->dname_tmp_length = 0; + } + action _dname_error { + WARN(ZS_BAD_DNAME_CHAR); + fhold; fgoto err_line; + } + + relative_dname = (labels ) >_dname_init %_relative_dname_exit; + absolute_dname = (labels? . '.') >_dname_init %_absolute_dname_exit; + + dname_ := ( relative_dname + | absolute_dname + | '@' %_origin_dname_exit + ) $!_dname_error %_ret . all_wchar; + dname = (alnum | [\-_/\\] | [*.@]) ${ fhold; fcall dname_; }; + # END + + # BEGIN - Common r_data item processing + action _item_length_init { + if (rdata_tail <= rdata_stop) { + s->item_length_location = rdata_tail++; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _item_length_exit { + s->item_length = rdata_tail - s->item_length_location - 1; + if (s->comma_list && s->item_length == 0) { + WARN(ZS_EMPTY_LIST_ITEM); + fhold; fgoto err_line; + } + if (s->item_length <= MAX_ITEM_LENGTH) { + *(s->item_length_location) = (uint8_t)(s->item_length); + } else { + WARN(ZS_ITEM_OVERFLOW); + fhold; fgoto err_line; + } + } + action _item_length2_init { + if (rdata_tail < rdata_stop) { + s->item_length2_location = rdata_tail; + rdata_tail += 2; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _item_length2_exit { + s->item_length = rdata_tail - s->item_length2_location - 2; + + if (s->item_length <= MAX_ITEM_LENGTH2) { + uint16_t val = htons((uint16_t)(s->item_length)); + memcpy(s->item_length2_location, &val, 2); + } else { + WARN(ZS_ITEM_OVERFLOW); + fhold; fgoto err_line; + } + } + # END + + # BEGIN - Owner processing + action _r_owner_init { + s->dname = s->r_owner; + s->r_owner_length = 0; + } + action _r_owner_exit { + s->r_owner_length = s->dname_tmp_length; + } + action _r_owner_empty_exit { + if (s->r_owner_length == 0) { + WARN(ZS_BAD_PREVIOUS_OWNER); + fhold; fgoto err_line; + } + } + action _r_owner_error { + s->r_owner_length = 0; + WARN(ZS_BAD_OWNER); + fhold; fgoto err_line; + } + + r_owner = ( dname >_r_owner_init %_r_owner_exit + | zlen %_r_owner_empty_exit # Empty owner - use the previous one. + ) $!_r_owner_error; + # END + + # BEGIN - domain name in record data processing + action _r_dname_init { + s->dname = rdata_tail; + } + action _r_dname_exit { + rdata_tail += s->dname_tmp_length; + } + + r_dname = dname >_r_dname_init %_r_dname_exit; + # END + + # BEGIN - Number processing + action _number_digit { + // Overflow check: 10*(s->number64) + fc - '0' <= UINT64_MAX + if ((s->number64 < (UINT64_MAX / 10)) || // Dominant fast check. + ((s->number64 == (UINT64_MAX / 10)) && // Marginal case. + ((uint8_t)fc <= (UINT64_MAX % 10) + '0') + ) + ) { + s->number64 *= 10; + s->number64 += digit_to_num[(uint8_t)fc]; + } else { + WARN(ZS_NUMBER64_OVERFLOW); + fhold; fgoto err_line; + } + } + + number_digit = [0-9] $_number_digit; + + action _number_init { + s->number64 = 0; + } + action _number_error { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + + # General integer number that cover all necessary integer ranges. + number = number_digit+ >_number_init; + + action _float_init { + s->decimal_counter = 0; + } + action _decimal_init { + s->number64_tmp = s->number64; + } + action _decimal_digit { + s->decimal_counter++; + } + + action _float_exit { + if (s->decimal_counter == 0 && s->number64 < UINT32_MAX) { + s->number64 *= pow(10, s->decimals); + } else if (s->decimal_counter <= s->decimals && + s->number64_tmp < UINT32_MAX) { + s->number64 *= pow(10, s->decimals - s->decimal_counter); + s->number64 += s->number64_tmp * pow(10, s->decimals); + } else { + WARN(ZS_FLOAT_OVERFLOW); + fhold; fgoto err_line; + } + } + + # Next float can't be used directly (doesn't contain decimals init)! + float = (number . ('.' . number? >_decimal_init $_decimal_digit)?) + >_float_init %_float_exit; + + action _float2_init { + s->decimals = 2; + } + action _float3_init { + s->decimals = 3; + } + + # Float number (in hundredths)with 2 possible decimal digits. + float2 = float >_float2_init; + # Float number (in thousandths) with 3 possible decimal digits. + float3 = float >_float3_init; + + action _num8_write { + if (s->number64 <= UINT8_MAX) { + *rdata_tail = (uint8_t)(s->number64); + rdata_tail += 1; + } else { + WARN(ZS_NUMBER8_OVERFLOW); + fhold; fgoto err_line; + } + } + action _num16_write { + if (s->number64 <= UINT16_MAX) { + uint16_t num16 = htons((uint16_t)s->number64); + memcpy(rdata_tail, &num16, 2); + rdata_tail += 2; + } else { + WARN(ZS_NUMBER16_OVERFLOW); + fhold; fgoto err_line; + } + } + action _num32_write { + if (s->number64 <= UINT32_MAX) { + uint32_t num32 = htonl((uint32_t)s->number64); + memcpy(rdata_tail, &num32, 4); + rdata_tail += 4; + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + + action _type_number_exit { + if (s->number64 <= UINT16_MAX) { + s->r_type = (uint16_t)(s->number64); + } else { + WARN(ZS_NUMBER16_OVERFLOW); + fhold; fgoto err_line; + } + } + + action _length_number_exit { + if (s->number64 <= UINT16_MAX) { + s->r_data_length = (uint16_t)(s->number64); + } else { + WARN(ZS_NUMBER16_OVERFLOW); + fhold; fgoto err_line; + } + } + num8 = number %_num8_write $!_number_error; + num16 = number %_num16_write $!_number_error; + num32 = number %_num32_write $!_number_error; + + type_number = number %_type_number_exit $!_number_error; + length_number = number %_length_number_exit $!_number_error; + # END + + # BEGIN - Time processing + action _time_unit_error { + WARN(ZS_BAD_TIME_UNIT); + fhold; fgoto err_line; + } + + time_unit = + ( 's'i + | 'm'i ${ if (s->number64 <= (UINT32_MAX / 60)) { + s->number64 *= 60; + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + | 'h'i ${ if (s->number64 <= (UINT32_MAX / 3600)) { + s->number64 *= 3600; + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + | 'd'i ${ if (s->number64 <= (UINT32_MAX / 86400)) { + s->number64 *= 86400; + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + | 'w'i ${ if (s->number64 <= (UINT32_MAX / 604800)) { + s->number64 *= 604800; + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + ) $!_time_unit_error; + + + action _time_block_init { + s->number64_tmp = s->number64; + } + action _time_block_exit { + if (s->number64 + s->number64_tmp < UINT32_MAX) { + s->number64 += s->number64_tmp; + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + + time_block = (number . time_unit) >_time_block_init %_time_block_exit; + + # Time is either a number or a sequence of time blocks (1w1h1m). + time = (number . (time_unit . (time_block)*)?) $!_number_error; + + time32 = time %_num32_write; + # END + + # BEGIN - Timestamp processing + action _timestamp_init { + s->buffer_length = 0; + } + action _timestamp { + if (s->buffer_length < sizeof(s->buffer) - 1) { + s->buffer[s->buffer_length++] = fc; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _timestamp_exit { + s->buffer[s->buffer_length] = 0; + + if (s->buffer_length == 14) { // Date; 14 = len("YYYYMMDDHHmmSS"). + uint32_t timestamp; + int ret = date_to_timestamp(s->buffer, ×tamp); + + if (ret == ZS_OK) { + *((uint32_t *)rdata_tail) = htonl(timestamp); + rdata_tail += 4; + } else { + WARN(ret); + fhold; fgoto err_line; + } + } else if (s->buffer_length <= 10) { // Timestamp format. + char *end; + + s->number64 = strtoull((char *)(s->buffer), &end, 10); + + if (end == (char *)(s->buffer) || *end != '\0') { + WARN(ZS_BAD_TIMESTAMP); + fhold; fgoto err_line; + } + + if (s->number64 <= UINT32_MAX) { + *((uint32_t *)rdata_tail) = htonl((uint32_t)s->number64); + rdata_tail += 4; + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } else { + WARN(ZS_BAD_TIMESTAMP_LENGTH); + fhold; fgoto err_line; + } + } + action _timestamp_error { + WARN(ZS_BAD_TIMESTAMP_CHAR); + fhold; fgoto err_line; + } + + timestamp = digit+ >_timestamp_init $_timestamp + %_timestamp_exit $!_timestamp_error; + # END + + # BEGIN - Text processing + action _text_char { + if (rdata_tail <= rdata_stop) { + // Split long string. + if (s->long_string && + rdata_tail - s->item_length_location == 1 + MAX_ITEM_LENGTH) { + // _item_length_exit equivalent. + *(s->item_length_location) = MAX_ITEM_LENGTH; + // _item_length_init equivalent. + s->item_length_location = rdata_tail++; + + if (rdata_tail > rdata_stop) { + WARN(ZS_TEXT_OVERFLOW); + fhold; fgoto err_line; + } + } + + *(rdata_tail++) = fc; + } else { + WARN(ZS_TEXT_OVERFLOW); + fhold; fgoto err_line; + } + } + action _text_char_error { + WARN(ZS_BAD_TEXT_CHAR); + fhold; fgoto err_line; + } + action _text_error { + WARN(ZS_BAD_TEXT); + fhold; fgoto err_line; + } + + action _text_dec_init { + if (rdata_tail <= rdata_stop) { + // Split long string. + if (s->long_string && + rdata_tail - s->item_length_location == 1 + MAX_ITEM_LENGTH) { + // _item_length_exit equivalent. + *(s->item_length_location) = MAX_ITEM_LENGTH; + // _item_length_init equivalent. + s->item_length_location = rdata_tail++; + + if (rdata_tail > rdata_stop) { + WARN(ZS_TEXT_OVERFLOW); + fhold; fgoto err_line; + } + } + + *rdata_tail = 0; + s->item_length++; + } else { + WARN(ZS_TEXT_OVERFLOW); + fhold; fgoto err_line; + } + } + action _text_dec { + if ((*rdata_tail < (UINT8_MAX / 10)) || // Dominant fast check. + ((*rdata_tail == (UINT8_MAX / 10)) && // Marginal case. + (fc <= (UINT8_MAX % 10) + '0') + ) + ) { + *rdata_tail *= 10; + *rdata_tail += digit_to_num[(uint8_t)fc]; + } else { + WARN(ZS_NUMBER8_OVERFLOW); + fhold; fgoto err_line; + } + } + action _text_dec_exit { + rdata_tail++; + } + action _text_dec_error { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + + action _comma_list { + uint8_t *last_two = rdata_tail - 2; + uint16_t current_len = rdata_tail - s->item_length_location - 2; + if (s->comma_list) { + if (last_two[1] == ',') { + if (current_len <= 1) { + WARN(ZS_EMPTY_LIST_ITEM); + fhold; fgoto err_line; + } else if (last_two[0] != '\\') { // Start a new item. + *(s->item_length_location) = current_len; + s->item_length_location = rdata_tail - 1; + } else { // Remove backslash. + last_two[0] = ','; + rdata_tail--; + } + } else if (current_len > 1 && last_two[1] == '\\') { + if (last_two[0] == '\\') { // Remove backslash. + rdata_tail--; + } + } + } + } + + text_char = + ( (33..126 - [\\;\"]) $_text_char # One printable char. + | ('\\' . (32..126 - digit)) @_text_char # One "\x" char. + | ('\\' %_text_dec_init # Initial "\" char. + . digit {3} $_text_dec %_text_dec_exit # "DDD" rest. + $!_text_dec_error + ) + ) %_comma_list $!_text_char_error; + + quoted_text_char = + ( text_char + | ([ \t;] | [\n] when { s->multiline }) $_text_char + ) $!_text_char_error; + + # Text string machine instantiation (for smaller code). + text_ := (('\"' . quoted_text_char* . '\"') | text_char+) + $!_text_error %_ret . all_wchar; + text = ^all_wchar ${ fhold; fcall text_; }; + + # Text string with forward 1-byte length. + text_string = text >_item_length_init %_item_length_exit; + + action _text_array_init { + s->long_string = true; + } + action _text_array_exit { + s->long_string = false; + } + + # Text string array as one rdata item. + text_array = + ( (text_string . (sep . text_string)* . sep?) + ) >_text_array_init %_text_array_exit $!_text_array_exit; + # END + + # BEGIN - TTL directive processing + action _default_ttl_exit { + if (s->number64 <= UINT32_MAX) { + s->default_ttl = (uint32_t)(s->number64); + } else { + ERR(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + action _default_ttl_error { + ERR(ZS_BAD_TTL); + fhold; fgoto err_line; + } + + default_ttl_ := (sep . time . rest) $!_default_ttl_error + %_default_ttl_exit %_ret . newline; + default_ttl = all_wchar ${ fhold; fcall default_ttl_; }; + # END + + # BEGIN - ORIGIN directive processing + action _zone_origin_init { + s->dname = s->zone_origin; + } + action _zone_origin_exit { + s->zone_origin_length = s->dname_tmp_length; + } + action _zone_origin_error { + ERR(ZS_BAD_ORIGIN); + fhold; fgoto err_line; + } + + zone_origin_ := (sep . absolute_dname >_zone_origin_init . rest) + $!_zone_origin_error %_zone_origin_exit %_ret . newline; + zone_origin = all_wchar ${ fhold; fcall zone_origin_; }; + # END + + # BEGIN - INCLUDE directive processing + action _incl_filename_init { + rdata_tail = s->r_data; + } + action _incl_filename_exit { + size_t len = rdata_tail - s->r_data; + if (len >= sizeof(s->include_filename)) { + ERR(ZS_BAD_INCLUDE_FILENAME); + fhold; fgoto err_line; + } + + // Store zero terminated include filename. + memcpy(s->include_filename, s->r_data, len); + s->include_filename[len] = '\0'; + + // For detection whether origin is not present. + s->dname = NULL; + } + action _incl_filename_error { + ERR(ZS_BAD_INCLUDE_FILENAME); + fhold; fgoto err_line; + } + + action _incl_origin_init { + s->dname = s->r_data; + } + action _incl_origin_exit { + s->r_data_length = s->dname_tmp_length; + } + action _incl_origin_error { + ERR(ZS_BAD_INCLUDE_ORIGIN); + fhold; fgoto err_line; + } + + action _include_exit { + // Extend relative file path. + if (s->include_filename[0] != '/') { + int ret = snprintf((char *)(s->buffer), sizeof(s->buffer), + "%s/%s", s->path, s->include_filename); + if (ret <= 0 || ret >= sizeof(s->buffer)) { + ERR(ZS_BAD_INCLUDE_FILENAME); + fhold; fgoto err_line; + } + memcpy(s->include_filename, s->buffer, ret + 1); + } + + // Origin conversion from wire to text form in \DDD notation. + if (s->dname == NULL) { // Use current origin. + wire_dname_to_str(s->zone_origin, + s->zone_origin_length, + (char *)s->buffer); + } else { // Use specified origin. + wire_dname_to_str(s->r_data, + s->r_data_length, + (char *)s->buffer); + } + + // Let the caller to solve the include. + if (s->process.automatic) { + // Create new scanner for included zone file. + zs_scanner_t *ss = malloc(sizeof(zs_scanner_t)); + if (ss == NULL) { + ERR(ZS_UNPROCESSED_INCLUDE); + fhold; fgoto err_line; + } + + // Parse included zone file. + if (zs_init(ss, (char *)s->buffer, s->default_class, + s->default_ttl) != 0 || + zs_set_input_file(ss, (char *)(s->include_filename)) != 0 || + zs_set_processing(ss, s->process.record, s->process.error, + s->process.data) != 0 || + zs_parse_all(ss) != 0) { + // File internal errors are handled by error callback. + if (ss->error.counter > 0) { + s->error.counter += ss->error.counter; + ERR(ZS_UNPROCESSED_INCLUDE); + // General include file error. + } else { + ERR(ss->error.code); + } + zs_deinit(ss); + free(ss); + fhold; fgoto err_line; + } + zs_deinit(ss); + free(ss); + } else { + s->state = ZS_STATE_INCLUDE; + fhold; fnext main; fbreak; + } + } + + include_file_ := + (sep . text >_incl_filename_init %_incl_filename_exit + $!_incl_filename_error . + (sep . absolute_dname >_incl_origin_init %_incl_origin_exit + $!_incl_origin_error + )? . rest + ) %_include_exit %_ret newline; + include_file = all_wchar ${ fhold; fcall include_file_; }; + # END + + # BEGIN - Directive switch + # Each error/warning in directive should stop processing. + # Some internal errors cause warning only. This causes stop processing. + action _directive_init { + ERR(ZS_OK); + } + # Remove stop processing flag. + action _directive_exit { + NOERR; + } + action _directive_error { + ERR(ZS_BAD_DIRECTIVE); + fhold; fgoto err_line; + } + + directive = '$' . ( ("TTL"i . default_ttl) + | ("ORIGIN"i . zone_origin) + | ("INCLUDE"i . include_file) + ) >_directive_init %_directive_exit $!_directive_error; + # END + + # BEGIN - RRecord class and ttl processing + action _default_r_class_exit { + s->r_class = s->default_class; + } + + action _default_r_ttl_exit { + s->r_ttl = s->default_ttl; + } + + action _r_class_in_exit { + s->r_class = KNOT_CLASS_IN; + } + + action _r_ttl_exit { + if (s->number64 <= UINT32_MAX) { + s->r_ttl = (uint32_t)(s->number64); + } else { + WARN(ZS_NUMBER32_OVERFLOW); + fhold; fgoto err_line; + } + } + + r_class = "IN"i %_r_class_in_exit; + + r_ttl = time %_r_ttl_exit; + # END + + # BEGIN - IPv4 and IPv6 address processing + action _addr_init { + s->buffer_length = 0; + } + action _addr { + if (s->buffer_length < sizeof(s->buffer) - 1) { + s->buffer[s->buffer_length++] = fc; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _addr_error { + WARN(ZS_BAD_ADDRESS_CHAR); + fhold; fgoto err_line; + } + + action _ipv4_addr_exit { + s->buffer[s->buffer_length] = 0; + + if (inet_pton(AF_INET, (char *)s->buffer, s->addr) <= 0) { + WARN(ZS_BAD_IPV4); + fhold; fgoto err_line; + } + } + action _ipv4_addr_write { + if (rdata_tail + ZS_INET4_ADDR_LENGTH > rdata_stop + 1) { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + memcpy(rdata_tail, s->addr, ZS_INET4_ADDR_LENGTH); + rdata_tail += ZS_INET4_ADDR_LENGTH; + } + + action _ipv6_addr_exit { + s->buffer[s->buffer_length] = 0; + + if (inet_pton(AF_INET6, (char *)s->buffer, s->addr) <= 0) { + WARN(ZS_BAD_IPV6); + fhold; fgoto err_line; + } + } + action _ipv6_addr_write { + if (rdata_tail + ZS_INET6_ADDR_LENGTH > rdata_stop + 1) { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + memcpy(rdata_tail, s->addr, ZS_INET6_ADDR_LENGTH); + rdata_tail += ZS_INET6_ADDR_LENGTH; + } + + # Address parsers only. + ipv4_addr = (digit | '.')+ >_addr_init $_addr %_ipv4_addr_exit + $!_addr_error; + ipv6_addr = (xdigit | [.:])+ >_addr_init $_addr %_ipv6_addr_exit + $!_addr_error; + + # Write parsed address to r_data. + ipv4_addr_write = ipv4_addr %_ipv4_addr_write; + ipv6_addr_write = ipv6_addr %_ipv6_addr_write; + # END + + # BEGIN - apl record processing + action _apl_init { + memset(&(s->apl), 0, sizeof(s->apl)); + } + action _apl_excl_flag { + s->apl.excl_flag = 128; // dec 128 = bin 10000000. + } + action _apl_addr_1 { + s->apl.addr_family = 1; + } + action _apl_addr_2 { + s->apl.addr_family = 2; + } + action _apl_prefix_length { + if ((s->apl.addr_family == 1 && s->number64 <= 32) || + (s->apl.addr_family == 2 && s->number64 <= 128)) { + s->apl.prefix_length = (uint8_t)(s->number64); + } else { + WARN(ZS_BAD_APL); + fhold; fgoto err_line; + } + } + action _apl_exit { + // Copy address to buffer. + uint8_t len; + switch (s->apl.addr_family) { + case 1: + len = ZS_INET4_ADDR_LENGTH; + memcpy(s->buffer, s->addr, len); + break; + case 2: + len = ZS_INET6_ADDR_LENGTH; + memcpy(s->buffer, s->addr, len); + break; + default: + WARN(ZS_BAD_APL); + fhold; fgoto err_line; + } + // Find prefix without trailing zeroes. + while (len > 0) { + if ((s->buffer[len - 1] & 255) != 0) { + break; + } + len--; + } + // Check for rdata overflow. + if (rdata_tail + 4 + len > rdata_stop + 1) { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + // Write address family. + uint16_t af = htons(s->apl.addr_family); + memcpy(rdata_tail, &af, sizeof(af)); + rdata_tail += 2; + // Write prefix length in bits. + *(rdata_tail) = s->apl.prefix_length; + rdata_tail += 1; + // Write negation flag + prefix length in bytes. + *(rdata_tail) = len + s->apl.excl_flag; + rdata_tail += 1; + // Write address prefix non-null data. + memcpy(rdata_tail, s->buffer, len); + rdata_tail += len; + } + action _apl_error { + WARN(ZS_BAD_APL); + fhold; fgoto err_line; + } + + apl = ('!'? $_apl_excl_flag . + ( ('1' $_apl_addr_1 . ':' . ipv4_addr . '/' . number + %_apl_prefix_length) + | ('2' $_apl_addr_2 . ':' . ipv6_addr . '/' . number + %_apl_prefix_length) + ) + ) >_apl_init %_apl_exit $!_apl_error; + + # Array of APL records (can be empty). + apl_array = apl? . (sep . apl)* . sep?; + # END + + # BEGIN - Hexadecimal string array processing + action _first_hex_char { + if (rdata_tail <= rdata_stop) { + *rdata_tail = first_hex_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _second_hex_char { + *rdata_tail += second_hex_to_num[(uint8_t)fc]; + rdata_tail++; + } + action _hex_char_error { + WARN(ZS_BAD_HEX_CHAR); + fhold; fgoto err_line; + } + + hex_char = (xdigit $_first_hex_char . xdigit $_second_hex_char); + + # Hex array with possibility of inside white spaces and multiline. + hex_array = (hex_char+ . sep?)+ $!_hex_char_error; + + # Continuous hex array (or "-") with forward length processing. + salt = (hex_char+ | '-') >_item_length_init %_item_length_exit + $!_hex_char_error; + + action _type_data_exit { + if ((rdata_tail - s->r_data) != s->r_data_length) { + WARN(ZS_BAD_RDATA_LENGTH); + fhold; fgoto err_line; + } + } + + action _type_data_error { + WARN(ZS_BAD_HEX_RDATA); + fhold; fgoto err_line; + } + + # Hex array with control to forward length statement. + type_data = hex_array %_type_data_exit $!_type_data_error; + # END + + # BEGIN - Base64 processing (RFC 4648) + action _first_base64_char { + if (rdata_tail <= rdata_stop) { + *rdata_tail = first_base64_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _second_base64_char { + *(rdata_tail++) += second_left_base64_to_num[(uint8_t)fc]; + + if (rdata_tail <= rdata_stop) { + *rdata_tail = second_right_base64_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _third_base64_char { + *(rdata_tail++) += third_left_base64_to_num[(uint8_t)fc]; + + if (rdata_tail <= rdata_stop) { + *rdata_tail = third_right_base64_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _fourth_base64_char { + *(rdata_tail++) += fourth_base64_to_num[(uint8_t)fc]; + } + + action _base64_char_error { + WARN(ZS_BAD_BASE64_CHAR); + fhold; fgoto err_line; + } + + base64_char = alnum | [+/]; + base64_padd = '='; + base64_quartet = + ( base64_char $_first_base64_char . # A + base64_char $_second_base64_char . # AB + ( ( base64_char $_third_base64_char . # ABC + ( base64_char $_fourth_base64_char # ABCD + | base64_padd{1} # ABC= + ) + ) + | base64_padd{2} # AB== + ) + ); + + # Base64 array with possibility of inside white spaces and multiline. + base64_ := (base64_quartet+ . sep?)+ $!_base64_char_error + %_ret . end_wchar; + base64 = base64_char ${ fhold; fcall base64_; }; + # END + + # BEGIN - Base32hex processing (RFC 4648) + action _first_base32hex_char { + if (rdata_tail <= rdata_stop) { + *rdata_tail = first_base32hex_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _second_base32hex_char { + *(rdata_tail++) += second_left_base32hex_to_num[(uint8_t)fc]; + + if (rdata_tail <= rdata_stop) { + *rdata_tail = second_right_base32hex_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _third_base32hex_char { + *rdata_tail += third_base32hex_to_num[(uint8_t)fc]; + } + action _fourth_base32hex_char { + *(rdata_tail++) += fourth_left_base32hex_to_num[(uint8_t)fc]; + + if (rdata_tail <= rdata_stop) { + *rdata_tail = fourth_right_base32hex_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _fifth_base32hex_char { + *(rdata_tail++) += fifth_left_base32hex_to_num[(uint8_t)fc]; + + if (rdata_tail <= rdata_stop) { + *rdata_tail = fifth_right_base32hex_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _sixth_base32hex_char { + *rdata_tail += sixth_base32hex_to_num[(uint8_t)fc]; + } + action _seventh_base32hex_char { + *(rdata_tail++) += seventh_left_base32hex_to_num[(uint8_t)fc]; + + if (rdata_tail <= rdata_stop) { + *rdata_tail = seventh_right_base32hex_to_num[(uint8_t)fc]; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + action _eighth_base32hex_char { + *(rdata_tail++) += eighth_base32hex_to_num[(uint8_t)fc]; + } + + action _base32hex_char_error { + WARN(ZS_BAD_BASE32HEX_CHAR); + fhold; fgoto err_line; + } + + base32hex_char = [0-9a-vA-V]; + base32hex_padd = '='; + base32hex_octet = + ( base32hex_char $_first_base32hex_char . # A + base32hex_char $_second_base32hex_char . # AB + ( ( base32hex_char $_third_base32hex_char . # ABC + base32hex_char $_fourth_base32hex_char . # ABCD + ( ( base32hex_char $_fifth_base32hex_char . # ABCDE + ( ( base32hex_char $_sixth_base32hex_char . # ABCDEF + base32hex_char $_seventh_base32hex_char . # ABCDEFG + ( base32hex_char $_eighth_base32hex_char # ABCDEFGH + | base32hex_padd{1} # ABCDEFG= + ) + ) + | base32hex_padd{3} # ABCDE=== + ) + ) + | base32hex_padd{4} # ABCD==== + ) + ) + | base32hex_padd{6} # AB====== + ) + ); + + # Continuous base32hex (with padding!) array with forward length processing. + hash = base32hex_octet+ >_item_length_init %_item_length_exit + $!_base32hex_char_error; + # END + + # BEGIN - Simple number write functions. + action _write8_0 { + *(rdata_tail++) = 0; + } + action _write8_1 { + *(rdata_tail++) = 1; + } + action _write8_2 { + *(rdata_tail++) = 2; + } + action _write8_3 { + *(rdata_tail++) = 3; + } + action _write8_5 { + *(rdata_tail++) = 5; + } + action _write8_6 { + *(rdata_tail++) = 6; + } + action _write8_7 { + *(rdata_tail++) = 7; + } + action _write8_8 { + *(rdata_tail++) = 8; + } + action _write8_10 { + *(rdata_tail++) = 10; + } + action _write8_12 { + *(rdata_tail++) = 12; + } + action _write8_13 { + *(rdata_tail++) = 13; + } + action _write8_14 { + *(rdata_tail++) = 14; + } + action _write8_15 { + *(rdata_tail++) = 15; + } + action _write8_16 { + *(rdata_tail++) = 16; + } + action _write8_252 { + *(rdata_tail++) = 252; + } + action _write8_253 { + *(rdata_tail++) = 253; + } + action _write8_254 { + *(rdata_tail++) = 254; + } + + action _write16_0 { + uint16_t val = htons(0); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_1 { + uint16_t val = htons(1); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_2 { + uint16_t val = htons(2); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_3 { + uint16_t val = htons(3); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_4 { + uint16_t val = htons(4); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_5 { + uint16_t val = htons(5); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_6 { + uint16_t val = htons(6); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_7 { + uint16_t val = htons(7); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_8 { + uint16_t val = htons(8); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_253 { + uint16_t val = htons(253); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + action _write16_254 { + uint16_t val = htons(254); + memcpy(rdata_tail, &val, 2); + rdata_tail += 2; + } + # END + + # BEGIN - Gateway + action _gateway_error { + WARN(ZS_BAD_GATEWAY); + fhold; fgoto err_line; + } + action _gateway_key_error { + WARN(ZS_BAD_GATEWAY_KEY); + fhold; fgoto err_line; + } + + gateway = (( ('0' $_write8_0 . sep . num8 . sep . '.') + | ('1' $_write8_1 . sep . num8 . sep . ipv4_addr_write) + | ('2' $_write8_2 . sep . num8 . sep . ipv6_addr_write) + | ('3' $_write8_3 . sep . num8 . sep . r_dname) + ) $!_gateway_error . + # If algorithm is 0 then key isn't present and vice versa. + ( ((sep . base64) when { s->number64 != 0 }) + | ((sep?) when { s->number64 == 0 }) # remove blank space + ) $!_gateway_key_error + ); + # END + + # BEGIN - Type processing + action _type_error { + WARN(ZS_UNSUPPORTED_TYPE); + fhold; fgoto err_line; + } + + type_num = + ( "A"i %{ type_num(KNOT_RRTYPE_A, &rdata_tail); } + | "NS"i %{ type_num(KNOT_RRTYPE_NS, &rdata_tail); } + | "CNAME"i %{ type_num(KNOT_RRTYPE_CNAME, &rdata_tail); } + | "SOA"i %{ type_num(KNOT_RRTYPE_SOA, &rdata_tail); } + | "PTR"i %{ type_num(KNOT_RRTYPE_PTR, &rdata_tail); } + | "HINFO"i %{ type_num(KNOT_RRTYPE_HINFO, &rdata_tail); } + | "MINFO"i %{ type_num(KNOT_RRTYPE_MINFO, &rdata_tail); } + | "MX"i %{ type_num(KNOT_RRTYPE_MX, &rdata_tail); } + | "TXT"i %{ type_num(KNOT_RRTYPE_TXT, &rdata_tail); } + | "RP"i %{ type_num(KNOT_RRTYPE_RP, &rdata_tail); } + | "AFSDB"i %{ type_num(KNOT_RRTYPE_AFSDB, &rdata_tail); } + | "RT"i %{ type_num(KNOT_RRTYPE_RT, &rdata_tail); } + | "KEY"i %{ type_num(KNOT_RRTYPE_KEY, &rdata_tail); } + | "AAAA"i %{ type_num(KNOT_RRTYPE_AAAA, &rdata_tail); } + | "LOC"i %{ type_num(KNOT_RRTYPE_LOC, &rdata_tail); } + | "SRV"i %{ type_num(KNOT_RRTYPE_SRV, &rdata_tail); } + | "NAPTR"i %{ type_num(KNOT_RRTYPE_NAPTR, &rdata_tail); } + | "KX"i %{ type_num(KNOT_RRTYPE_KX, &rdata_tail); } + | "CERT"i %{ type_num(KNOT_RRTYPE_CERT, &rdata_tail); } + | "DNAME"i %{ type_num(KNOT_RRTYPE_DNAME, &rdata_tail); } + | "APL"i %{ type_num(KNOT_RRTYPE_APL, &rdata_tail); } + | "DS"i %{ type_num(KNOT_RRTYPE_DS, &rdata_tail); } + | "SSHFP"i %{ type_num(KNOT_RRTYPE_SSHFP, &rdata_tail); } + | "IPSECKEY"i %{ type_num(KNOT_RRTYPE_IPSECKEY, &rdata_tail); } + | "RRSIG"i %{ type_num(KNOT_RRTYPE_RRSIG, &rdata_tail); } + | "NSEC"i %{ type_num(KNOT_RRTYPE_NSEC, &rdata_tail); } + | "DNSKEY"i %{ type_num(KNOT_RRTYPE_DNSKEY, &rdata_tail); } + | "DHCID"i %{ type_num(KNOT_RRTYPE_DHCID, &rdata_tail); } + | "NSEC3"i %{ type_num(KNOT_RRTYPE_NSEC3, &rdata_tail); } + | "NSEC3PARAM"i %{ type_num(KNOT_RRTYPE_NSEC3PARAM, &rdata_tail); } + | "TLSA"i %{ type_num(KNOT_RRTYPE_TLSA, &rdata_tail); } + | "SMIMEA"i %{ type_num(KNOT_RRTYPE_SMIMEA, &rdata_tail); } + | "CDS"i %{ type_num(KNOT_RRTYPE_CDS, &rdata_tail); } + | "CDNSKEY"i %{ type_num(KNOT_RRTYPE_CDNSKEY, &rdata_tail); } + | "OPENPGPKEY"i %{ type_num(KNOT_RRTYPE_OPENPGPKEY, &rdata_tail); } + | "CSYNC"i %{ type_num(KNOT_RRTYPE_CSYNC, &rdata_tail); } + | "ZONEMD"i %{ type_num(KNOT_RRTYPE_ZONEMD, &rdata_tail); } + | "SPF"i %{ type_num(KNOT_RRTYPE_SPF, &rdata_tail); } + | "NID"i %{ type_num(KNOT_RRTYPE_NID, &rdata_tail); } + | "L32"i %{ type_num(KNOT_RRTYPE_L32, &rdata_tail); } + | "L64"i %{ type_num(KNOT_RRTYPE_L64, &rdata_tail); } + | "LP"i %{ type_num(KNOT_RRTYPE_LP, &rdata_tail); } + | "EUI48"i %{ type_num(KNOT_RRTYPE_EUI48, &rdata_tail); } + | "EUI64"i %{ type_num(KNOT_RRTYPE_EUI64, &rdata_tail); } + | "URI"i %{ type_num(KNOT_RRTYPE_URI, &rdata_tail); } + | "CAA"i %{ type_num(KNOT_RRTYPE_CAA, &rdata_tail); } + | "SVCB"i %{ type_num(KNOT_RRTYPE_SVCB, &rdata_tail); } + | "HTTPS"i %{ type_num(KNOT_RRTYPE_HTTPS, &rdata_tail); } + | "TYPE"i . num16 # TYPE0-TYPE65535. + ) $!_type_error; + # END + + # BEGIN - Bitmap processing + action _type_bitmap_exit { + if (s->number64 <= UINT16_MAX) { + window_add_bit(s->number64, s); + } else { + WARN(ZS_NUMBER16_OVERFLOW); + fhold; fgoto err_line; + } + } + + # TYPE0-TYPE65535. + type_bitmap = number %_type_bitmap_exit; + + type_bit = + ( "A"i %{ window_add_bit(KNOT_RRTYPE_A, s); } + | "NS"i %{ window_add_bit(KNOT_RRTYPE_NS, s); } + | "CNAME"i %{ window_add_bit(KNOT_RRTYPE_CNAME, s); } + | "SOA"i %{ window_add_bit(KNOT_RRTYPE_SOA, s); } + | "PTR"i %{ window_add_bit(KNOT_RRTYPE_PTR, s); } + | "HINFO"i %{ window_add_bit(KNOT_RRTYPE_HINFO, s); } + | "MINFO"i %{ window_add_bit(KNOT_RRTYPE_MINFO, s); } + | "MX"i %{ window_add_bit(KNOT_RRTYPE_MX, s); } + | "TXT"i %{ window_add_bit(KNOT_RRTYPE_TXT, s); } + | "RP"i %{ window_add_bit(KNOT_RRTYPE_RP, s); } + | "AFSDB"i %{ window_add_bit(KNOT_RRTYPE_AFSDB, s); } + | "RT"i %{ window_add_bit(KNOT_RRTYPE_RT, s); } + | "KEY"i %{ window_add_bit(KNOT_RRTYPE_KEY, s); } + | "AAAA"i %{ window_add_bit(KNOT_RRTYPE_AAAA, s); } + | "LOC"i %{ window_add_bit(KNOT_RRTYPE_LOC, s); } + | "SRV"i %{ window_add_bit(KNOT_RRTYPE_SRV, s); } + | "NAPTR"i %{ window_add_bit(KNOT_RRTYPE_NAPTR, s); } + | "KX"i %{ window_add_bit(KNOT_RRTYPE_KX, s); } + | "CERT"i %{ window_add_bit(KNOT_RRTYPE_CERT, s); } + | "DNAME"i %{ window_add_bit(KNOT_RRTYPE_DNAME, s); } + | "APL"i %{ window_add_bit(KNOT_RRTYPE_APL, s); } + | "DS"i %{ window_add_bit(KNOT_RRTYPE_DS, s); } + | "SSHFP"i %{ window_add_bit(KNOT_RRTYPE_SSHFP, s); } + | "IPSECKEY"i %{ window_add_bit(KNOT_RRTYPE_IPSECKEY, s); } + | "RRSIG"i %{ window_add_bit(KNOT_RRTYPE_RRSIG, s); } + | "NSEC"i %{ window_add_bit(KNOT_RRTYPE_NSEC, s); } + | "DNSKEY"i %{ window_add_bit(KNOT_RRTYPE_DNSKEY, s); } + | "DHCID"i %{ window_add_bit(KNOT_RRTYPE_DHCID, s); } + | "NSEC3"i %{ window_add_bit(KNOT_RRTYPE_NSEC3, s); } + | "NSEC3PARAM"i %{ window_add_bit(KNOT_RRTYPE_NSEC3PARAM, s); } + | "TLSA"i %{ window_add_bit(KNOT_RRTYPE_TLSA, s); } + | "SMIMEA"i %{ window_add_bit(KNOT_RRTYPE_SMIMEA, s); } + | "CDS"i %{ window_add_bit(KNOT_RRTYPE_CDS, s); } + | "CDNSKEY"i %{ window_add_bit(KNOT_RRTYPE_CDNSKEY, s); } + | "OPENPGPKEY"i %{ window_add_bit(KNOT_RRTYPE_OPENPGPKEY, s); } + | "CSYNC"i %{ window_add_bit(KNOT_RRTYPE_CSYNC, s); } + | "ZONEMD"i %{ window_add_bit(KNOT_RRTYPE_ZONEMD, s); } + | "SPF"i %{ window_add_bit(KNOT_RRTYPE_SPF, s); } + | "NID"i %{ window_add_bit(KNOT_RRTYPE_NID, s); } + | "L32"i %{ window_add_bit(KNOT_RRTYPE_L32, s); } + | "L64"i %{ window_add_bit(KNOT_RRTYPE_L64, s); } + | "LP"i %{ window_add_bit(KNOT_RRTYPE_LP, s); } + | "EUI48"i %{ window_add_bit(KNOT_RRTYPE_EUI48, s); } + | "EUI64"i %{ window_add_bit(KNOT_RRTYPE_EUI64, s); } + | "URI"i %{ window_add_bit(KNOT_RRTYPE_URI, s); } + | "CAA"i %{ window_add_bit(KNOT_RRTYPE_CAA, s); } + | "SVCB"i %{ window_add_bit(KNOT_RRTYPE_SVCB, s); } + | "HTTPS"i %{ window_add_bit(KNOT_RRTYPE_HTTPS, s); } + | "TYPE"i . type_bitmap # TYPE0-TYPE65535. + ); + + action _bitmap_init { + memset(s->windows, 0, sizeof(s->windows)); + s->last_window = -1; + } + action _bitmap_exit { + for (uint16_t window = 0; window <= s->last_window; window++) { + if ((s->windows[window]).length > 0) { + if (rdata_tail + 2 + (s->windows[window]).length <= rdata_stop) + { + // Window number. + *rdata_tail = (uint8_t)window; + rdata_tail += 1; + // Bitmap length. + *rdata_tail = (s->windows[window]).length; + rdata_tail += 1; + // Copying bitmap. + memcpy(rdata_tail, + (s->windows[window]).bitmap, + (s->windows[window]).length); + rdata_tail += (s->windows[window]).length; + } else { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + } + } + action _bitmap_error { + WARN(ZS_BAD_BITMAP); + fhold; fgoto err_line; + } + + # Blank bitmap is allowed too. + bitmap_ := ((sep . type_bit)* . sep?) >_bitmap_init + %_bitmap_exit %_ret $!_bitmap_error . end_wchar; + bitmap = all_wchar ${ fhold; fcall bitmap_; }; + # END + + # BEGIN - Location processing + action _d1_exit { + if (s->number64 <= 90) { + s->loc.d1 = (uint32_t)(s->number64); + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _d2_exit { + if (s->number64 <= 180) { + s->loc.d2 = (uint32_t)(s->number64); + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _m1_exit { + if (s->number64 <= 59) { + s->loc.m1 = (uint32_t)(s->number64); + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _m2_exit { + if (s->number64 <= 59) { + s->loc.m2 = (uint32_t)(s->number64); + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _s1_exit { + if (s->number64 <= 59999) { + s->loc.s1 = (uint32_t)(s->number64); + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _s2_exit { + if (s->number64 <= 59999) { + s->loc.s2 = (uint32_t)(s->number64); + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _alt_exit { + if ((s->loc.alt_sign == 1 && s->number64 <= 4284967295) || + (s->loc.alt_sign == -1 && s->number64 <= 10000000)) + { + s->loc.alt = (uint32_t)(s->number64); + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _siz_exit { + if (s->number64 <= 9000000000ULL) { + s->loc.siz = s->number64; + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _hp_exit { + if (s->number64 <= 9000000000ULL) { + s->loc.hp = s->number64; + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _vp_exit { + if (s->number64 <= 9000000000ULL) { + s->loc.vp = s->number64; + } else { + WARN(ZS_BAD_NUMBER); + fhold; fgoto err_line; + } + } + action _lat_sign { + s->loc.lat_sign = -1; + } + action _long_sign { + s->loc.long_sign = -1; + } + action _alt_sign { + s->loc.alt_sign = -1; + } + + d1 = number %_d1_exit; + d2 = number %_d2_exit; + m1 = number %_m1_exit; + m2 = number %_m2_exit; + s1 = float3 %_s1_exit; + s2 = float3 %_s2_exit; + siz = float2 %_siz_exit; + hp = float2 %_hp_exit; + vp = float2 %_vp_exit; + alt = ('-' %_alt_sign)? . float2 %_alt_exit; + lat_sign = 'N' | 'S' %_lat_sign; + long_sign = 'E' | 'W' %_long_sign; + + action _loc_init { + memset(&(s->loc), 0, sizeof(s->loc)); + // Defaults. + s->loc.siz = 100; + s->loc.vp = 1000; + s->loc.hp = 1000000; + s->loc.lat_sign = 1; + s->loc.long_sign = 1; + s->loc.alt_sign = 1; + } + action _loc_exit { + // Write version. + *(rdata_tail) = 0; + rdata_tail += 1; + // Write size. + *(rdata_tail) = loc64to8(s->loc.siz); + rdata_tail += 1; + // Write horizontal precision. + *(rdata_tail) = loc64to8(s->loc.hp); + rdata_tail += 1; + // Write vertical precision. + *(rdata_tail) = loc64to8(s->loc.vp); + rdata_tail += 1; + // Write latitude. + *((uint32_t *)rdata_tail) = htonl(LOC_LAT_ZERO + s->loc.lat_sign * + (3600000 * s->loc.d1 + 60000 * s->loc.m1 + s->loc.s1)); + rdata_tail += 4; + // Write longitude. + *((uint32_t *)rdata_tail) = htonl(LOC_LONG_ZERO + s->loc.long_sign * + (3600000 * s->loc.d2 + 60000 * s->loc.m2 + s->loc.s2)); + rdata_tail += 4; + // Write altitude. + *((uint32_t *)rdata_tail) = htonl(LOC_ALT_ZERO + s->loc.alt_sign * + (s->loc.alt)); + rdata_tail += 4; + } + action _loc_error { + WARN(ZS_BAD_LOC_DATA); + fhold; fgoto err_line; + } + + loc = (d1 . sep . (m1 . sep . (s1 . sep)?)? . lat_sign . sep . + d2 . sep . (m2 . sep . (s2 . sep)?)? . long_sign . sep . + alt 'm'? . (sep . siz 'm'? . (sep . hp 'm'? . (sep . vp 'm'?)?)?)? . + sep? + ) >_loc_init %_loc_exit $!_loc_error; + # END + + # BEGIN - Hexadecimal rdata processing + action _hex_r_data_error { + WARN(ZS_BAD_HEX_RDATA); + fhold; fgoto err_line; + } + + nonempty_hex_r_data := + (sep . length_number . sep . type_data) + $!_hex_r_data_error %_ret . end_wchar; + + hex_r_data := + (sep . + ( ('0' %_ret . all_wchar) + | (length_number . sep . type_data %_ret . end_wchar) + ) + ) $!_hex_r_data_error; + # END + + # BEGIN - EUI processing + action _eui_init { + s->item_length = 0; + } + action _eui_count { + s->item_length++; + } + action _eui48_exit { + if (s->item_length != 6) { + WARN(ZS_BAD_EUI_LENGTH); + fhold; fgoto err_line; + } + } + action _eui64_exit { + if (s->item_length != 8) { + WARN(ZS_BAD_EUI_LENGTH); + fhold; fgoto err_line; + } + } + action _eui_sep_error { + WARN(ZS_BAD_CHAR_DASH); + fhold; fgoto err_line; + } + + eui48 = (hex_char %_eui_count . + ('-' >!_eui_sep_error . hex_char %_eui_count)+ + ) $!_hex_char_error >_eui_init %_eui48_exit; + + eui64 = (hex_char %_eui_count . + ('-' >!_eui_sep_error . hex_char %_eui_count)+ + ) $!_hex_char_error >_eui_init %_eui64_exit; + # END + + # BEGIN - ILNP processing + action _l64_init { + s->item_length = 0; + } + action _l64_count { + s->item_length++; + } + action _l64_exit { + if (s->item_length != 4) { + WARN(ZS_BAD_L64_LENGTH); + fhold; fgoto err_line; + } + } + action _l64_sep_error { + WARN(ZS_BAD_CHAR_COLON); + fhold; fgoto err_line; + } + + l64_label = (hex_char . hex_char) $!_hex_char_error %_l64_count; + l64 = (l64_label . (':' >!_l64_sep_error . l64_label)+ + ) $!_hex_char_error >_l64_init %_l64_exit; + + l32 = ipv4_addr %_ipv4_addr_write; + # END + + # BEGIN - SvcParams processing (SVCB/HTTPS records) + action _svcb_params_init { + s->svcb.params_position = rdata_tail; + s->svcb.last_key = -1; + } + action _svcb_params_exit { + int ret = svcb_check(s, rdata_tail); + if (ret != ZS_OK) { + WARN(ret); + fhold; fgoto err_line; + } + } + action _svcb_params_error { + WARN(ZS_BAD_SVCB_PARAM); + fhold; fgoto err_line; + } + + action _mandat_value_error { + WARN(ZS_BAD_SVCB_MANDATORY); + fhold; fgoto err_line; + } + + action _svcb_param_init { + if (rdata_tail + 4 > rdata_stop + 1) { // key_len + val_len + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + s->svcb.param_position = rdata_tail; + } + action _svcb_param_exit { + int ret = svcb_sort(s, rdata_tail); + if (ret != ZS_OK) { + WARN(ret); + fhold; fgoto err_line; + } + } + + action _alpnl_init { + s->comma_list = true; + } + action _alpnl_exit { + s->comma_list = false; + } + + action _mandatory_init { + s->svcb.mandatory_position = rdata_tail + 2; // Skip 2-B prefix. + } + action _mandatory_exit { + svcb_mandatory_sort(s->svcb.mandatory_position, rdata_tail); + } + + action _rdata_2B_check { + if (rdata_tail + 2 > rdata_stop + 1) { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + } + + svcb_key_generic = ("key" . num16); + svcb_key_mandatory = ("mandatory" %_write16_0); + svcb_key_alpn = ("alpn" %_write16_1); + svcb_key_ndalpn = ("no-default-alpn" %_write16_2); + svcb_key_port = ("port" %_write16_3); + svcb_key_ipv4hint = ("ipv4hint" %_write16_4); + svcb_key_ech = ("ech" %_write16_5); + svcb_key_ipv6hint = ("ipv6hint" %_write16_6); + + mandat_value_ := + (svcb_key_generic | svcb_key_alpn | svcb_key_ndalpn | svcb_key_port | + svcb_key_ipv4hint | svcb_key_ech | svcb_key_ipv6hint + ) >_rdata_2B_check $!_mandat_value_error %_ret . ([,\"] | all_wchar); + mandat_value = alpha ${ fhold; fcall mandat_value_; }; + + svcb_empty = zlen %_write16_0; + svcb_generic_ = (text >_item_length2_init %_item_length2_exit); + svcb_generic = ("=" . svcb_generic_) | svcb_empty; + svcb_mandat_ = ((mandat_value . ("," . mandat_value)*) >_item_length2_init %_item_length2_exit); + svcb_mandat = svcb_mandat_ >_mandatory_init %_mandatory_exit; + svcb_alpn = (text_string >_alpnl_init %_alpnl_exit >_item_length2_init %_item_length2_exit); + svcb_port = num16 >_write16_2 >_rdata_2B_check; + svcb_ipv4 = ((ipv4_addr_write . ("," . ipv4_addr_write)*) >_item_length2_init %_item_length2_exit); + svcb_ech = (base64_quartet+ >_item_length2_init %_item_length2_exit); + svcb_ipv6 = ((ipv6_addr_write . ("," . ipv6_addr_write)*) >_item_length2_init %_item_length2_exit); + + svcb_param_generic = (svcb_key_generic . svcb_generic); + svcb_param_mandatory = (svcb_key_mandatory . "=" . (svcb_mandat | ('\"' . svcb_mandat . '\"'))); + svcb_param_alpn = (svcb_key_alpn . "=" . (svcb_alpn | ('\"' . svcb_alpn . '\"'))); + svcb_param_ndalpn = (svcb_key_ndalpn . svcb_empty); + svcb_param_port = (svcb_key_port . "=" . (svcb_port | ('\"' . svcb_port . '\"'))); + svcb_param_ipv4hint = (svcb_key_ipv4hint . "=" . (svcb_ipv4 | ('\"' . svcb_ipv4 . '\"'))); + svcb_param_ech = (svcb_key_ech . "=" . (svcb_ech | ('\"' . svcb_ech . '\"'))); + svcb_param_ipv6hint = (svcb_key_ipv6hint . "=" . (svcb_ipv6 | ('\"' . svcb_ipv6 . '\"'))); + + svcb_param_any = + (svcb_param_generic | svcb_param_mandatory | svcb_param_alpn | + svcb_param_ndalpn | svcb_param_port | svcb_param_ipv4hint | + svcb_param_ech | svcb_param_ipv6hint + ) >_svcb_param_init %_svcb_param_exit; + svcb_params_ := + ((sep . svcb_param_any)* . sep?) >_svcb_params_init + %_svcb_params_exit $!_svcb_params_error %_ret . end_wchar; + svcb_params = all_wchar ${ fhold; fcall svcb_params_; }; + # END + + # BEGIN - Mnemonic names processing + action _dns_alg_error { + WARN(ZS_BAD_ALGORITHM); + fhold; fgoto err_line; + } + action _cert_type_error { + WARN(ZS_BAD_CERT_TYPE); + fhold; fgoto err_line; + } + + dns_alg_ := + ( number %_num8_write + | "RSAMD5"i %_write8_1 + | "DH"i %_write8_2 + | "DSA"i %_write8_3 + | "RSASHA1"i %_write8_5 + | "DSA-NSEC3-SHA1"i %_write8_6 + | "RSASHA1-NSEC3-SHA1"i %_write8_7 + | "RSASHA256"i %_write8_8 + | "RSASHA512"i %_write8_10 + | "ECC-GOST"i %_write8_12 + | "ECDSAP256SHA256"i %_write8_13 + | "ECDSAP384SHA384"i %_write8_14 + | "ED25519"i %_write8_15 + | "ED448"i %_write8_16 + | "INDIRECT"i %_write8_252 + | "PRIVATEDNS"i %_write8_253 + | "PRIVATEOID"i %_write8_254 + ) $!_dns_alg_error %_ret . all_wchar; + dns_alg = alnum ${ fhold; fcall dns_alg_; }; + + cert_type_ := + ( number %_num16_write + | "PKIX"i %_write16_1 + | "SPKI"i %_write16_2 + | "PGP"i %_write16_3 + | "IPKIX"i %_write16_4 + | "ISPKI"i %_write16_5 + | "IPGP"i %_write16_6 + | "ACPKIX"i %_write16_7 + | "IACPKIX"i %_write16_8 + | "URI"i %_write16_253 + | "OID"i %_write16_254 + ) $!_cert_type_error %_ret . all_wchar; + cert_type = alnum ${ fhold; fcall cert_type_; }; + # END + + # BEGIN - Rdata processing + action _r_data_init { + rdata_tail = s->r_data; + } + action _r_data_error { + WARN(ZS_BAD_RDATA); + fhold; fgoto err_line; + } + + r_data_a := + (ipv4_addr_write) + $!_r_data_error %_ret . all_wchar; + + r_data_ns := + (r_dname) + $!_r_data_error %_ret . all_wchar; + + r_data_soa := + (r_dname . sep . r_dname . sep . num32 . sep . time32 . + sep . time32 . sep . time32 . sep . time32) + $!_r_data_error %_ret . all_wchar; + + r_data_hinfo := + (text_string . sep . text_string) + $!_r_data_error %_ret . all_wchar; + + r_data_minfo := + (r_dname . sep . r_dname) + $!_r_data_error %_ret . all_wchar; + + r_data_mx := + (num16 . sep . r_dname) + $!_r_data_error %_ret . all_wchar; + + r_data_txt := + (text_array) + $!_r_data_error %_ret . end_wchar; + + r_data_aaaa := + (ipv6_addr_write) + $!_r_data_error %_ret . all_wchar; + + r_data_loc := + (loc) + $!_r_data_error %_ret . end_wchar; + + r_data_srv := + (num16 . sep . num16 . sep . num16 . sep . r_dname) + $!_r_data_error %_ret . all_wchar; + + r_data_naptr := + (num16 . sep . num16 . sep . text_string . sep . text_string . + sep . text_string . sep . r_dname) + $!_r_data_error %_ret . all_wchar; + + r_data_cert := + (cert_type . sep . num16 . sep . dns_alg . sep . base64) + $!_r_data_error %_ret . end_wchar; + + r_data_apl := + (apl_array) + $!_r_data_error %_ret . end_wchar; + + r_data_ds := + (num16 . sep . dns_alg . sep . num8 . sep . hex_array) + $!_r_data_error %_ret . end_wchar; + + r_data_sshfp := + (num8 . sep . num8 . sep . hex_array) + $!_r_data_error %_ret . end_wchar; + + r_data_ipseckey := + (num8 . sep . gateway) + $!_r_data_error %_ret . end_wchar; + + r_data_rrsig := + (type_num . sep . dns_alg . sep . num8 . sep . num32 . sep . + timestamp . sep . timestamp . sep . num16 . sep . r_dname . + sep . base64) + $!_r_data_error %_ret . end_wchar; + + r_data_nsec := + (r_dname . bitmap) + $!_r_data_error %_ret . all_wchar; + + r_data_dnskey := + (num16 . sep . num8 . sep . dns_alg . sep . base64) + $!_r_data_error %_ret . end_wchar; + + r_data_dhcid := + (base64) + $!_r_data_error %_ret . end_wchar; + + r_data_nsec3 := + (num8 . sep . num8 . sep . num16 . sep . salt . sep . + hash . bitmap) + $!_r_data_error %_ret . all_wchar; + + r_data_nsec3param := + (num8 . sep . num8 . sep . num16 . sep . salt) + $!_r_data_error %_ret . all_wchar; + + r_data_tlsa := + (num8 . sep . num8 . sep . num8 . sep . hex_array) + $!_r_data_error %_ret . end_wchar; + + r_data_csync := + (num32 . sep . num16 . bitmap) + $!_r_data_error %_ret . all_wchar; + + r_data_zonemd := + (num32 . sep . num8 . sep . num8 . sep . hex_array) + $!_r_data_error %_ret . end_wchar; + + r_data_l32 := + (num16 . sep . l32) + $!_r_data_error %_ret . all_wchar; + + r_data_l64 := + (num16 . sep . l64) + $!_r_data_error %_ret . all_wchar; + + r_data_eui48 := + (eui48) + $!_r_data_error %_ret . all_wchar; + + r_data_eui64 := + (eui64) + $!_r_data_error %_ret . all_wchar; + + r_data_uri := + (num16 . sep . num16 . sep . text) + $!_r_data_error %_ret . all_wchar; + + r_data_caa := + (num8 . sep . text_string . sep . text) + $!_r_data_error %_ret . all_wchar; + + r_data_svcb := + (num16 . sep . r_dname . svcb_params) + $!_r_data_error %_ret . all_wchar; + + action _text_r_data { + fhold; + switch (s->r_type) { + case KNOT_RRTYPE_A: + fcall r_data_a; + case KNOT_RRTYPE_NS: + case KNOT_RRTYPE_CNAME: + case KNOT_RRTYPE_PTR: + case KNOT_RRTYPE_DNAME: + fcall r_data_ns; + case KNOT_RRTYPE_SOA: + fcall r_data_soa; + case KNOT_RRTYPE_HINFO: + fcall r_data_hinfo; + case KNOT_RRTYPE_MINFO: + case KNOT_RRTYPE_RP: + fcall r_data_minfo; + case KNOT_RRTYPE_MX: + case KNOT_RRTYPE_AFSDB: + case KNOT_RRTYPE_RT: + case KNOT_RRTYPE_KX: + case KNOT_RRTYPE_LP: + fcall r_data_mx; + case KNOT_RRTYPE_TXT: + case KNOT_RRTYPE_SPF: + fcall r_data_txt; + case KNOT_RRTYPE_AAAA: + fcall r_data_aaaa; + case KNOT_RRTYPE_LOC: + fcall r_data_loc; + case KNOT_RRTYPE_SRV: + fcall r_data_srv; + case KNOT_RRTYPE_NAPTR: + fcall r_data_naptr; + case KNOT_RRTYPE_CERT: + fcall r_data_cert; + case KNOT_RRTYPE_APL: + fcall r_data_apl; + case KNOT_RRTYPE_DS: + case KNOT_RRTYPE_CDS: + fcall r_data_ds; + case KNOT_RRTYPE_SSHFP: + fcall r_data_sshfp; + case KNOT_RRTYPE_IPSECKEY: + fcall r_data_ipseckey; + case KNOT_RRTYPE_RRSIG: + fcall r_data_rrsig; + case KNOT_RRTYPE_NSEC: + fcall r_data_nsec; + case KNOT_RRTYPE_KEY: + case KNOT_RRTYPE_DNSKEY: + case KNOT_RRTYPE_CDNSKEY: + fcall r_data_dnskey; + case KNOT_RRTYPE_DHCID: + case KNOT_RRTYPE_OPENPGPKEY: + fcall r_data_dhcid; + case KNOT_RRTYPE_NSEC3: + fcall r_data_nsec3; + case KNOT_RRTYPE_NSEC3PARAM: + fcall r_data_nsec3param; + case KNOT_RRTYPE_TLSA: + case KNOT_RRTYPE_SMIMEA: + fcall r_data_tlsa; + case KNOT_RRTYPE_CSYNC: + fcall r_data_csync; + case KNOT_RRTYPE_ZONEMD: + fcall r_data_zonemd; + case KNOT_RRTYPE_NID: + case KNOT_RRTYPE_L64: + fcall r_data_l64; + case KNOT_RRTYPE_L32: + fcall r_data_l32; + case KNOT_RRTYPE_EUI48: + fcall r_data_eui48; + case KNOT_RRTYPE_EUI64: + fcall r_data_eui64; + case KNOT_RRTYPE_URI: + fcall r_data_uri; + case KNOT_RRTYPE_CAA: + fcall r_data_caa; + case KNOT_RRTYPE_SVCB: + case KNOT_RRTYPE_HTTPS: + fcall r_data_svcb; + default: + WARN(ZS_CANNOT_TEXT_DATA); + fgoto err_line; + } + } + action _hex_r_data { + switch (s->r_type) { + // Next types must not have empty rdata. + case KNOT_RRTYPE_A: + case KNOT_RRTYPE_NS: + case KNOT_RRTYPE_CNAME: + case KNOT_RRTYPE_PTR: + case KNOT_RRTYPE_DNAME: + case KNOT_RRTYPE_SOA: + case KNOT_RRTYPE_HINFO: + case KNOT_RRTYPE_MINFO: + case KNOT_RRTYPE_MX: + case KNOT_RRTYPE_AFSDB: + case KNOT_RRTYPE_RT: + case KNOT_RRTYPE_KX: + case KNOT_RRTYPE_TXT: + case KNOT_RRTYPE_SPF: + case KNOT_RRTYPE_RP: + case KNOT_RRTYPE_AAAA: + case KNOT_RRTYPE_LOC: + case KNOT_RRTYPE_SRV: + case KNOT_RRTYPE_NAPTR: + case KNOT_RRTYPE_CERT: + case KNOT_RRTYPE_DS: + case KNOT_RRTYPE_SSHFP: + case KNOT_RRTYPE_IPSECKEY: + case KNOT_RRTYPE_RRSIG: + case KNOT_RRTYPE_NSEC: + case KNOT_RRTYPE_KEY: + case KNOT_RRTYPE_DNSKEY: + case KNOT_RRTYPE_DHCID: + case KNOT_RRTYPE_NSEC3: + case KNOT_RRTYPE_NSEC3PARAM: + case KNOT_RRTYPE_TLSA: + case KNOT_RRTYPE_SMIMEA: + case KNOT_RRTYPE_CDS: + case KNOT_RRTYPE_CDNSKEY: + case KNOT_RRTYPE_OPENPGPKEY: + case KNOT_RRTYPE_CSYNC: + case KNOT_RRTYPE_ZONEMD: + case KNOT_RRTYPE_NID: + case KNOT_RRTYPE_L32: + case KNOT_RRTYPE_L64: + case KNOT_RRTYPE_LP: + case KNOT_RRTYPE_EUI48: + case KNOT_RRTYPE_EUI64: + case KNOT_RRTYPE_URI: + case KNOT_RRTYPE_CAA: + case KNOT_RRTYPE_SVCB: + case KNOT_RRTYPE_HTTPS: + fcall nonempty_hex_r_data; + // Next types can have empty rdata. + case KNOT_RRTYPE_APL: + default: + fcall hex_r_data; + } + } + + # Avoidance of multiple fhold at the input block end. + action _wrap_in { + if (pe - p == 1) { + *wrap = WRAP_DETECTED; + } + } + action _wrap_out { + if (*wrap == WRAP_NONE) { + fhold; + } + } + + # rdata can be in text or hex format with leading "\#" string. + r_data = + ( sep . ^('\\' | all_wchar) $_text_r_data + | sep . '\\' $_wrap_in . ^'#' $_wrap_out $_text_r_data + | sep . '\\' . '#' $_hex_r_data # Hex format. + | sep? . end_wchar $_text_r_data # Empty rdata. + ) >_r_data_init $!_r_data_error; + # END + + # BEGIN - Record type processing + action _r_type_error { + WARN(ZS_UNSUPPORTED_TYPE); + fhold; fgoto err_line; + } + + r_type = + ( "A"i %{ s->r_type = KNOT_RRTYPE_A; } + | "NS"i %{ s->r_type = KNOT_RRTYPE_NS; } + | "CNAME"i %{ s->r_type = KNOT_RRTYPE_CNAME; } + | "SOA"i %{ s->r_type = KNOT_RRTYPE_SOA; } + | "PTR"i %{ s->r_type = KNOT_RRTYPE_PTR; } + | "HINFO"i %{ s->r_type = KNOT_RRTYPE_HINFO; } + | "MINFO"i %{ s->r_type = KNOT_RRTYPE_MINFO; } + | "MX"i %{ s->r_type = KNOT_RRTYPE_MX; } + | "TXT"i %{ s->r_type = KNOT_RRTYPE_TXT; } + | "RP"i %{ s->r_type = KNOT_RRTYPE_RP; } + | "AFSDB"i %{ s->r_type = KNOT_RRTYPE_AFSDB; } + | "RT"i %{ s->r_type = KNOT_RRTYPE_RT; } + | "KEY"i %{ s->r_type = KNOT_RRTYPE_KEY; } + | "AAAA"i %{ s->r_type = KNOT_RRTYPE_AAAA; } + | "LOC"i %{ s->r_type = KNOT_RRTYPE_LOC; } + | "SRV"i %{ s->r_type = KNOT_RRTYPE_SRV; } + | "NAPTR"i %{ s->r_type = KNOT_RRTYPE_NAPTR; } + | "KX"i %{ s->r_type = KNOT_RRTYPE_KX; } + | "CERT"i %{ s->r_type = KNOT_RRTYPE_CERT; } + | "DNAME"i %{ s->r_type = KNOT_RRTYPE_DNAME; } + | "APL"i %{ s->r_type = KNOT_RRTYPE_APL; } + | "DS"i %{ s->r_type = KNOT_RRTYPE_DS; } + | "SSHFP"i %{ s->r_type = KNOT_RRTYPE_SSHFP; } + | "IPSECKEY"i %{ s->r_type = KNOT_RRTYPE_IPSECKEY; } + | "RRSIG"i %{ s->r_type = KNOT_RRTYPE_RRSIG; } + | "NSEC"i %{ s->r_type = KNOT_RRTYPE_NSEC; } + | "DNSKEY"i %{ s->r_type = KNOT_RRTYPE_DNSKEY; } + | "DHCID"i %{ s->r_type = KNOT_RRTYPE_DHCID; } + | "NSEC3"i %{ s->r_type = KNOT_RRTYPE_NSEC3; } + | "NSEC3PARAM"i %{ s->r_type = KNOT_RRTYPE_NSEC3PARAM; } + | "TLSA"i %{ s->r_type = KNOT_RRTYPE_TLSA; } + | "SMIMEA"i %{ s->r_type = KNOT_RRTYPE_SMIMEA; } + | "CDS"i %{ s->r_type = KNOT_RRTYPE_CDS; } + | "CDNSKEY"i %{ s->r_type = KNOT_RRTYPE_CDNSKEY; } + | "OPENPGPKEY"i %{ s->r_type = KNOT_RRTYPE_OPENPGPKEY; } + | "CSYNC"i %{ s->r_type = KNOT_RRTYPE_CSYNC; } + | "ZONEMD"i %{ s->r_type = KNOT_RRTYPE_ZONEMD; } + | "SPF"i %{ s->r_type = KNOT_RRTYPE_SPF; } + | "NID"i %{ s->r_type = KNOT_RRTYPE_NID; } + | "L32"i %{ s->r_type = KNOT_RRTYPE_L32; } + | "L64"i %{ s->r_type = KNOT_RRTYPE_L64; } + | "LP"i %{ s->r_type = KNOT_RRTYPE_LP; } + | "EUI48"i %{ s->r_type = KNOT_RRTYPE_EUI48; } + | "EUI64"i %{ s->r_type = KNOT_RRTYPE_EUI64; } + | "URI"i %{ s->r_type = KNOT_RRTYPE_URI; } + | "CAA"i %{ s->r_type = KNOT_RRTYPE_CAA; } + | "SVCB"i %{ s->r_type = KNOT_RRTYPE_SVCB; } + | "HTTPS"i %{ s->r_type = KNOT_RRTYPE_HTTPS; } + | "TYPE"i . type_number + ) $!_r_type_error; + # END + + # BEGIN - The highest level processing + action _record_exit { + if (rdata_tail - s->r_data > UINT16_MAX) { + WARN(ZS_RDATA_OVERFLOW); + fhold; fgoto err_line; + } + s->r_data_length = rdata_tail - s->r_data; + + s->state = ZS_STATE_DATA; + + // Execute the record callback. + if (s->process.automatic) { + if (s->process.record != NULL) { + s->process.record(s); + + // Stop if required from the callback. + if (s->state == ZS_STATE_STOP) { + fbreak; + } + } + } else { + // Return if external processing. + fhold; fbreak; + } + } + + # Resource record. + record = + r_owner . sep . + ( (r_class . sep . ((r_ttl . sep) | (zlen %_default_r_ttl_exit ))) + | (r_ttl . sep . ((r_class . sep) | (zlen %_default_r_class_exit))) + | zlen %_default_r_class_exit %_default_r_ttl_exit + ) $!_r_type_error . + r_type . r_data . + rest %_record_exit . + newline; + + # Blank spaces with comments. + blank = rest . newline; + + # Main processing loop. + main := (record | directive | blank)*; + # END +}%% -- cgit v1.2.3