configparser.c revision 1.1.1.8
1 /* A Bison parser, made by GNU Bison 3.7.6. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, 6 Inc. 7 8 This program is free software: you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation, either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 20 21 /* As a special exception, you may create a larger work that contains 22 part or all of the Bison parser skeleton and distribute that work 23 under terms of your choice, so long as that work isn't itself a 24 parser generator using the skeleton or a modified version thereof 25 as a parser skeleton. Alternatively, if you modify or redistribute 26 the parser skeleton itself, you may (at your option) remove this 27 special exception, which will cause the skeleton and the resulting 28 Bison output files to be licensed under the GNU General Public 29 License without this special exception. 30 31 This special exception was added by the Free Software Foundation in 32 version 2.2 of Bison. */ 33 34 /* C LALR(1) parser skeleton written by Richard Stallman, by 35 simplifying the original so-called "semantic" parser. */ 36 37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, 38 especially those whose name start with YY_ or yy_. They are 39 private implementation details that can be changed or removed. */ 40 41 /* All symbols defined below should begin with yy or YY, to avoid 42 infringing on user name space. This should be done even for local 43 variables, as they might otherwise be expanded by user macros. 44 There are some unavoidable exceptions within include files to 45 define necessary library symbols; they are noted "INFRINGES ON 46 USER NAME SPACE" below. */ 47 48 /* Identify Bison output, and Bison version. */ 49 #define YYBISON 30706 50 51 /* Bison version string. */ 52 #define YYBISON_VERSION "3.7.6" 53 54 /* Skeleton name. */ 55 #define YYSKELETON_NAME "yacc.c" 56 57 /* Pure parsers. */ 58 #define YYPURE 0 59 60 /* Push parsers. */ 61 #define YYPUSH 0 62 63 /* Pull parsers. */ 64 #define YYPULL 1 65 66 67 /* Substitute the variable and function names. */ 68 #define yyparse c_parse 69 #define yylex c_lex 70 #define yyerror c_error 71 #define yydebug c_debug 72 #define yynerrs c_nerrs 73 #define yylval c_lval 74 #define yychar c_char 75 76 /* First part of user prologue. */ 77 #line 10 "configparser.y" 78 79 #include "config.h" 80 81 #include <assert.h> 82 #include <errno.h> 83 #include <stdio.h> 84 #include <string.h> 85 86 #include "options.h" 87 #include "util.h" 88 #include "dname.h" 89 #include "tsig.h" 90 #include "rrl.h" 91 92 int yylex(void); 93 94 #ifdef __cplusplus 95 extern "C" 96 #endif 97 98 /* these need to be global, otherwise they cannot be used inside yacc */ 99 extern config_parser_state_type *cfg_parser; 100 101 static void append_acl(struct acl_options **list, struct acl_options *acl); 102 static void add_to_last_acl(struct acl_options **list, char *ac); 103 static int parse_boolean(const char *str, int *bln); 104 static int parse_expire_expr(const char *str, long long *num, uint8_t *expr); 105 static int parse_number(const char *str, long long *num); 106 static int parse_range(const char *str, long long *low, long long *high); 107 108 struct component { 109 struct component *next; 110 char *str; 111 }; 112 113 114 #line 115 "configparser.c" 115 116 # ifndef YY_CAST 117 # ifdef __cplusplus 118 # define YY_CAST(Type, Val) static_cast<Type> (Val) 119 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 120 # else 121 # define YY_CAST(Type, Val) ((Type) (Val)) 122 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 123 # endif 124 # endif 125 # ifndef YY_NULLPTR 126 # if defined __cplusplus 127 # if 201103L <= __cplusplus 128 # define YY_NULLPTR nullptr 129 # else 130 # define YY_NULLPTR 0 131 # endif 132 # else 133 # define YY_NULLPTR ((void*)0) 134 # endif 135 # endif 136 137 #include "configparser.h" 138 /* Symbol kind. */ 139 enum yysymbol_kind_t 140 { 141 YYSYMBOL_YYEMPTY = -2, 142 YYSYMBOL_YYEOF = 0, /* "end of file" */ 143 YYSYMBOL_YYerror = 1, /* error */ 144 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ 145 YYSYMBOL_STRING = 3, /* STRING */ 146 YYSYMBOL_VAR_SERVER = 4, /* VAR_SERVER */ 147 YYSYMBOL_VAR_SERVER_COUNT = 5, /* VAR_SERVER_COUNT */ 148 YYSYMBOL_VAR_IP_ADDRESS = 6, /* VAR_IP_ADDRESS */ 149 YYSYMBOL_VAR_IP_TRANSPARENT = 7, /* VAR_IP_TRANSPARENT */ 150 YYSYMBOL_VAR_IP_FREEBIND = 8, /* VAR_IP_FREEBIND */ 151 YYSYMBOL_VAR_REUSEPORT = 9, /* VAR_REUSEPORT */ 152 YYSYMBOL_VAR_SEND_BUFFER_SIZE = 10, /* VAR_SEND_BUFFER_SIZE */ 153 YYSYMBOL_VAR_RECEIVE_BUFFER_SIZE = 11, /* VAR_RECEIVE_BUFFER_SIZE */ 154 YYSYMBOL_VAR_DEBUG_MODE = 12, /* VAR_DEBUG_MODE */ 155 YYSYMBOL_VAR_IP4_ONLY = 13, /* VAR_IP4_ONLY */ 156 YYSYMBOL_VAR_IP6_ONLY = 14, /* VAR_IP6_ONLY */ 157 YYSYMBOL_VAR_DO_IP4 = 15, /* VAR_DO_IP4 */ 158 YYSYMBOL_VAR_DO_IP6 = 16, /* VAR_DO_IP6 */ 159 YYSYMBOL_VAR_PORT = 17, /* VAR_PORT */ 160 YYSYMBOL_VAR_USE_SYSTEMD = 18, /* VAR_USE_SYSTEMD */ 161 YYSYMBOL_VAR_VERBOSITY = 19, /* VAR_VERBOSITY */ 162 YYSYMBOL_VAR_USERNAME = 20, /* VAR_USERNAME */ 163 YYSYMBOL_VAR_CHROOT = 21, /* VAR_CHROOT */ 164 YYSYMBOL_VAR_ZONESDIR = 22, /* VAR_ZONESDIR */ 165 YYSYMBOL_VAR_ZONELISTFILE = 23, /* VAR_ZONELISTFILE */ 166 YYSYMBOL_VAR_DATABASE = 24, /* VAR_DATABASE */ 167 YYSYMBOL_VAR_LOGFILE = 25, /* VAR_LOGFILE */ 168 YYSYMBOL_VAR_LOG_ONLY_SYSLOG = 26, /* VAR_LOG_ONLY_SYSLOG */ 169 YYSYMBOL_VAR_PIDFILE = 27, /* VAR_PIDFILE */ 170 YYSYMBOL_VAR_DIFFFILE = 28, /* VAR_DIFFFILE */ 171 YYSYMBOL_VAR_XFRDFILE = 29, /* VAR_XFRDFILE */ 172 YYSYMBOL_VAR_XFRDIR = 30, /* VAR_XFRDIR */ 173 YYSYMBOL_VAR_HIDE_VERSION = 31, /* VAR_HIDE_VERSION */ 174 YYSYMBOL_VAR_HIDE_IDENTITY = 32, /* VAR_HIDE_IDENTITY */ 175 YYSYMBOL_VAR_VERSION = 33, /* VAR_VERSION */ 176 YYSYMBOL_VAR_IDENTITY = 34, /* VAR_IDENTITY */ 177 YYSYMBOL_VAR_NSID = 35, /* VAR_NSID */ 178 YYSYMBOL_VAR_TCP_COUNT = 36, /* VAR_TCP_COUNT */ 179 YYSYMBOL_VAR_TCP_REJECT_OVERFLOW = 37, /* VAR_TCP_REJECT_OVERFLOW */ 180 YYSYMBOL_VAR_TCP_QUERY_COUNT = 38, /* VAR_TCP_QUERY_COUNT */ 181 YYSYMBOL_VAR_TCP_TIMEOUT = 39, /* VAR_TCP_TIMEOUT */ 182 YYSYMBOL_VAR_TCP_MSS = 40, /* VAR_TCP_MSS */ 183 YYSYMBOL_VAR_OUTGOING_TCP_MSS = 41, /* VAR_OUTGOING_TCP_MSS */ 184 YYSYMBOL_VAR_IPV4_EDNS_SIZE = 42, /* VAR_IPV4_EDNS_SIZE */ 185 YYSYMBOL_VAR_IPV6_EDNS_SIZE = 43, /* VAR_IPV6_EDNS_SIZE */ 186 YYSYMBOL_VAR_STATISTICS = 44, /* VAR_STATISTICS */ 187 YYSYMBOL_VAR_XFRD_RELOAD_TIMEOUT = 45, /* VAR_XFRD_RELOAD_TIMEOUT */ 188 YYSYMBOL_VAR_LOG_TIME_ASCII = 46, /* VAR_LOG_TIME_ASCII */ 189 YYSYMBOL_VAR_ROUND_ROBIN = 47, /* VAR_ROUND_ROBIN */ 190 YYSYMBOL_VAR_MINIMAL_RESPONSES = 48, /* VAR_MINIMAL_RESPONSES */ 191 YYSYMBOL_VAR_CONFINE_TO_ZONE = 49, /* VAR_CONFINE_TO_ZONE */ 192 YYSYMBOL_VAR_REFUSE_ANY = 50, /* VAR_REFUSE_ANY */ 193 YYSYMBOL_VAR_ZONEFILES_CHECK = 51, /* VAR_ZONEFILES_CHECK */ 194 YYSYMBOL_VAR_ZONEFILES_WRITE = 52, /* VAR_ZONEFILES_WRITE */ 195 YYSYMBOL_VAR_RRL_SIZE = 53, /* VAR_RRL_SIZE */ 196 YYSYMBOL_VAR_RRL_RATELIMIT = 54, /* VAR_RRL_RATELIMIT */ 197 YYSYMBOL_VAR_RRL_SLIP = 55, /* VAR_RRL_SLIP */ 198 YYSYMBOL_VAR_RRL_IPV4_PREFIX_LENGTH = 56, /* VAR_RRL_IPV4_PREFIX_LENGTH */ 199 YYSYMBOL_VAR_RRL_IPV6_PREFIX_LENGTH = 57, /* VAR_RRL_IPV6_PREFIX_LENGTH */ 200 YYSYMBOL_VAR_RRL_WHITELIST_RATELIMIT = 58, /* VAR_RRL_WHITELIST_RATELIMIT */ 201 YYSYMBOL_VAR_TLS_SERVICE_KEY = 59, /* VAR_TLS_SERVICE_KEY */ 202 YYSYMBOL_VAR_TLS_SERVICE_PEM = 60, /* VAR_TLS_SERVICE_PEM */ 203 YYSYMBOL_VAR_TLS_SERVICE_OCSP = 61, /* VAR_TLS_SERVICE_OCSP */ 204 YYSYMBOL_VAR_TLS_PORT = 62, /* VAR_TLS_PORT */ 205 YYSYMBOL_VAR_TLS_CERT_BUNDLE = 63, /* VAR_TLS_CERT_BUNDLE */ 206 YYSYMBOL_VAR_PROXY_PROTOCOL_PORT = 64, /* VAR_PROXY_PROTOCOL_PORT */ 207 YYSYMBOL_VAR_CPU_AFFINITY = 65, /* VAR_CPU_AFFINITY */ 208 YYSYMBOL_VAR_XFRD_CPU_AFFINITY = 66, /* VAR_XFRD_CPU_AFFINITY */ 209 YYSYMBOL_VAR_SERVER_CPU_AFFINITY = 67, /* VAR_SERVER_CPU_AFFINITY */ 210 YYSYMBOL_VAR_DROP_UPDATES = 68, /* VAR_DROP_UPDATES */ 211 YYSYMBOL_VAR_XFRD_TCP_MAX = 69, /* VAR_XFRD_TCP_MAX */ 212 YYSYMBOL_VAR_XFRD_TCP_PIPELINE = 70, /* VAR_XFRD_TCP_PIPELINE */ 213 YYSYMBOL_VAR_DNSTAP = 71, /* VAR_DNSTAP */ 214 YYSYMBOL_VAR_DNSTAP_ENABLE = 72, /* VAR_DNSTAP_ENABLE */ 215 YYSYMBOL_VAR_DNSTAP_SOCKET_PATH = 73, /* VAR_DNSTAP_SOCKET_PATH */ 216 YYSYMBOL_VAR_DNSTAP_IP = 74, /* VAR_DNSTAP_IP */ 217 YYSYMBOL_VAR_DNSTAP_TLS = 75, /* VAR_DNSTAP_TLS */ 218 YYSYMBOL_VAR_DNSTAP_TLS_SERVER_NAME = 76, /* VAR_DNSTAP_TLS_SERVER_NAME */ 219 YYSYMBOL_VAR_DNSTAP_TLS_CERT_BUNDLE = 77, /* VAR_DNSTAP_TLS_CERT_BUNDLE */ 220 YYSYMBOL_VAR_DNSTAP_TLS_CLIENT_KEY_FILE = 78, /* VAR_DNSTAP_TLS_CLIENT_KEY_FILE */ 221 YYSYMBOL_VAR_DNSTAP_TLS_CLIENT_CERT_FILE = 79, /* VAR_DNSTAP_TLS_CLIENT_CERT_FILE */ 222 YYSYMBOL_VAR_DNSTAP_SEND_IDENTITY = 80, /* VAR_DNSTAP_SEND_IDENTITY */ 223 YYSYMBOL_VAR_DNSTAP_SEND_VERSION = 81, /* VAR_DNSTAP_SEND_VERSION */ 224 YYSYMBOL_VAR_DNSTAP_IDENTITY = 82, /* VAR_DNSTAP_IDENTITY */ 225 YYSYMBOL_VAR_DNSTAP_VERSION = 83, /* VAR_DNSTAP_VERSION */ 226 YYSYMBOL_VAR_DNSTAP_LOG_AUTH_QUERY_MESSAGES = 84, /* VAR_DNSTAP_LOG_AUTH_QUERY_MESSAGES */ 227 YYSYMBOL_VAR_DNSTAP_LOG_AUTH_RESPONSE_MESSAGES = 85, /* VAR_DNSTAP_LOG_AUTH_RESPONSE_MESSAGES */ 228 YYSYMBOL_VAR_REMOTE_CONTROL = 86, /* VAR_REMOTE_CONTROL */ 229 YYSYMBOL_VAR_CONTROL_ENABLE = 87, /* VAR_CONTROL_ENABLE */ 230 YYSYMBOL_VAR_CONTROL_INTERFACE = 88, /* VAR_CONTROL_INTERFACE */ 231 YYSYMBOL_VAR_CONTROL_PORT = 89, /* VAR_CONTROL_PORT */ 232 YYSYMBOL_VAR_SERVER_KEY_FILE = 90, /* VAR_SERVER_KEY_FILE */ 233 YYSYMBOL_VAR_SERVER_CERT_FILE = 91, /* VAR_SERVER_CERT_FILE */ 234 YYSYMBOL_VAR_CONTROL_KEY_FILE = 92, /* VAR_CONTROL_KEY_FILE */ 235 YYSYMBOL_VAR_CONTROL_CERT_FILE = 93, /* VAR_CONTROL_CERT_FILE */ 236 YYSYMBOL_VAR_KEY = 94, /* VAR_KEY */ 237 YYSYMBOL_VAR_ALGORITHM = 95, /* VAR_ALGORITHM */ 238 YYSYMBOL_VAR_SECRET = 96, /* VAR_SECRET */ 239 YYSYMBOL_VAR_TLS_AUTH = 97, /* VAR_TLS_AUTH */ 240 YYSYMBOL_VAR_TLS_AUTH_DOMAIN_NAME = 98, /* VAR_TLS_AUTH_DOMAIN_NAME */ 241 YYSYMBOL_VAR_TLS_AUTH_CLIENT_CERT = 99, /* VAR_TLS_AUTH_CLIENT_CERT */ 242 YYSYMBOL_VAR_TLS_AUTH_CLIENT_KEY = 100, /* VAR_TLS_AUTH_CLIENT_KEY */ 243 YYSYMBOL_VAR_TLS_AUTH_CLIENT_KEY_PW = 101, /* VAR_TLS_AUTH_CLIENT_KEY_PW */ 244 YYSYMBOL_VAR_PATTERN = 102, /* VAR_PATTERN */ 245 YYSYMBOL_VAR_NAME = 103, /* VAR_NAME */ 246 YYSYMBOL_VAR_ZONEFILE = 104, /* VAR_ZONEFILE */ 247 YYSYMBOL_VAR_NOTIFY = 105, /* VAR_NOTIFY */ 248 YYSYMBOL_VAR_PROVIDE_XFR = 106, /* VAR_PROVIDE_XFR */ 249 YYSYMBOL_VAR_ALLOW_QUERY = 107, /* VAR_ALLOW_QUERY */ 250 YYSYMBOL_VAR_AXFR = 108, /* VAR_AXFR */ 251 YYSYMBOL_VAR_UDP = 109, /* VAR_UDP */ 252 YYSYMBOL_VAR_NOTIFY_RETRY = 110, /* VAR_NOTIFY_RETRY */ 253 YYSYMBOL_VAR_ALLOW_NOTIFY = 111, /* VAR_ALLOW_NOTIFY */ 254 YYSYMBOL_VAR_REQUEST_XFR = 112, /* VAR_REQUEST_XFR */ 255 YYSYMBOL_VAR_ALLOW_AXFR_FALLBACK = 113, /* VAR_ALLOW_AXFR_FALLBACK */ 256 YYSYMBOL_VAR_OUTGOING_INTERFACE = 114, /* VAR_OUTGOING_INTERFACE */ 257 YYSYMBOL_VAR_ANSWER_COOKIE = 115, /* VAR_ANSWER_COOKIE */ 258 YYSYMBOL_VAR_COOKIE_SECRET = 116, /* VAR_COOKIE_SECRET */ 259 YYSYMBOL_VAR_COOKIE_SECRET_FILE = 117, /* VAR_COOKIE_SECRET_FILE */ 260 YYSYMBOL_VAR_MAX_REFRESH_TIME = 118, /* VAR_MAX_REFRESH_TIME */ 261 YYSYMBOL_VAR_MIN_REFRESH_TIME = 119, /* VAR_MIN_REFRESH_TIME */ 262 YYSYMBOL_VAR_MAX_RETRY_TIME = 120, /* VAR_MAX_RETRY_TIME */ 263 YYSYMBOL_VAR_MIN_RETRY_TIME = 121, /* VAR_MIN_RETRY_TIME */ 264 YYSYMBOL_VAR_MIN_EXPIRE_TIME = 122, /* VAR_MIN_EXPIRE_TIME */ 265 YYSYMBOL_VAR_MULTI_MASTER_CHECK = 123, /* VAR_MULTI_MASTER_CHECK */ 266 YYSYMBOL_VAR_SIZE_LIMIT_XFR = 124, /* VAR_SIZE_LIMIT_XFR */ 267 YYSYMBOL_VAR_ZONESTATS = 125, /* VAR_ZONESTATS */ 268 YYSYMBOL_VAR_INCLUDE_PATTERN = 126, /* VAR_INCLUDE_PATTERN */ 269 YYSYMBOL_VAR_STORE_IXFR = 127, /* VAR_STORE_IXFR */ 270 YYSYMBOL_VAR_IXFR_SIZE = 128, /* VAR_IXFR_SIZE */ 271 YYSYMBOL_VAR_IXFR_NUMBER = 129, /* VAR_IXFR_NUMBER */ 272 YYSYMBOL_VAR_CREATE_IXFR = 130, /* VAR_CREATE_IXFR */ 273 YYSYMBOL_VAR_ZONE = 131, /* VAR_ZONE */ 274 YYSYMBOL_VAR_RRL_WHITELIST = 132, /* VAR_RRL_WHITELIST */ 275 YYSYMBOL_VAR_SERVERS = 133, /* VAR_SERVERS */ 276 YYSYMBOL_VAR_BINDTODEVICE = 134, /* VAR_BINDTODEVICE */ 277 YYSYMBOL_VAR_SETFIB = 135, /* VAR_SETFIB */ 278 YYSYMBOL_VAR_VERIFY = 136, /* VAR_VERIFY */ 279 YYSYMBOL_VAR_ENABLE = 137, /* VAR_ENABLE */ 280 YYSYMBOL_VAR_VERIFY_ZONE = 138, /* VAR_VERIFY_ZONE */ 281 YYSYMBOL_VAR_VERIFY_ZONES = 139, /* VAR_VERIFY_ZONES */ 282 YYSYMBOL_VAR_VERIFIER = 140, /* VAR_VERIFIER */ 283 YYSYMBOL_VAR_VERIFIER_COUNT = 141, /* VAR_VERIFIER_COUNT */ 284 YYSYMBOL_VAR_VERIFIER_FEED_ZONE = 142, /* VAR_VERIFIER_FEED_ZONE */ 285 YYSYMBOL_VAR_VERIFIER_TIMEOUT = 143, /* VAR_VERIFIER_TIMEOUT */ 286 YYSYMBOL_YYACCEPT = 144, /* $accept */ 287 YYSYMBOL_blocks = 145, /* blocks */ 288 YYSYMBOL_block = 146, /* block */ 289 YYSYMBOL_server = 147, /* server */ 290 YYSYMBOL_server_block = 148, /* server_block */ 291 YYSYMBOL_server_option = 149, /* server_option */ 292 YYSYMBOL_150_1 = 150, /* $@1 */ 293 YYSYMBOL_socket_options = 151, /* socket_options */ 294 YYSYMBOL_socket_option = 152, /* socket_option */ 295 YYSYMBOL_cpus = 153, /* cpus */ 296 YYSYMBOL_service_cpu_affinity = 154, /* service_cpu_affinity */ 297 YYSYMBOL_dnstap = 155, /* dnstap */ 298 YYSYMBOL_dnstap_block = 156, /* dnstap_block */ 299 YYSYMBOL_dnstap_option = 157, /* dnstap_option */ 300 YYSYMBOL_remote_control = 158, /* remote_control */ 301 YYSYMBOL_remote_control_block = 159, /* remote_control_block */ 302 YYSYMBOL_remote_control_option = 160, /* remote_control_option */ 303 YYSYMBOL_tls_auth = 161, /* tls_auth */ 304 YYSYMBOL_162_2 = 162, /* $@2 */ 305 YYSYMBOL_tls_auth_block = 163, /* tls_auth_block */ 306 YYSYMBOL_tls_auth_option = 164, /* tls_auth_option */ 307 YYSYMBOL_key = 165, /* key */ 308 YYSYMBOL_166_3 = 166, /* $@3 */ 309 YYSYMBOL_key_block = 167, /* key_block */ 310 YYSYMBOL_key_option = 168, /* key_option */ 311 YYSYMBOL_zone = 169, /* zone */ 312 YYSYMBOL_170_4 = 170, /* $@4 */ 313 YYSYMBOL_zone_block = 171, /* zone_block */ 314 YYSYMBOL_zone_option = 172, /* zone_option */ 315 YYSYMBOL_pattern = 173, /* pattern */ 316 YYSYMBOL_174_5 = 174, /* $@5 */ 317 YYSYMBOL_pattern_block = 175, /* pattern_block */ 318 YYSYMBOL_pattern_option = 176, /* pattern_option */ 319 YYSYMBOL_pattern_or_zone_option = 177, /* pattern_or_zone_option */ 320 YYSYMBOL_178_6 = 178, /* $@6 */ 321 YYSYMBOL_179_7 = 179, /* $@7 */ 322 YYSYMBOL_verify = 180, /* verify */ 323 YYSYMBOL_verify_block = 181, /* verify_block */ 324 YYSYMBOL_verify_option = 182, /* verify_option */ 325 YYSYMBOL_command = 183, /* command */ 326 YYSYMBOL_arguments = 184, /* arguments */ 327 YYSYMBOL_ip_address = 185, /* ip_address */ 328 YYSYMBOL_number = 186, /* number */ 329 YYSYMBOL_boolean = 187, /* boolean */ 330 YYSYMBOL_tlsauth_option = 188 /* tlsauth_option */ 331 }; 332 typedef enum yysymbol_kind_t yysymbol_kind_t; 333 334 335 336 337 #ifdef short 338 # undef short 339 #endif 340 341 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure 342 <limits.h> and (if available) <stdint.h> are included 343 so that the code can choose integer types of a good width. */ 344 345 #ifndef __PTRDIFF_MAX__ 346 # include <limits.h> /* INFRINGES ON USER NAME SPACE */ 347 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 348 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */ 349 # define YY_STDINT_H 350 # endif 351 #endif 352 353 /* Narrow types that promote to a signed type and that can represent a 354 signed or unsigned integer of at least N bits. In tables they can 355 save space and decrease cache pressure. Promoting to a signed type 356 helps avoid bugs in integer arithmetic. */ 357 358 #ifdef __INT_LEAST8_MAX__ 359 typedef __INT_LEAST8_TYPE__ yytype_int8; 360 #elif defined YY_STDINT_H 361 typedef int_least8_t yytype_int8; 362 #else 363 typedef signed char yytype_int8; 364 #endif 365 366 #ifdef __INT_LEAST16_MAX__ 367 typedef __INT_LEAST16_TYPE__ yytype_int16; 368 #elif defined YY_STDINT_H 369 typedef int_least16_t yytype_int16; 370 #else 371 typedef short yytype_int16; 372 #endif 373 374 /* Work around bug in HP-UX 11.23, which defines these macros 375 incorrectly for preprocessor constants. This workaround can likely 376 be removed in 2023, as HPE has promised support for HP-UX 11.23 377 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of 378 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */ 379 #ifdef __hpux 380 # undef UINT_LEAST8_MAX 381 # undef UINT_LEAST16_MAX 382 # define UINT_LEAST8_MAX 255 383 # define UINT_LEAST16_MAX 65535 384 #endif 385 386 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ 387 typedef __UINT_LEAST8_TYPE__ yytype_uint8; 388 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ 389 && UINT_LEAST8_MAX <= INT_MAX) 390 typedef uint_least8_t yytype_uint8; 391 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX 392 typedef unsigned char yytype_uint8; 393 #else 394 typedef short yytype_uint8; 395 #endif 396 397 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ 398 typedef __UINT_LEAST16_TYPE__ yytype_uint16; 399 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ 400 && UINT_LEAST16_MAX <= INT_MAX) 401 typedef uint_least16_t yytype_uint16; 402 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX 403 typedef unsigned short yytype_uint16; 404 #else 405 typedef int yytype_uint16; 406 #endif 407 408 #ifndef YYPTRDIFF_T 409 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ 410 # define YYPTRDIFF_T __PTRDIFF_TYPE__ 411 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ 412 # elif defined PTRDIFF_MAX 413 # ifndef ptrdiff_t 414 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 415 # endif 416 # define YYPTRDIFF_T ptrdiff_t 417 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX 418 # else 419 # define YYPTRDIFF_T long 420 # define YYPTRDIFF_MAXIMUM LONG_MAX 421 # endif 422 #endif 423 424 #ifndef YYSIZE_T 425 # ifdef __SIZE_TYPE__ 426 # define YYSIZE_T __SIZE_TYPE__ 427 # elif defined size_t 428 # define YYSIZE_T size_t 429 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 430 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 431 # define YYSIZE_T size_t 432 # else 433 # define YYSIZE_T unsigned 434 # endif 435 #endif 436 437 #define YYSIZE_MAXIMUM \ 438 YY_CAST (YYPTRDIFF_T, \ 439 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ 440 ? YYPTRDIFF_MAXIMUM \ 441 : YY_CAST (YYSIZE_T, -1))) 442 443 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) 444 445 446 /* Stored state numbers (used for stacks). */ 447 typedef yytype_int16 yy_state_t; 448 449 /* State numbers in computations. */ 450 typedef int yy_state_fast_t; 451 452 #ifndef YY_ 453 # if defined YYENABLE_NLS && YYENABLE_NLS 454 # if ENABLE_NLS 455 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 456 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 457 # endif 458 # endif 459 # ifndef YY_ 460 # define YY_(Msgid) Msgid 461 # endif 462 #endif 463 464 465 #ifndef YY_ATTRIBUTE_PURE 466 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 467 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 468 # else 469 # define YY_ATTRIBUTE_PURE 470 # endif 471 #endif 472 473 #ifndef YY_ATTRIBUTE_UNUSED 474 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 475 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 476 # else 477 # define YY_ATTRIBUTE_UNUSED 478 # endif 479 #endif 480 481 /* Suppress unused-variable warnings by "using" E. */ 482 #if ! defined lint || defined __GNUC__ 483 # define YY_USE(E) ((void) (E)) 484 #else 485 # define YY_USE(E) /* empty */ 486 #endif 487 488 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 489 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 490 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 491 _Pragma ("GCC diagnostic push") \ 492 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ 493 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 494 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 495 _Pragma ("GCC diagnostic pop") 496 #else 497 # define YY_INITIAL_VALUE(Value) Value 498 #endif 499 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 500 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 501 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 502 #endif 503 #ifndef YY_INITIAL_VALUE 504 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 505 #endif 506 507 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 508 # define YY_IGNORE_USELESS_CAST_BEGIN \ 509 _Pragma ("GCC diagnostic push") \ 510 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 511 # define YY_IGNORE_USELESS_CAST_END \ 512 _Pragma ("GCC diagnostic pop") 513 #endif 514 #ifndef YY_IGNORE_USELESS_CAST_BEGIN 515 # define YY_IGNORE_USELESS_CAST_BEGIN 516 # define YY_IGNORE_USELESS_CAST_END 517 #endif 518 519 520 #define YY_ASSERT(E) ((void) (0 && (E))) 521 522 #if !defined yyoverflow 523 524 /* The parser invokes alloca or malloc; define the necessary symbols. */ 525 526 # ifdef YYSTACK_USE_ALLOCA 527 # if YYSTACK_USE_ALLOCA 528 # ifdef __GNUC__ 529 # define YYSTACK_ALLOC __builtin_alloca 530 # elif defined __BUILTIN_VA_ARG_INCR 531 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 532 # elif defined _AIX 533 # define YYSTACK_ALLOC __alloca 534 # elif defined _MSC_VER 535 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 536 # define alloca _alloca 537 # else 538 # define YYSTACK_ALLOC alloca 539 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 540 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 541 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 542 # ifndef EXIT_SUCCESS 543 # define EXIT_SUCCESS 0 544 # endif 545 # endif 546 # endif 547 # endif 548 # endif 549 550 # ifdef YYSTACK_ALLOC 551 /* Pacify GCC's 'empty if-body' warning. */ 552 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 553 # ifndef YYSTACK_ALLOC_MAXIMUM 554 /* The OS might guarantee only one guard page at the bottom of the stack, 555 and a page size can be as small as 4096 bytes. So we cannot safely 556 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 557 to allow for a few compiler-allocated temporary stack slots. */ 558 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 559 # endif 560 # else 561 # define YYSTACK_ALLOC YYMALLOC 562 # define YYSTACK_FREE YYFREE 563 # ifndef YYSTACK_ALLOC_MAXIMUM 564 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 565 # endif 566 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 567 && ! ((defined YYMALLOC || defined malloc) \ 568 && (defined YYFREE || defined free))) 569 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 570 # ifndef EXIT_SUCCESS 571 # define EXIT_SUCCESS 0 572 # endif 573 # endif 574 # ifndef YYMALLOC 575 # define YYMALLOC malloc 576 # if ! defined malloc && ! defined EXIT_SUCCESS 577 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 578 # endif 579 # endif 580 # ifndef YYFREE 581 # define YYFREE free 582 # if ! defined free && ! defined EXIT_SUCCESS 583 void free (void *); /* INFRINGES ON USER NAME SPACE */ 584 # endif 585 # endif 586 # endif 587 #endif /* !defined yyoverflow */ 588 589 #if (! defined yyoverflow \ 590 && (! defined __cplusplus \ 591 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 592 593 /* A type that is properly aligned for any stack member. */ 594 union yyalloc 595 { 596 yy_state_t yyss_alloc; 597 YYSTYPE yyvs_alloc; 598 }; 599 600 /* The size of the maximum gap between one aligned stack and the next. */ 601 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) 602 603 /* The size of an array large to enough to hold all stacks, each with 604 N elements. */ 605 # define YYSTACK_BYTES(N) \ 606 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ 607 + YYSTACK_GAP_MAXIMUM) 608 609 # define YYCOPY_NEEDED 1 610 611 /* Relocate STACK from its old location to the new one. The 612 local variables YYSIZE and YYSTACKSIZE give the old and new number of 613 elements in the stack, and YYPTR gives the new location of the 614 stack. Advance YYPTR to a properly aligned location for the next 615 stack. */ 616 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 617 do \ 618 { \ 619 YYPTRDIFF_T yynewbytes; \ 620 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 621 Stack = &yyptr->Stack_alloc; \ 622 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ 623 yyptr += yynewbytes / YYSIZEOF (*yyptr); \ 624 } \ 625 while (0) 626 627 #endif 628 629 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 630 /* Copy COUNT objects from SRC to DST. The source and destination do 631 not overlap. */ 632 # ifndef YYCOPY 633 # if defined __GNUC__ && 1 < __GNUC__ 634 # define YYCOPY(Dst, Src, Count) \ 635 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) 636 # else 637 # define YYCOPY(Dst, Src, Count) \ 638 do \ 639 { \ 640 YYPTRDIFF_T yyi; \ 641 for (yyi = 0; yyi < (Count); yyi++) \ 642 (Dst)[yyi] = (Src)[yyi]; \ 643 } \ 644 while (0) 645 # endif 646 # endif 647 #endif /* !YYCOPY_NEEDED */ 648 649 /* YYFINAL -- State number of the termination state. */ 650 #define YYFINAL 2 651 /* YYLAST -- Last index in YYTABLE. */ 652 #define YYLAST 422 653 654 /* YYNTOKENS -- Number of terminals. */ 655 #define YYNTOKENS 144 656 /* YYNNTS -- Number of nonterminals. */ 657 #define YYNNTS 45 658 /* YYNRULES -- Number of rules. */ 659 #define YYNRULES 197 660 /* YYNSTATES -- Number of states. */ 661 #define YYNSTATES 344 662 663 /* YYMAXUTOK -- Last valid token kind. */ 664 #define YYMAXUTOK 398 665 666 667 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM 668 as returned by yylex, with out-of-bounds checking. */ 669 #define YYTRANSLATE(YYX) \ 670 (0 <= (YYX) && (YYX) <= YYMAXUTOK \ 671 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ 672 : YYSYMBOL_YYUNDEF) 673 674 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 675 as returned by yylex. */ 676 static const yytype_uint8 yytranslate[] = 677 { 678 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 679 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 680 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 681 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 682 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 683 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 684 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 685 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 686 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 687 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 688 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 689 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 690 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 691 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 692 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 693 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 694 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 695 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 696 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 697 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 698 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 699 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 700 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 701 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 702 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 703 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 704 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 705 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 706 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 707 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 708 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 709 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 710 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 711 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 712 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 713 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 714 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 715 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 716 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 717 135, 136, 137, 138, 139, 140, 141, 142, 143 718 }; 719 720 #if YYDEBUG 721 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 722 static const yytype_int16 yyrline[] = 723 { 724 0, 227, 227, 229, 232, 233, 234, 235, 236, 237, 725 238, 239, 242, 245, 245, 249, 248, 265, 273, 275, 726 277, 279, 281, 283, 285, 287, 289, 291, 293, 295, 727 297, 299, 301, 303, 305, 335, 337, 339, 347, 349, 728 351, 353, 355, 357, 359, 361, 363, 370, 372, 374, 729 376, 378, 380, 382, 384, 386, 388, 390, 392, 402, 730 408, 414, 424, 434, 440, 442, 444, 449, 454, 459, 731 461, 463, 465, 467, 469, 476, 478, 486, 488, 490, 732 492, 494, 496, 500, 530, 531, 534, 561, 563, 568, 733 569, 603, 605, 616, 619, 619, 622, 624, 626, 628, 734 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 735 653, 656, 656, 659, 661, 671, 679, 681, 683, 685, 736 691, 690, 712, 712, 715, 726, 730, 734, 738, 746, 737 745, 770, 770, 773, 785, 793, 812, 811, 836, 836, 738 839, 852, 856, 855, 872, 872, 875, 882, 885, 891, 739 893, 895, 903, 905, 908, 907, 919, 918, 930, 940, 740 945, 954, 959, 964, 969, 974, 979, 984, 989, 994, 741 999, 1011, 1016, 1021, 1026, 1031, 1033, 1035, 1037, 1041, 742 1044, 1044, 1047, 1049, 1059, 1066, 1068, 1070, 1072, 1074, 743 1078, 1098, 1099, 1117, 1127, 1136, 1144, 1145 744 }; 745 #endif 746 747 /** Accessing symbol of state STATE. */ 748 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) 749 750 #if YYDEBUG || 0 751 /* The user-facing name of the symbol whose (internal) number is 752 YYSYMBOL. No bounds checking. */ 753 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; 754 755 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 756 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 757 static const char *const yytname[] = 758 { 759 "\"end of file\"", "error", "\"invalid token\"", "STRING", "VAR_SERVER", 760 "VAR_SERVER_COUNT", "VAR_IP_ADDRESS", "VAR_IP_TRANSPARENT", 761 "VAR_IP_FREEBIND", "VAR_REUSEPORT", "VAR_SEND_BUFFER_SIZE", 762 "VAR_RECEIVE_BUFFER_SIZE", "VAR_DEBUG_MODE", "VAR_IP4_ONLY", 763 "VAR_IP6_ONLY", "VAR_DO_IP4", "VAR_DO_IP6", "VAR_PORT", 764 "VAR_USE_SYSTEMD", "VAR_VERBOSITY", "VAR_USERNAME", "VAR_CHROOT", 765 "VAR_ZONESDIR", "VAR_ZONELISTFILE", "VAR_DATABASE", "VAR_LOGFILE", 766 "VAR_LOG_ONLY_SYSLOG", "VAR_PIDFILE", "VAR_DIFFFILE", "VAR_XFRDFILE", 767 "VAR_XFRDIR", "VAR_HIDE_VERSION", "VAR_HIDE_IDENTITY", "VAR_VERSION", 768 "VAR_IDENTITY", "VAR_NSID", "VAR_TCP_COUNT", "VAR_TCP_REJECT_OVERFLOW", 769 "VAR_TCP_QUERY_COUNT", "VAR_TCP_TIMEOUT", "VAR_TCP_MSS", 770 "VAR_OUTGOING_TCP_MSS", "VAR_IPV4_EDNS_SIZE", "VAR_IPV6_EDNS_SIZE", 771 "VAR_STATISTICS", "VAR_XFRD_RELOAD_TIMEOUT", "VAR_LOG_TIME_ASCII", 772 "VAR_ROUND_ROBIN", "VAR_MINIMAL_RESPONSES", "VAR_CONFINE_TO_ZONE", 773 "VAR_REFUSE_ANY", "VAR_ZONEFILES_CHECK", "VAR_ZONEFILES_WRITE", 774 "VAR_RRL_SIZE", "VAR_RRL_RATELIMIT", "VAR_RRL_SLIP", 775 "VAR_RRL_IPV4_PREFIX_LENGTH", "VAR_RRL_IPV6_PREFIX_LENGTH", 776 "VAR_RRL_WHITELIST_RATELIMIT", "VAR_TLS_SERVICE_KEY", 777 "VAR_TLS_SERVICE_PEM", "VAR_TLS_SERVICE_OCSP", "VAR_TLS_PORT", 778 "VAR_TLS_CERT_BUNDLE", "VAR_PROXY_PROTOCOL_PORT", "VAR_CPU_AFFINITY", 779 "VAR_XFRD_CPU_AFFINITY", "VAR_SERVER_CPU_AFFINITY", "VAR_DROP_UPDATES", 780 "VAR_XFRD_TCP_MAX", "VAR_XFRD_TCP_PIPELINE", "VAR_DNSTAP", 781 "VAR_DNSTAP_ENABLE", "VAR_DNSTAP_SOCKET_PATH", "VAR_DNSTAP_IP", 782 "VAR_DNSTAP_TLS", "VAR_DNSTAP_TLS_SERVER_NAME", 783 "VAR_DNSTAP_TLS_CERT_BUNDLE", "VAR_DNSTAP_TLS_CLIENT_KEY_FILE", 784 "VAR_DNSTAP_TLS_CLIENT_CERT_FILE", "VAR_DNSTAP_SEND_IDENTITY", 785 "VAR_DNSTAP_SEND_VERSION", "VAR_DNSTAP_IDENTITY", "VAR_DNSTAP_VERSION", 786 "VAR_DNSTAP_LOG_AUTH_QUERY_MESSAGES", 787 "VAR_DNSTAP_LOG_AUTH_RESPONSE_MESSAGES", "VAR_REMOTE_CONTROL", 788 "VAR_CONTROL_ENABLE", "VAR_CONTROL_INTERFACE", "VAR_CONTROL_PORT", 789 "VAR_SERVER_KEY_FILE", "VAR_SERVER_CERT_FILE", "VAR_CONTROL_KEY_FILE", 790 "VAR_CONTROL_CERT_FILE", "VAR_KEY", "VAR_ALGORITHM", "VAR_SECRET", 791 "VAR_TLS_AUTH", "VAR_TLS_AUTH_DOMAIN_NAME", "VAR_TLS_AUTH_CLIENT_CERT", 792 "VAR_TLS_AUTH_CLIENT_KEY", "VAR_TLS_AUTH_CLIENT_KEY_PW", "VAR_PATTERN", 793 "VAR_NAME", "VAR_ZONEFILE", "VAR_NOTIFY", "VAR_PROVIDE_XFR", 794 "VAR_ALLOW_QUERY", "VAR_AXFR", "VAR_UDP", "VAR_NOTIFY_RETRY", 795 "VAR_ALLOW_NOTIFY", "VAR_REQUEST_XFR", "VAR_ALLOW_AXFR_FALLBACK", 796 "VAR_OUTGOING_INTERFACE", "VAR_ANSWER_COOKIE", "VAR_COOKIE_SECRET", 797 "VAR_COOKIE_SECRET_FILE", "VAR_MAX_REFRESH_TIME", "VAR_MIN_REFRESH_TIME", 798 "VAR_MAX_RETRY_TIME", "VAR_MIN_RETRY_TIME", "VAR_MIN_EXPIRE_TIME", 799 "VAR_MULTI_MASTER_CHECK", "VAR_SIZE_LIMIT_XFR", "VAR_ZONESTATS", 800 "VAR_INCLUDE_PATTERN", "VAR_STORE_IXFR", "VAR_IXFR_SIZE", 801 "VAR_IXFR_NUMBER", "VAR_CREATE_IXFR", "VAR_ZONE", "VAR_RRL_WHITELIST", 802 "VAR_SERVERS", "VAR_BINDTODEVICE", "VAR_SETFIB", "VAR_VERIFY", 803 "VAR_ENABLE", "VAR_VERIFY_ZONE", "VAR_VERIFY_ZONES", "VAR_VERIFIER", 804 "VAR_VERIFIER_COUNT", "VAR_VERIFIER_FEED_ZONE", "VAR_VERIFIER_TIMEOUT", 805 "$accept", "blocks", "block", "server", "server_block", "server_option", 806 "$@1", "socket_options", "socket_option", "cpus", "service_cpu_affinity", 807 "dnstap", "dnstap_block", "dnstap_option", "remote_control", 808 "remote_control_block", "remote_control_option", "tls_auth", "$@2", 809 "tls_auth_block", "tls_auth_option", "key", "$@3", "key_block", 810 "key_option", "zone", "$@4", "zone_block", "zone_option", "pattern", 811 "$@5", "pattern_block", "pattern_option", "pattern_or_zone_option", 812 "$@6", "$@7", "verify", "verify_block", "verify_option", "command", 813 "arguments", "ip_address", "number", "boolean", "tlsauth_option", YY_NULLPTR 814 }; 815 816 static const char * 817 yysymbol_name (yysymbol_kind_t yysymbol) 818 { 819 return yytname[yysymbol]; 820 } 821 #endif 822 823 #ifdef YYPRINT 824 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 825 (internal) symbol number NUM (which must be that of a token). */ 826 static const yytype_int16 yytoknum[] = 827 { 828 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 829 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 830 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 831 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 832 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 833 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 834 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 835 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 836 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 837 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 838 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 839 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 840 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 841 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 842 395, 396, 397, 398 843 }; 844 #endif 845 846 #define YYPACT_NINF (-162) 847 848 #define yypact_value_is_default(Yyn) \ 849 ((Yyn) == YYPACT_NINF) 850 851 #define YYTABLE_NINF (-1) 852 853 #define yytable_value_is_error(Yyn) \ 854 0 855 856 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 857 STATE-NUM. */ 858 static const yytype_int16 yypact[] = 859 { 860 -162, 65, -162, -162, -162, -162, -162, -162, -162, -162, 861 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 862 305, -28, -57, -162, -162, -162, -162, 5, 0, 9, 863 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 864 0, 14, 0, 18, 22, 23, 25, 34, 55, 14, 865 56, 58, 59, 61, 14, 14, 63, 64, 67, 0, 866 14, 0, 0, 0, 0, 0, 0, 0, 0, 14, 867 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 868 0, 0, 69, 70, 71, 0, 72, 0, -162, -162, 869 -162, 14, 0, 0, 14, 79, 81, -162, 0, 14, 870 83, 89, 14, 91, 92, 93, 96, 14, 14, 97, 871 99, 14, 14, -162, 14, 9, 0, 100, 102, 113, 872 114, -162, -76, -10, 130, 275, 9, 0, 14, 14, 873 115, 0, 14, 0, -162, -162, -162, -162, -162, -162, 874 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 875 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 876 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 877 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 878 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 879 -162, -162, -162, -162, -162, -162, -162, -162, 116, -162, 880 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 881 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 882 -162, -162, -162, -162, -162, -162, -162, 124, 125, 126, 883 -162, 128, 131, 132, 136, 137, -162, 138, 146, 147, 884 149, 150, 0, 151, 6, 14, 152, 0, 0, 0, 885 0, 153, 14, 0, 154, 155, 14, 0, 0, 14, 886 157, 14, 115, 14, 0, -162, -162, 160, -162, -162, 887 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 888 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 889 -162, 161, 162, 163, -162, 165, 166, 167, 168, -162, 890 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 891 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 892 170, -119, -162, -162, -162, -162, -162, 171, 172, -162, 893 174, 14, 0, -162, 176, -162, -162, -162, -162, -162, 894 -162, -162, 176, -162 895 }; 896 897 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 898 Performed when YYTABLE does not specify something else to do. Zero 899 means the default is an error. */ 900 static const yytype_uint8 yydefact[] = 901 { 902 2, 0, 1, 14, 95, 112, 129, 120, 142, 136, 903 181, 3, 4, 5, 6, 8, 7, 10, 9, 11, 904 12, 93, 110, 132, 123, 145, 139, 179, 0, 0, 905 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 906 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 907 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 908 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 909 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 910 0, 0, 0, 0, 0, 0, 0, 0, 89, 91, 911 92, 0, 0, 0, 0, 0, 0, 13, 0, 0, 912 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 913 0, 0, 0, 94, 0, 0, 0, 0, 0, 0, 914 0, 111, 130, 121, 143, 137, 0, 0, 0, 0, 915 0, 0, 0, 0, 180, 194, 17, 193, 15, 195, 916 18, 19, 47, 20, 21, 22, 27, 28, 29, 30, 917 46, 23, 57, 50, 49, 51, 52, 31, 35, 36, 918 45, 53, 54, 55, 24, 25, 33, 32, 34, 37, 919 38, 39, 40, 41, 42, 43, 44, 48, 56, 66, 920 67, 68, 69, 70, 64, 65, 58, 59, 60, 61, 921 62, 63, 71, 73, 72, 74, 75, 76, 82, 26, 922 80, 81, 77, 78, 79, 83, 96, 97, 98, 99, 923 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 924 113, 114, 115, 116, 117, 118, 119, 0, 0, 0, 925 131, 0, 0, 0, 0, 0, 122, 0, 0, 0, 926 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 927 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 928 0, 0, 0, 0, 0, 144, 147, 0, 138, 141, 929 183, 184, 182, 185, 191, 186, 187, 189, 188, 84, 930 90, 134, 135, 133, 125, 126, 127, 128, 124, 146, 931 149, 0, 0, 0, 165, 0, 0, 0, 0, 164, 932 163, 166, 167, 168, 169, 170, 152, 151, 150, 153, 933 171, 172, 173, 174, 148, 175, 176, 177, 178, 140, 934 190, 16, 160, 161, 162, 159, 154, 0, 0, 192, 935 0, 0, 0, 85, 196, 156, 158, 86, 87, 88, 936 197, 155, 196, 157 937 }; 938 939 /* YYPGOTO[NTERM-NUM]. */ 940 static const yytype_int16 yypgoto[] = 941 { 942 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 943 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 944 -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, 945 -162, -162, -162, 8, -162, -162, -162, -162, -162, -82, 946 -162, -113, 45, -31, -161 947 }; 948 949 /* YYDEFGOTO[NTERM-NUM]. */ 950 static const yytype_int16 yydefgoto[] = 951 { 952 0, 1, 11, 12, 20, 97, 279, 321, 333, 198, 953 98, 13, 21, 113, 14, 22, 121, 15, 24, 123, 954 236, 16, 23, 122, 230, 17, 26, 125, 268, 18, 955 25, 124, 265, 266, 334, 342, 19, 27, 134, 275, 956 320, 138, 136, 140, 341 957 }; 958 959 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 960 positive, shift that token. If negative, reduce the rule whose 961 number is the opposite. If YYTABLE_NINF, syntax error. */ 962 static const yytype_int16 yytable[] = 963 { 964 141, 142, 221, 135, 145, 146, 147, 148, 149, 296, 965 151, 126, 137, 270, 330, 331, 332, 139, 159, 227, 966 228, 153, 127, 164, 165, 154, 155, 229, 156, 170, 967 114, 115, 116, 117, 118, 119, 120, 157, 179, 180, 968 181, 182, 183, 184, 99, 100, 101, 102, 103, 104, 969 105, 106, 107, 108, 109, 110, 111, 112, 158, 160, 970 199, 161, 162, 202, 163, 2, 166, 167, 206, 3, 971 168, 209, 192, 193, 194, 196, 214, 215, 143, 144, 972 218, 219, 203, 220, 204, 150, 207, 152, 231, 232, 973 233, 234, 208, 235, 210, 211, 212, 272, 273, 213, 974 216, 277, 217, 223, 169, 224, 171, 172, 173, 174, 975 175, 176, 177, 178, 297, 298, 225, 226, 274, 280, 976 185, 186, 187, 188, 189, 190, 191, 281, 282, 283, 977 195, 284, 197, 269, 285, 286, 4, 200, 201, 287, 978 288, 289, 128, 205, 129, 130, 131, 132, 133, 290, 979 291, 5, 292, 293, 295, 300, 305, 308, 309, 6, 980 314, 222, 7, 319, 322, 323, 324, 8, 325, 326, 981 327, 328, 271, 329, 335, 336, 276, 337, 278, 340, 982 316, 343, 0, 0, 0, 0, 0, 0, 0, 0, 983 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 984 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 985 0, 0, 0, 0, 299, 0, 0, 0, 0, 0, 986 0, 306, 0, 0, 0, 310, 0, 0, 313, 0, 987 315, 0, 317, 237, 238, 239, 240, 241, 0, 0, 988 242, 243, 244, 245, 246, 0, 0, 0, 247, 248, 989 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 990 259, 0, 260, 0, 0, 0, 0, 0, 261, 0, 991 262, 0, 263, 264, 0, 0, 0, 0, 0, 0, 992 0, 0, 0, 0, 0, 0, 0, 294, 0, 0, 993 0, 0, 301, 302, 303, 304, 0, 0, 307, 0, 994 338, 0, 311, 312, 0, 0, 0, 0, 0, 318, 995 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 996 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 997 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 998 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 999 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 1000 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 1001 88, 89, 90, 91, 92, 93, 0, 339, 267, 238, 1002 239, 240, 241, 0, 0, 242, 243, 244, 245, 246, 1003 0, 0, 0, 247, 248, 249, 250, 251, 252, 253, 1004 254, 255, 256, 257, 258, 259, 0, 260, 0, 0, 1005 0, 0, 0, 261, 0, 262, 0, 263, 264, 0, 1006 94, 95, 96 1007 }; 1008 1009 static const yytype_int16 yycheck[] = 1010 { 1011 31, 32, 115, 3, 35, 36, 37, 38, 39, 3, 1012 41, 6, 3, 126, 133, 134, 135, 3, 49, 95, 1013 96, 3, 17, 54, 55, 3, 3, 103, 3, 60, 1014 87, 88, 89, 90, 91, 92, 93, 3, 69, 70, 1015 71, 72, 73, 74, 72, 73, 74, 75, 76, 77, 1016 78, 79, 80, 81, 82, 83, 84, 85, 3, 3, 1017 91, 3, 3, 94, 3, 0, 3, 3, 99, 4, 1018 3, 102, 3, 3, 3, 3, 107, 108, 33, 34, 1019 111, 112, 3, 114, 3, 40, 3, 42, 98, 99, 1020 100, 101, 3, 103, 3, 3, 3, 128, 129, 3, 1021 3, 132, 3, 3, 59, 3, 61, 62, 63, 64, 1022 65, 66, 67, 68, 108, 109, 3, 3, 3, 3, 1023 75, 76, 77, 78, 79, 80, 81, 3, 3, 3, 1024 85, 3, 87, 125, 3, 3, 71, 92, 93, 3, 1025 3, 3, 137, 98, 139, 140, 141, 142, 143, 3, 1026 3, 86, 3, 3, 3, 3, 3, 3, 3, 94, 1027 3, 116, 97, 3, 3, 3, 3, 102, 3, 3, 1028 3, 3, 127, 3, 3, 3, 131, 3, 133, 3, 1029 262, 342, -1, -1, -1, -1, -1, -1, -1, -1, 1030 -1, -1, -1, -1, -1, -1, 131, -1, -1, -1, 1031 -1, 136, -1, -1, -1, -1, -1, -1, -1, -1, 1032 -1, -1, -1, -1, 245, -1, -1, -1, -1, -1, 1033 -1, 252, -1, -1, -1, 256, -1, -1, 259, -1, 1034 261, -1, 263, 103, 104, 105, 106, 107, -1, -1, 1035 110, 111, 112, 113, 114, -1, -1, -1, 118, 119, 1036 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 1037 130, -1, 132, -1, -1, -1, -1, -1, 138, -1, 1038 140, -1, 142, 143, -1, -1, -1, -1, -1, -1, 1039 -1, -1, -1, -1, -1, -1, -1, 242, -1, -1, 1040 -1, -1, 247, 248, 249, 250, -1, -1, 253, -1, 1041 331, -1, 257, 258, -1, -1, -1, -1, -1, 264, 1042 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1043 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 1044 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1045 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 1046 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 1047 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 1048 65, 66, 67, 68, 69, 70, -1, 332, 103, 104, 1049 105, 106, 107, -1, -1, 110, 111, 112, 113, 114, 1050 -1, -1, -1, 118, 119, 120, 121, 122, 123, 124, 1051 125, 126, 127, 128, 129, 130, -1, 132, -1, -1, 1052 -1, -1, -1, 138, -1, 140, -1, 142, 143, -1, 1053 115, 116, 117 1054 }; 1055 1056 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1057 symbol of state STATE-NUM. */ 1058 static const yytype_uint8 yystos[] = 1059 { 1060 0, 145, 0, 4, 71, 86, 94, 97, 102, 131, 1061 136, 146, 147, 155, 158, 161, 165, 169, 173, 180, 1062 148, 156, 159, 166, 162, 174, 170, 181, 5, 6, 1063 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1064 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1065 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 1066 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 1067 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 1068 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 1069 67, 68, 69, 70, 115, 116, 117, 149, 154, 72, 1070 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1071 83, 84, 85, 157, 87, 88, 89, 90, 91, 92, 1072 93, 160, 167, 163, 175, 171, 6, 17, 137, 139, 1073 140, 141, 142, 143, 182, 3, 186, 3, 185, 3, 1074 187, 187, 187, 186, 186, 187, 187, 187, 187, 187, 1075 186, 187, 186, 3, 3, 3, 3, 3, 3, 187, 1076 3, 3, 3, 3, 187, 187, 3, 3, 3, 186, 1077 187, 186, 186, 186, 186, 186, 186, 186, 186, 187, 1078 187, 187, 187, 187, 187, 186, 186, 186, 186, 186, 1079 186, 186, 3, 3, 3, 186, 3, 186, 153, 187, 1080 186, 186, 187, 3, 3, 186, 187, 3, 3, 187, 1081 3, 3, 3, 3, 187, 187, 3, 3, 187, 187, 1082 187, 185, 186, 3, 3, 3, 3, 95, 96, 103, 1083 168, 98, 99, 100, 101, 103, 164, 103, 104, 105, 1084 106, 107, 110, 111, 112, 113, 114, 118, 119, 120, 1085 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 1086 132, 138, 140, 142, 143, 176, 177, 103, 172, 177, 1087 185, 186, 187, 187, 3, 183, 186, 187, 186, 150, 1088 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1089 3, 3, 3, 3, 186, 3, 3, 108, 109, 187, 1090 3, 186, 186, 186, 186, 3, 187, 186, 3, 3, 1091 187, 186, 186, 187, 3, 187, 183, 187, 186, 3, 1092 184, 151, 3, 3, 3, 3, 3, 3, 3, 3, 1093 133, 134, 135, 152, 178, 3, 3, 3, 187, 186, 1094 3, 188, 179, 188 1095 }; 1096 1097 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 1098 static const yytype_uint8 yyr1[] = 1099 { 1100 0, 144, 145, 145, 146, 146, 146, 146, 146, 146, 1101 146, 146, 147, 148, 148, 150, 149, 149, 149, 149, 1102 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 1103 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 1104 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 1105 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 1106 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 1107 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 1108 149, 149, 149, 149, 151, 151, 152, 152, 152, 153, 1109 153, 154, 154, 155, 156, 156, 157, 157, 157, 157, 1110 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 1111 158, 159, 159, 160, 160, 160, 160, 160, 160, 160, 1112 162, 161, 163, 163, 164, 164, 164, 164, 164, 166, 1113 165, 167, 167, 168, 168, 168, 170, 169, 171, 171, 1114 172, 172, 174, 173, 175, 175, 176, 176, 177, 177, 1115 177, 177, 177, 177, 178, 177, 179, 177, 177, 177, 1116 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 1117 177, 177, 177, 177, 177, 177, 177, 177, 177, 180, 1118 181, 181, 182, 182, 182, 182, 182, 182, 182, 182, 1119 183, 184, 184, 185, 186, 187, 188, 188 1120 }; 1121 1122 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 1123 static const yytype_int8 yyr2[] = 1124 { 1125 0, 2, 0, 2, 1, 1, 1, 1, 1, 1, 1126 1, 1, 2, 2, 0, 0, 4, 2, 2, 2, 1127 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1128 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1129 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1130 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1131 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1132 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1133 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 1134 2, 1, 1, 2, 2, 0, 2, 2, 2, 2, 1135 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1136 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 1137 0, 3, 2, 0, 2, 2, 2, 2, 2, 0, 1138 3, 2, 0, 2, 2, 2, 0, 3, 2, 0, 1139 2, 1, 0, 3, 2, 0, 2, 1, 2, 2, 1140 2, 2, 2, 2, 0, 5, 0, 6, 4, 3, 1141 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 1142 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1143 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 1144 2, 0, 2, 1, 1, 1, 0, 1 1145 }; 1146 1147 1148 enum { YYENOMEM = -2 }; 1149 1150 #define yyerrok (yyerrstatus = 0) 1151 #define yyclearin (yychar = YYEMPTY) 1152 1153 #define YYACCEPT goto yyacceptlab 1154 #define YYABORT goto yyabortlab 1155 #define YYERROR goto yyerrorlab 1156 1157 1158 #define YYRECOVERING() (!!yyerrstatus) 1159 1160 #define YYBACKUP(Token, Value) \ 1161 do \ 1162 if (yychar == YYEMPTY) \ 1163 { \ 1164 yychar = (Token); \ 1165 yylval = (Value); \ 1166 YYPOPSTACK (yylen); \ 1167 yystate = *yyssp; \ 1168 goto yybackup; \ 1169 } \ 1170 else \ 1171 { \ 1172 yyerror (YY_("syntax error: cannot back up")); \ 1173 YYERROR; \ 1174 } \ 1175 while (0) 1176 1177 /* Backward compatibility with an undocumented macro. 1178 Use YYerror or YYUNDEF. */ 1179 #define YYERRCODE YYUNDEF 1180 1181 1182 /* Enable debugging if requested. */ 1183 #if YYDEBUG 1184 1185 # ifndef YYFPRINTF 1186 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1187 # define YYFPRINTF fprintf 1188 # endif 1189 1190 # define YYDPRINTF(Args) \ 1191 do { \ 1192 if (yydebug) \ 1193 YYFPRINTF Args; \ 1194 } while (0) 1195 1196 /* This macro is provided for backward compatibility. */ 1197 # ifndef YY_LOCATION_PRINT 1198 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1199 # endif 1200 1201 1202 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ 1203 do { \ 1204 if (yydebug) \ 1205 { \ 1206 YYFPRINTF (stderr, "%s ", Title); \ 1207 yy_symbol_print (stderr, \ 1208 Kind, Value); \ 1209 YYFPRINTF (stderr, "\n"); \ 1210 } \ 1211 } while (0) 1212 1213 1214 /*-----------------------------------. 1215 | Print this symbol's value on YYO. | 1216 `-----------------------------------*/ 1217 1218 static void 1219 yy_symbol_value_print (FILE *yyo, 1220 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 1221 { 1222 FILE *yyoutput = yyo; 1223 YY_USE (yyoutput); 1224 if (!yyvaluep) 1225 return; 1226 # ifdef YYPRINT 1227 if (yykind < YYNTOKENS) 1228 YYPRINT (yyo, yytoknum[yykind], *yyvaluep); 1229 # endif 1230 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1231 YY_USE (yykind); 1232 YY_IGNORE_MAYBE_UNINITIALIZED_END 1233 } 1234 1235 1236 /*---------------------------. 1237 | Print this symbol on YYO. | 1238 `---------------------------*/ 1239 1240 static void 1241 yy_symbol_print (FILE *yyo, 1242 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 1243 { 1244 YYFPRINTF (yyo, "%s %s (", 1245 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); 1246 1247 yy_symbol_value_print (yyo, yykind, yyvaluep); 1248 YYFPRINTF (yyo, ")"); 1249 } 1250 1251 /*------------------------------------------------------------------. 1252 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1253 | TOP (included). | 1254 `------------------------------------------------------------------*/ 1255 1256 static void 1257 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) 1258 { 1259 YYFPRINTF (stderr, "Stack now"); 1260 for (; yybottom <= yytop; yybottom++) 1261 { 1262 int yybot = *yybottom; 1263 YYFPRINTF (stderr, " %d", yybot); 1264 } 1265 YYFPRINTF (stderr, "\n"); 1266 } 1267 1268 # define YY_STACK_PRINT(Bottom, Top) \ 1269 do { \ 1270 if (yydebug) \ 1271 yy_stack_print ((Bottom), (Top)); \ 1272 } while (0) 1273 1274 1275 /*------------------------------------------------. 1276 | Report that the YYRULE is going to be reduced. | 1277 `------------------------------------------------*/ 1278 1279 static void 1280 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, 1281 int yyrule) 1282 { 1283 int yylno = yyrline[yyrule]; 1284 int yynrhs = yyr2[yyrule]; 1285 int yyi; 1286 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", 1287 yyrule - 1, yylno); 1288 /* The symbols being reduced. */ 1289 for (yyi = 0; yyi < yynrhs; yyi++) 1290 { 1291 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1292 yy_symbol_print (stderr, 1293 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), 1294 &yyvsp[(yyi + 1) - (yynrhs)]); 1295 YYFPRINTF (stderr, "\n"); 1296 } 1297 } 1298 1299 # define YY_REDUCE_PRINT(Rule) \ 1300 do { \ 1301 if (yydebug) \ 1302 yy_reduce_print (yyssp, yyvsp, Rule); \ 1303 } while (0) 1304 1305 /* Nonzero means print parse trace. It is left uninitialized so that 1306 multiple parsers can coexist. */ 1307 int yydebug; 1308 #else /* !YYDEBUG */ 1309 # define YYDPRINTF(Args) ((void) 0) 1310 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) 1311 # define YY_STACK_PRINT(Bottom, Top) 1312 # define YY_REDUCE_PRINT(Rule) 1313 #endif /* !YYDEBUG */ 1314 1315 1316 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1317 #ifndef YYINITDEPTH 1318 # define YYINITDEPTH 200 1319 #endif 1320 1321 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1322 if the built-in stack extension method is used). 1323 1324 Do not make this value too large; the results are undefined if 1325 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1326 evaluated with infinite-precision integer arithmetic. */ 1327 1328 #ifndef YYMAXDEPTH 1329 # define YYMAXDEPTH 10000 1330 #endif 1331 1332 1333 1334 1335 1336 1337 /*-----------------------------------------------. 1338 | Release the memory associated to this symbol. | 1339 `-----------------------------------------------*/ 1340 1341 static void 1342 yydestruct (const char *yymsg, 1343 yysymbol_kind_t yykind, YYSTYPE *yyvaluep) 1344 { 1345 YY_USE (yyvaluep); 1346 if (!yymsg) 1347 yymsg = "Deleting"; 1348 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1349 1350 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1351 YY_USE (yykind); 1352 YY_IGNORE_MAYBE_UNINITIALIZED_END 1353 } 1354 1355 1356 /* Lookahead token kind. */ 1357 int yychar; 1358 1359 /* The semantic value of the lookahead symbol. */ 1360 YYSTYPE yylval; 1361 /* Number of syntax errors so far. */ 1362 int yynerrs; 1363 1364 1365 1366 1367 /*----------. 1368 | yyparse. | 1369 `----------*/ 1370 1371 int 1372 yyparse (void) 1373 { 1374 yy_state_fast_t yystate = 0; 1375 /* Number of tokens to shift before error messages enabled. */ 1376 int yyerrstatus = 0; 1377 1378 /* Refer to the stacks through separate pointers, to allow yyoverflow 1379 to reallocate them elsewhere. */ 1380 1381 /* Their size. */ 1382 YYPTRDIFF_T yystacksize = YYINITDEPTH; 1383 1384 /* The state stack: array, bottom, top. */ 1385 yy_state_t yyssa[YYINITDEPTH]; 1386 yy_state_t *yyss = yyssa; 1387 yy_state_t *yyssp = yyss; 1388 1389 /* The semantic value stack: array, bottom, top. */ 1390 YYSTYPE yyvsa[YYINITDEPTH]; 1391 YYSTYPE *yyvs = yyvsa; 1392 YYSTYPE *yyvsp = yyvs; 1393 1394 int yyn; 1395 /* The return value of yyparse. */ 1396 int yyresult; 1397 /* Lookahead symbol kind. */ 1398 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1399 /* The variables used to return semantic value and location from the 1400 action routines. */ 1401 YYSTYPE yyval; 1402 1403 1404 1405 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1406 1407 /* The number of symbols on the RHS of the reduced rule. 1408 Keep to zero when no symbol should be popped. */ 1409 int yylen = 0; 1410 1411 YYDPRINTF ((stderr, "Starting parse\n")); 1412 1413 yychar = YYEMPTY; /* Cause a token to be read. */ 1414 goto yysetstate; 1415 1416 1417 /*------------------------------------------------------------. 1418 | yynewstate -- push a new state, which is found in yystate. | 1419 `------------------------------------------------------------*/ 1420 yynewstate: 1421 /* In all cases, when you get here, the value and location stacks 1422 have just been pushed. So pushing a state here evens the stacks. */ 1423 yyssp++; 1424 1425 1426 /*--------------------------------------------------------------------. 1427 | yysetstate -- set current state (the top of the stack) to yystate. | 1428 `--------------------------------------------------------------------*/ 1429 yysetstate: 1430 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1431 YY_ASSERT (0 <= yystate && yystate < YYNSTATES); 1432 YY_IGNORE_USELESS_CAST_BEGIN 1433 *yyssp = YY_CAST (yy_state_t, yystate); 1434 YY_IGNORE_USELESS_CAST_END 1435 YY_STACK_PRINT (yyss, yyssp); 1436 1437 if (yyss + yystacksize - 1 <= yyssp) 1438 #if !defined yyoverflow && !defined YYSTACK_RELOCATE 1439 goto yyexhaustedlab; 1440 #else 1441 { 1442 /* Get the current used size of the three stacks, in elements. */ 1443 YYPTRDIFF_T yysize = yyssp - yyss + 1; 1444 1445 # if defined yyoverflow 1446 { 1447 /* Give user a chance to reallocate the stack. Use copies of 1448 these so that the &'s don't force the real ones into 1449 memory. */ 1450 yy_state_t *yyss1 = yyss; 1451 YYSTYPE *yyvs1 = yyvs; 1452 1453 /* Each stack pointer address is followed by the size of the 1454 data in use in that stack, in bytes. This used to be a 1455 conditional around just the two extra args, but that might 1456 be undefined if yyoverflow is a macro. */ 1457 yyoverflow (YY_("memory exhausted"), 1458 &yyss1, yysize * YYSIZEOF (*yyssp), 1459 &yyvs1, yysize * YYSIZEOF (*yyvsp), 1460 &yystacksize); 1461 yyss = yyss1; 1462 yyvs = yyvs1; 1463 } 1464 # else /* defined YYSTACK_RELOCATE */ 1465 /* Extend the stack our own way. */ 1466 if (YYMAXDEPTH <= yystacksize) 1467 goto yyexhaustedlab; 1468 yystacksize *= 2; 1469 if (YYMAXDEPTH < yystacksize) 1470 yystacksize = YYMAXDEPTH; 1471 1472 { 1473 yy_state_t *yyss1 = yyss; 1474 union yyalloc *yyptr = 1475 YY_CAST (union yyalloc *, 1476 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1477 if (! yyptr) 1478 goto yyexhaustedlab; 1479 YYSTACK_RELOCATE (yyss_alloc, yyss); 1480 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1481 # undef YYSTACK_RELOCATE 1482 if (yyss1 != yyssa) 1483 YYSTACK_FREE (yyss1); 1484 } 1485 # endif 1486 1487 yyssp = yyss + yysize - 1; 1488 yyvsp = yyvs + yysize - 1; 1489 1490 YY_IGNORE_USELESS_CAST_BEGIN 1491 YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1492 YY_CAST (long, yystacksize))); 1493 YY_IGNORE_USELESS_CAST_END 1494 1495 if (yyss + yystacksize - 1 <= yyssp) 1496 YYABORT; 1497 } 1498 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1499 1500 if (yystate == YYFINAL) 1501 YYACCEPT; 1502 1503 goto yybackup; 1504 1505 1506 /*-----------. 1507 | yybackup. | 1508 `-----------*/ 1509 yybackup: 1510 /* Do appropriate processing given the current state. Read a 1511 lookahead token if we need one and don't already have one. */ 1512 1513 /* First try to decide what to do without reference to lookahead token. */ 1514 yyn = yypact[yystate]; 1515 if (yypact_value_is_default (yyn)) 1516 goto yydefault; 1517 1518 /* Not known => get a lookahead token if don't already have one. */ 1519 1520 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1521 if (yychar == YYEMPTY) 1522 { 1523 YYDPRINTF ((stderr, "Reading a token\n")); 1524 yychar = yylex (); 1525 } 1526 1527 if (yychar <= YYEOF) 1528 { 1529 yychar = YYEOF; 1530 yytoken = YYSYMBOL_YYEOF; 1531 YYDPRINTF ((stderr, "Now at end of input.\n")); 1532 } 1533 else if (yychar == YYerror) 1534 { 1535 /* The scanner already issued an error message, process directly 1536 to error recovery. But do not keep the error token as 1537 lookahead, it is too special and may lead us to an endless 1538 loop in error recovery. */ 1539 yychar = YYUNDEF; 1540 yytoken = YYSYMBOL_YYerror; 1541 goto yyerrlab1; 1542 } 1543 else 1544 { 1545 yytoken = YYTRANSLATE (yychar); 1546 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1547 } 1548 1549 /* If the proper action on seeing token YYTOKEN is to reduce or to 1550 detect an error, take that action. */ 1551 yyn += yytoken; 1552 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1553 goto yydefault; 1554 yyn = yytable[yyn]; 1555 if (yyn <= 0) 1556 { 1557 if (yytable_value_is_error (yyn)) 1558 goto yyerrlab; 1559 yyn = -yyn; 1560 goto yyreduce; 1561 } 1562 1563 /* Count tokens shifted since error; after three, turn off error 1564 status. */ 1565 if (yyerrstatus) 1566 yyerrstatus--; 1567 1568 /* Shift the lookahead token. */ 1569 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1570 yystate = yyn; 1571 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1572 *++yyvsp = yylval; 1573 YY_IGNORE_MAYBE_UNINITIALIZED_END 1574 1575 /* Discard the shifted token. */ 1576 yychar = YYEMPTY; 1577 goto yynewstate; 1578 1579 1580 /*-----------------------------------------------------------. 1581 | yydefault -- do the default action for the current state. | 1582 `-----------------------------------------------------------*/ 1583 yydefault: 1584 yyn = yydefact[yystate]; 1585 if (yyn == 0) 1586 goto yyerrlab; 1587 goto yyreduce; 1588 1589 1590 /*-----------------------------. 1591 | yyreduce -- do a reduction. | 1592 `-----------------------------*/ 1593 yyreduce: 1594 /* yyn is the number of a rule to reduce with. */ 1595 yylen = yyr2[yyn]; 1596 1597 /* If YYLEN is nonzero, implement the default value of the action: 1598 '$$ = $1'. 1599 1600 Otherwise, the following line sets YYVAL to garbage. 1601 This behavior is undocumented and Bison 1602 users should not rely upon it. Assigning to YYVAL 1603 unconditionally makes the parser a bit smaller, and it avoids a 1604 GCC warning that YYVAL may be used uninitialized. */ 1605 yyval = yyvsp[1-yylen]; 1606 1607 1608 YY_REDUCE_PRINT (yyn); 1609 switch (yyn) 1610 { 1611 case 15: /* $@1: %empty */ 1612 #line 249 "configparser.y" 1613 { 1614 struct ip_address_option *ip = cfg_parser->opt->ip_addresses; 1615 1616 if(ip == NULL) { 1617 cfg_parser->opt->ip_addresses = (yyvsp[0].ip); 1618 } else { 1619 while(ip->next) { ip = ip->next; } 1620 ip->next = (yyvsp[0].ip); 1621 } 1622 1623 cfg_parser->ip = (yyvsp[0].ip); 1624 } 1625 #line 1626 "configparser.c" 1626 break; 1627 1628 case 16: /* server_option: VAR_IP_ADDRESS ip_address $@1 socket_options */ 1629 #line 262 "configparser.y" 1630 { 1631 cfg_parser->ip = NULL; 1632 } 1633 #line 1634 "configparser.c" 1634 break; 1635 1636 case 17: /* server_option: VAR_SERVER_COUNT number */ 1637 #line 266 "configparser.y" 1638 { 1639 if ((yyvsp[0].llng) > 0) { 1640 cfg_parser->opt->server_count = (int)(yyvsp[0].llng); 1641 } else { 1642 yyerror("expected a number greater than zero"); 1643 } 1644 } 1645 #line 1646 "configparser.c" 1646 break; 1647 1648 case 18: /* server_option: VAR_IP_TRANSPARENT boolean */ 1649 #line 274 "configparser.y" 1650 { cfg_parser->opt->ip_transparent = (yyvsp[0].bln); } 1651 #line 1652 "configparser.c" 1652 break; 1653 1654 case 19: /* server_option: VAR_IP_FREEBIND boolean */ 1655 #line 276 "configparser.y" 1656 { cfg_parser->opt->ip_freebind = (yyvsp[0].bln); } 1657 #line 1658 "configparser.c" 1658 break; 1659 1660 case 20: /* server_option: VAR_SEND_BUFFER_SIZE number */ 1661 #line 278 "configparser.y" 1662 { cfg_parser->opt->send_buffer_size = (int)(yyvsp[0].llng); } 1663 #line 1664 "configparser.c" 1664 break; 1665 1666 case 21: /* server_option: VAR_RECEIVE_BUFFER_SIZE number */ 1667 #line 280 "configparser.y" 1668 { cfg_parser->opt->receive_buffer_size = (int)(yyvsp[0].llng); } 1669 #line 1670 "configparser.c" 1670 break; 1671 1672 case 22: /* server_option: VAR_DEBUG_MODE boolean */ 1673 #line 282 "configparser.y" 1674 { cfg_parser->opt->debug_mode = (yyvsp[0].bln); } 1675 #line 1676 "configparser.c" 1676 break; 1677 1678 case 23: /* server_option: VAR_USE_SYSTEMD boolean */ 1679 #line 284 "configparser.y" 1680 { /* ignored, obsolete */ } 1681 #line 1682 "configparser.c" 1682 break; 1683 1684 case 24: /* server_option: VAR_HIDE_VERSION boolean */ 1685 #line 286 "configparser.y" 1686 { cfg_parser->opt->hide_version = (yyvsp[0].bln); } 1687 #line 1688 "configparser.c" 1688 break; 1689 1690 case 25: /* server_option: VAR_HIDE_IDENTITY boolean */ 1691 #line 288 "configparser.y" 1692 { cfg_parser->opt->hide_identity = (yyvsp[0].bln); } 1693 #line 1694 "configparser.c" 1694 break; 1695 1696 case 26: /* server_option: VAR_DROP_UPDATES boolean */ 1697 #line 290 "configparser.y" 1698 { cfg_parser->opt->drop_updates = (yyvsp[0].bln); } 1699 #line 1700 "configparser.c" 1700 break; 1701 1702 case 27: /* server_option: VAR_IP4_ONLY boolean */ 1703 #line 292 "configparser.y" 1704 { if((yyvsp[0].bln)) { cfg_parser->opt->do_ip4 = 1; cfg_parser->opt->do_ip6 = 0; } } 1705 #line 1706 "configparser.c" 1706 break; 1707 1708 case 28: /* server_option: VAR_IP6_ONLY boolean */ 1709 #line 294 "configparser.y" 1710 { if((yyvsp[0].bln)) { cfg_parser->opt->do_ip4 = 0; cfg_parser->opt->do_ip6 = 1; } } 1711 #line 1712 "configparser.c" 1712 break; 1713 1714 case 29: /* server_option: VAR_DO_IP4 boolean */ 1715 #line 296 "configparser.y" 1716 { cfg_parser->opt->do_ip4 = (yyvsp[0].bln); } 1717 #line 1718 "configparser.c" 1718 break; 1719 1720 case 30: /* server_option: VAR_DO_IP6 boolean */ 1721 #line 298 "configparser.y" 1722 { cfg_parser->opt->do_ip6 = (yyvsp[0].bln); } 1723 #line 1724 "configparser.c" 1724 break; 1725 1726 case 31: /* server_option: VAR_DATABASE STRING */ 1727 #line 300 "configparser.y" 1728 { /* ignored, obsolete */ } 1729 #line 1730 "configparser.c" 1730 break; 1731 1732 case 32: /* server_option: VAR_IDENTITY STRING */ 1733 #line 302 "configparser.y" 1734 { cfg_parser->opt->identity = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1735 #line 1736 "configparser.c" 1736 break; 1737 1738 case 33: /* server_option: VAR_VERSION STRING */ 1739 #line 304 "configparser.y" 1740 { cfg_parser->opt->version = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1741 #line 1742 "configparser.c" 1742 break; 1743 1744 case 34: /* server_option: VAR_NSID STRING */ 1745 #line 306 "configparser.y" 1746 { 1747 unsigned char* nsid = 0; 1748 size_t nsid_len = strlen((yyvsp[0].str)); 1749 1750 if (strncasecmp((yyvsp[0].str), "ascii_", 6) == 0) { 1751 nsid_len -= 6; /* discard "ascii_" */ 1752 if(nsid_len < 65535) { 1753 cfg_parser->opt->nsid = region_alloc(cfg_parser->opt->region, nsid_len*2+1); 1754 hex_ntop((uint8_t*)(yyvsp[0].str)+6, nsid_len, (char*)cfg_parser->opt->nsid, nsid_len*2+1); 1755 } else { 1756 yyerror("NSID too long"); 1757 } 1758 } else if (nsid_len % 2 != 0) { 1759 yyerror("the NSID must be a hex string of an even length."); 1760 } else { 1761 nsid_len = nsid_len / 2; 1762 if(nsid_len < 65535) { 1763 nsid = xalloc(nsid_len); 1764 if (hex_pton((yyvsp[0].str), nsid, nsid_len) == -1) { 1765 yyerror("hex string cannot be parsed in NSID."); 1766 } else { 1767 cfg_parser->opt->nsid = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 1768 } 1769 free(nsid); 1770 } else { 1771 yyerror("NSID too long"); 1772 } 1773 } 1774 } 1775 #line 1776 "configparser.c" 1776 break; 1777 1778 case 35: /* server_option: VAR_LOGFILE STRING */ 1779 #line 336 "configparser.y" 1780 { cfg_parser->opt->logfile = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1781 #line 1782 "configparser.c" 1782 break; 1783 1784 case 36: /* server_option: VAR_LOG_ONLY_SYSLOG boolean */ 1785 #line 338 "configparser.y" 1786 { cfg_parser->opt->log_only_syslog = (yyvsp[0].bln); } 1787 #line 1788 "configparser.c" 1788 break; 1789 1790 case 37: /* server_option: VAR_TCP_COUNT number */ 1791 #line 340 "configparser.y" 1792 { 1793 if ((yyvsp[0].llng) > 0) { 1794 cfg_parser->opt->tcp_count = (int)(yyvsp[0].llng); 1795 } else { 1796 yyerror("expected a number greater than zero"); 1797 } 1798 } 1799 #line 1800 "configparser.c" 1800 break; 1801 1802 case 38: /* server_option: VAR_TCP_REJECT_OVERFLOW boolean */ 1803 #line 348 "configparser.y" 1804 { cfg_parser->opt->tcp_reject_overflow = (yyvsp[0].bln); } 1805 #line 1806 "configparser.c" 1806 break; 1807 1808 case 39: /* server_option: VAR_TCP_QUERY_COUNT number */ 1809 #line 350 "configparser.y" 1810 { cfg_parser->opt->tcp_query_count = (int)(yyvsp[0].llng); } 1811 #line 1812 "configparser.c" 1812 break; 1813 1814 case 40: /* server_option: VAR_TCP_TIMEOUT number */ 1815 #line 352 "configparser.y" 1816 { cfg_parser->opt->tcp_timeout = (int)(yyvsp[0].llng); } 1817 #line 1818 "configparser.c" 1818 break; 1819 1820 case 41: /* server_option: VAR_TCP_MSS number */ 1821 #line 354 "configparser.y" 1822 { cfg_parser->opt->tcp_mss = (int)(yyvsp[0].llng); } 1823 #line 1824 "configparser.c" 1824 break; 1825 1826 case 42: /* server_option: VAR_OUTGOING_TCP_MSS number */ 1827 #line 356 "configparser.y" 1828 { cfg_parser->opt->outgoing_tcp_mss = (int)(yyvsp[0].llng); } 1829 #line 1830 "configparser.c" 1830 break; 1831 1832 case 43: /* server_option: VAR_IPV4_EDNS_SIZE number */ 1833 #line 358 "configparser.y" 1834 { cfg_parser->opt->ipv4_edns_size = (size_t)(yyvsp[0].llng); } 1835 #line 1836 "configparser.c" 1836 break; 1837 1838 case 44: /* server_option: VAR_IPV6_EDNS_SIZE number */ 1839 #line 360 "configparser.y" 1840 { cfg_parser->opt->ipv6_edns_size = (size_t)(yyvsp[0].llng); } 1841 #line 1842 "configparser.c" 1842 break; 1843 1844 case 45: /* server_option: VAR_PIDFILE STRING */ 1845 #line 362 "configparser.y" 1846 { cfg_parser->opt->pidfile = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1847 #line 1848 "configparser.c" 1848 break; 1849 1850 case 46: /* server_option: VAR_PORT number */ 1851 #line 364 "configparser.y" 1852 { 1853 /* port number, stored as a string */ 1854 char buf[16]; 1855 (void)snprintf(buf, sizeof(buf), "%lld", (yyvsp[0].llng)); 1856 cfg_parser->opt->port = region_strdup(cfg_parser->opt->region, buf); 1857 } 1858 #line 1859 "configparser.c" 1859 break; 1860 1861 case 47: /* server_option: VAR_REUSEPORT boolean */ 1862 #line 371 "configparser.y" 1863 { cfg_parser->opt->reuseport = (yyvsp[0].bln); } 1864 #line 1865 "configparser.c" 1865 break; 1866 1867 case 48: /* server_option: VAR_STATISTICS number */ 1868 #line 373 "configparser.y" 1869 { cfg_parser->opt->statistics = (int)(yyvsp[0].llng); } 1870 #line 1871 "configparser.c" 1871 break; 1872 1873 case 49: /* server_option: VAR_CHROOT STRING */ 1874 #line 375 "configparser.y" 1875 { cfg_parser->opt->chroot = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1876 #line 1877 "configparser.c" 1877 break; 1878 1879 case 50: /* server_option: VAR_USERNAME STRING */ 1880 #line 377 "configparser.y" 1881 { cfg_parser->opt->username = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1882 #line 1883 "configparser.c" 1883 break; 1884 1885 case 51: /* server_option: VAR_ZONESDIR STRING */ 1886 #line 379 "configparser.y" 1887 { cfg_parser->opt->zonesdir = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1888 #line 1889 "configparser.c" 1889 break; 1890 1891 case 52: /* server_option: VAR_ZONELISTFILE STRING */ 1892 #line 381 "configparser.y" 1893 { cfg_parser->opt->zonelistfile = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1894 #line 1895 "configparser.c" 1895 break; 1896 1897 case 53: /* server_option: VAR_DIFFFILE STRING */ 1898 #line 383 "configparser.y" 1899 { /* ignored, obsolete */ } 1900 #line 1901 "configparser.c" 1901 break; 1902 1903 case 54: /* server_option: VAR_XFRDFILE STRING */ 1904 #line 385 "configparser.y" 1905 { cfg_parser->opt->xfrdfile = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1906 #line 1907 "configparser.c" 1907 break; 1908 1909 case 55: /* server_option: VAR_XFRDIR STRING */ 1910 #line 387 "configparser.y" 1911 { cfg_parser->opt->xfrdir = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 1912 #line 1913 "configparser.c" 1913 break; 1914 1915 case 56: /* server_option: VAR_XFRD_RELOAD_TIMEOUT number */ 1916 #line 389 "configparser.y" 1917 { cfg_parser->opt->xfrd_reload_timeout = (int)(yyvsp[0].llng); } 1918 #line 1919 "configparser.c" 1919 break; 1920 1921 case 57: /* server_option: VAR_VERBOSITY number */ 1922 #line 391 "configparser.y" 1923 { cfg_parser->opt->verbosity = (int)(yyvsp[0].llng); } 1924 #line 1925 "configparser.c" 1925 break; 1926 1927 case 58: /* server_option: VAR_RRL_SIZE number */ 1928 #line 393 "configparser.y" 1929 { 1930 #ifdef RATELIMIT 1931 if ((yyvsp[0].llng) > 0) { 1932 cfg_parser->opt->rrl_size = (size_t)(yyvsp[0].llng); 1933 } else { 1934 yyerror("expected a number greater than zero"); 1935 } 1936 #endif 1937 } 1938 #line 1939 "configparser.c" 1939 break; 1940 1941 case 59: /* server_option: VAR_RRL_RATELIMIT number */ 1942 #line 403 "configparser.y" 1943 { 1944 #ifdef RATELIMIT 1945 cfg_parser->opt->rrl_ratelimit = (size_t)(yyvsp[0].llng); 1946 #endif 1947 } 1948 #line 1949 "configparser.c" 1949 break; 1950 1951 case 60: /* server_option: VAR_RRL_SLIP number */ 1952 #line 409 "configparser.y" 1953 { 1954 #ifdef RATELIMIT 1955 cfg_parser->opt->rrl_slip = (size_t)(yyvsp[0].llng); 1956 #endif 1957 } 1958 #line 1959 "configparser.c" 1959 break; 1960 1961 case 61: /* server_option: VAR_RRL_IPV4_PREFIX_LENGTH number */ 1962 #line 415 "configparser.y" 1963 { 1964 #ifdef RATELIMIT 1965 if ((yyvsp[0].llng) > 32) { 1966 yyerror("invalid IPv4 prefix length"); 1967 } else { 1968 cfg_parser->opt->rrl_ipv4_prefix_length = (size_t)(yyvsp[0].llng); 1969 } 1970 #endif 1971 } 1972 #line 1973 "configparser.c" 1973 break; 1974 1975 case 62: /* server_option: VAR_RRL_IPV6_PREFIX_LENGTH number */ 1976 #line 425 "configparser.y" 1977 { 1978 #ifdef RATELIMIT 1979 if ((yyvsp[0].llng) > 64) { 1980 yyerror("invalid IPv6 prefix length"); 1981 } else { 1982 cfg_parser->opt->rrl_ipv6_prefix_length = (size_t)(yyvsp[0].llng); 1983 } 1984 #endif 1985 } 1986 #line 1987 "configparser.c" 1987 break; 1988 1989 case 63: /* server_option: VAR_RRL_WHITELIST_RATELIMIT number */ 1990 #line 435 "configparser.y" 1991 { 1992 #ifdef RATELIMIT 1993 cfg_parser->opt->rrl_whitelist_ratelimit = (size_t)(yyvsp[0].llng); 1994 #endif 1995 } 1996 #line 1997 "configparser.c" 1997 break; 1998 1999 case 64: /* server_option: VAR_ZONEFILES_CHECK boolean */ 2000 #line 441 "configparser.y" 2001 { cfg_parser->opt->zonefiles_check = (yyvsp[0].bln); } 2002 #line 2003 "configparser.c" 2003 break; 2004 2005 case 65: /* server_option: VAR_ZONEFILES_WRITE number */ 2006 #line 443 "configparser.y" 2007 { cfg_parser->opt->zonefiles_write = (int)(yyvsp[0].llng); } 2008 #line 2009 "configparser.c" 2009 break; 2010 2011 case 66: /* server_option: VAR_LOG_TIME_ASCII boolean */ 2012 #line 445 "configparser.y" 2013 { 2014 cfg_parser->opt->log_time_ascii = (yyvsp[0].bln); 2015 log_time_asc = cfg_parser->opt->log_time_ascii; 2016 } 2017 #line 2018 "configparser.c" 2018 break; 2019 2020 case 67: /* server_option: VAR_ROUND_ROBIN boolean */ 2021 #line 450 "configparser.y" 2022 { 2023 cfg_parser->opt->round_robin = (yyvsp[0].bln); 2024 round_robin = cfg_parser->opt->round_robin; 2025 } 2026 #line 2027 "configparser.c" 2027 break; 2028 2029 case 68: /* server_option: VAR_MINIMAL_RESPONSES boolean */ 2030 #line 455 "configparser.y" 2031 { 2032 cfg_parser->opt->minimal_responses = (yyvsp[0].bln); 2033 minimal_responses = cfg_parser->opt->minimal_responses; 2034 } 2035 #line 2036 "configparser.c" 2036 break; 2037 2038 case 69: /* server_option: VAR_CONFINE_TO_ZONE boolean */ 2039 #line 460 "configparser.y" 2040 { cfg_parser->opt->confine_to_zone = (yyvsp[0].bln); } 2041 #line 2042 "configparser.c" 2042 break; 2043 2044 case 70: /* server_option: VAR_REFUSE_ANY boolean */ 2045 #line 462 "configparser.y" 2046 { cfg_parser->opt->refuse_any = (yyvsp[0].bln); } 2047 #line 2048 "configparser.c" 2048 break; 2049 2050 case 71: /* server_option: VAR_TLS_SERVICE_KEY STRING */ 2051 #line 464 "configparser.y" 2052 { cfg_parser->opt->tls_service_key = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2053 #line 2054 "configparser.c" 2054 break; 2055 2056 case 72: /* server_option: VAR_TLS_SERVICE_OCSP STRING */ 2057 #line 466 "configparser.y" 2058 { cfg_parser->opt->tls_service_ocsp = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2059 #line 2060 "configparser.c" 2060 break; 2061 2062 case 73: /* server_option: VAR_TLS_SERVICE_PEM STRING */ 2063 #line 468 "configparser.y" 2064 { cfg_parser->opt->tls_service_pem = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2065 #line 2066 "configparser.c" 2066 break; 2067 2068 case 74: /* server_option: VAR_TLS_PORT number */ 2069 #line 470 "configparser.y" 2070 { 2071 /* port number, stored as string */ 2072 char buf[16]; 2073 (void)snprintf(buf, sizeof(buf), "%lld", (yyvsp[0].llng)); 2074 cfg_parser->opt->tls_port = region_strdup(cfg_parser->opt->region, buf); 2075 } 2076 #line 2077 "configparser.c" 2077 break; 2078 2079 case 75: /* server_option: VAR_TLS_CERT_BUNDLE STRING */ 2080 #line 477 "configparser.y" 2081 { cfg_parser->opt->tls_cert_bundle = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2082 #line 2083 "configparser.c" 2083 break; 2084 2085 case 76: /* server_option: VAR_PROXY_PROTOCOL_PORT number */ 2086 #line 479 "configparser.y" 2087 { 2088 struct proxy_protocol_port_list* elem = region_alloc_zero( 2089 cfg_parser->opt->region, sizeof(*elem)); 2090 elem->port = (yyvsp[0].llng); 2091 elem->next = cfg_parser->opt->proxy_protocol_port; 2092 cfg_parser->opt->proxy_protocol_port = elem; 2093 } 2094 #line 2095 "configparser.c" 2095 break; 2096 2097 case 77: /* server_option: VAR_ANSWER_COOKIE boolean */ 2098 #line 487 "configparser.y" 2099 { cfg_parser->opt->answer_cookie = (yyvsp[0].bln); } 2100 #line 2101 "configparser.c" 2101 break; 2102 2103 case 78: /* server_option: VAR_COOKIE_SECRET STRING */ 2104 #line 489 "configparser.y" 2105 { cfg_parser->opt->cookie_secret = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2106 #line 2107 "configparser.c" 2107 break; 2108 2109 case 79: /* server_option: VAR_COOKIE_SECRET_FILE STRING */ 2110 #line 491 "configparser.y" 2111 { cfg_parser->opt->cookie_secret_file = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2112 #line 2113 "configparser.c" 2113 break; 2114 2115 case 80: /* server_option: VAR_XFRD_TCP_MAX number */ 2116 #line 493 "configparser.y" 2117 { cfg_parser->opt->xfrd_tcp_max = (int)(yyvsp[0].llng); } 2118 #line 2119 "configparser.c" 2119 break; 2120 2121 case 81: /* server_option: VAR_XFRD_TCP_PIPELINE number */ 2122 #line 495 "configparser.y" 2123 { cfg_parser->opt->xfrd_tcp_pipeline = (int)(yyvsp[0].llng); } 2124 #line 2125 "configparser.c" 2125 break; 2126 2127 case 82: /* server_option: VAR_CPU_AFFINITY cpus */ 2128 #line 497 "configparser.y" 2129 { 2130 cfg_parser->opt->cpu_affinity = (yyvsp[0].cpu); 2131 } 2132 #line 2133 "configparser.c" 2133 break; 2134 2135 case 83: /* server_option: service_cpu_affinity number */ 2136 #line 501 "configparser.y" 2137 { 2138 if((yyvsp[0].llng) < 0) { 2139 yyerror("expected a non-negative number"); 2140 YYABORT; 2141 } else { 2142 struct cpu_map_option *opt, *tail; 2143 2144 opt = cfg_parser->opt->service_cpu_affinity; 2145 while(opt && opt->service != (yyvsp[-1].llng)) { opt = opt->next; } 2146 2147 if(opt) { 2148 opt->cpu = (yyvsp[0].llng); 2149 } else { 2150 opt = region_alloc_zero(cfg_parser->opt->region, sizeof(*opt)); 2151 opt->service = (int)(yyvsp[-1].llng); 2152 opt->cpu = (int)(yyvsp[0].llng); 2153 2154 tail = cfg_parser->opt->service_cpu_affinity; 2155 if(tail) { 2156 while(tail->next) { tail = tail->next; } 2157 tail->next = opt; 2158 } else { 2159 cfg_parser->opt->service_cpu_affinity = opt; 2160 } 2161 } 2162 } 2163 } 2164 #line 2165 "configparser.c" 2165 break; 2166 2167 case 86: /* socket_option: VAR_SERVERS STRING */ 2168 #line 535 "configparser.y" 2169 { 2170 char *tok, *ptr, *str; 2171 struct range_option *servers = NULL; 2172 long long first, last; 2173 2174 /* user may specify "0 1", "0" "1", 0 1 or a combination thereof */ 2175 for(str = (yyvsp[0].str); (tok = strtok_r(str, " \t", &ptr)); str = NULL) { 2176 struct range_option *opt = 2177 region_alloc(cfg_parser->opt->region, sizeof(*opt)); 2178 first = last = 0; 2179 if(!parse_range(tok, &first, &last)) { 2180 yyerror("invalid server range '%s'", tok); 2181 YYABORT; 2182 } 2183 assert(first >= 0); 2184 assert(last >= 0); 2185 opt->next = NULL; 2186 opt->first = (int)first; 2187 opt->last = (int)last; 2188 if(servers) { 2189 servers = servers->next = opt; 2190 } else { 2191 servers = cfg_parser->ip->servers = opt; 2192 } 2193 } 2194 } 2195 #line 2196 "configparser.c" 2196 break; 2197 2198 case 87: /* socket_option: VAR_BINDTODEVICE boolean */ 2199 #line 562 "configparser.y" 2200 { cfg_parser->ip->dev = (yyvsp[0].bln); } 2201 #line 2202 "configparser.c" 2202 break; 2203 2204 case 88: /* socket_option: VAR_SETFIB number */ 2205 #line 564 "configparser.y" 2206 { cfg_parser->ip->fib = (yyvsp[0].llng); } 2207 #line 2208 "configparser.c" 2208 break; 2209 2210 case 89: /* cpus: %empty */ 2211 #line 568 "configparser.y" 2212 { (yyval.cpu) = NULL; } 2213 #line 2214 "configparser.c" 2214 break; 2215 2216 case 90: /* cpus: cpus STRING */ 2217 #line 570 "configparser.y" 2218 { 2219 char *tok, *ptr, *str; 2220 struct cpu_option *tail; 2221 long long cpu; 2222 2223 str = (yyvsp[0].str); 2224 (yyval.cpu) = tail = (yyvsp[-1].cpu); 2225 if(tail) { 2226 while(tail->next) { tail = tail->next; } 2227 } 2228 2229 /* Users may specify "0 1", "0" "1", 0 1 or a combination thereof. */ 2230 for(str = (yyvsp[0].str); (tok = strtok_r(str, " \t", &ptr)); str = NULL) { 2231 struct cpu_option *opt = 2232 region_alloc_zero(cfg_parser->opt->region, sizeof(*opt)); 2233 cpu = 0; 2234 if(!parse_number(tok, &cpu) || cpu < 0) { 2235 yyerror("expected a positive number"); 2236 YYABORT; 2237 } 2238 assert(cpu >=0); 2239 opt->cpu = (int)cpu; 2240 if(tail) { 2241 tail->next = opt; 2242 tail = opt; 2243 } else { 2244 (yyval.cpu) = tail = opt; 2245 } 2246 } 2247 } 2248 #line 2249 "configparser.c" 2249 break; 2250 2251 case 91: /* service_cpu_affinity: VAR_XFRD_CPU_AFFINITY */ 2252 #line 604 "configparser.y" 2253 { (yyval.llng) = -1; } 2254 #line 2255 "configparser.c" 2255 break; 2256 2257 case 92: /* service_cpu_affinity: VAR_SERVER_CPU_AFFINITY */ 2258 #line 606 "configparser.y" 2259 { 2260 if((yyvsp[0].llng) <= 0) { 2261 yyerror("invalid server identifier"); 2262 YYABORT; 2263 } 2264 (yyval.llng) = (yyvsp[0].llng); 2265 } 2266 #line 2267 "configparser.c" 2267 break; 2268 2269 case 96: /* dnstap_option: VAR_DNSTAP_ENABLE boolean */ 2270 #line 623 "configparser.y" 2271 { cfg_parser->opt->dnstap_enable = (yyvsp[0].bln); } 2272 #line 2273 "configparser.c" 2273 break; 2274 2275 case 97: /* dnstap_option: VAR_DNSTAP_SOCKET_PATH STRING */ 2276 #line 625 "configparser.y" 2277 { cfg_parser->opt->dnstap_socket_path = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2278 #line 2279 "configparser.c" 2279 break; 2280 2281 case 98: /* dnstap_option: VAR_DNSTAP_IP STRING */ 2282 #line 627 "configparser.y" 2283 { cfg_parser->opt->dnstap_ip = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2284 #line 2285 "configparser.c" 2285 break; 2286 2287 case 99: /* dnstap_option: VAR_DNSTAP_TLS boolean */ 2288 #line 629 "configparser.y" 2289 { cfg_parser->opt->dnstap_tls = (yyvsp[0].bln); } 2290 #line 2291 "configparser.c" 2291 break; 2292 2293 case 100: /* dnstap_option: VAR_DNSTAP_TLS_SERVER_NAME STRING */ 2294 #line 631 "configparser.y" 2295 { cfg_parser->opt->dnstap_tls_server_name = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2296 #line 2297 "configparser.c" 2297 break; 2298 2299 case 101: /* dnstap_option: VAR_DNSTAP_TLS_CERT_BUNDLE STRING */ 2300 #line 633 "configparser.y" 2301 { cfg_parser->opt->dnstap_tls_cert_bundle = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2302 #line 2303 "configparser.c" 2303 break; 2304 2305 case 102: /* dnstap_option: VAR_DNSTAP_TLS_CLIENT_KEY_FILE STRING */ 2306 #line 635 "configparser.y" 2307 { cfg_parser->opt->dnstap_tls_client_key_file = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2308 #line 2309 "configparser.c" 2309 break; 2310 2311 case 103: /* dnstap_option: VAR_DNSTAP_TLS_CLIENT_CERT_FILE STRING */ 2312 #line 637 "configparser.y" 2313 { cfg_parser->opt->dnstap_tls_client_cert_file = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2314 #line 2315 "configparser.c" 2315 break; 2316 2317 case 104: /* dnstap_option: VAR_DNSTAP_SEND_IDENTITY boolean */ 2318 #line 639 "configparser.y" 2319 { cfg_parser->opt->dnstap_send_identity = (yyvsp[0].bln); } 2320 #line 2321 "configparser.c" 2321 break; 2322 2323 case 105: /* dnstap_option: VAR_DNSTAP_SEND_VERSION boolean */ 2324 #line 641 "configparser.y" 2325 { cfg_parser->opt->dnstap_send_version = (yyvsp[0].bln); } 2326 #line 2327 "configparser.c" 2327 break; 2328 2329 case 106: /* dnstap_option: VAR_DNSTAP_IDENTITY STRING */ 2330 #line 643 "configparser.y" 2331 { cfg_parser->opt->dnstap_identity = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2332 #line 2333 "configparser.c" 2333 break; 2334 2335 case 107: /* dnstap_option: VAR_DNSTAP_VERSION STRING */ 2336 #line 645 "configparser.y" 2337 { cfg_parser->opt->dnstap_version = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2338 #line 2339 "configparser.c" 2339 break; 2340 2341 case 108: /* dnstap_option: VAR_DNSTAP_LOG_AUTH_QUERY_MESSAGES boolean */ 2342 #line 647 "configparser.y" 2343 { cfg_parser->opt->dnstap_log_auth_query_messages = (yyvsp[0].bln); } 2344 #line 2345 "configparser.c" 2345 break; 2346 2347 case 109: /* dnstap_option: VAR_DNSTAP_LOG_AUTH_RESPONSE_MESSAGES boolean */ 2348 #line 649 "configparser.y" 2349 { cfg_parser->opt->dnstap_log_auth_response_messages = (yyvsp[0].bln); } 2350 #line 2351 "configparser.c" 2351 break; 2352 2353 case 113: /* remote_control_option: VAR_CONTROL_ENABLE boolean */ 2354 #line 660 "configparser.y" 2355 { cfg_parser->opt->control_enable = (yyvsp[0].bln); } 2356 #line 2357 "configparser.c" 2357 break; 2358 2359 case 114: /* remote_control_option: VAR_CONTROL_INTERFACE ip_address */ 2360 #line 662 "configparser.y" 2361 { 2362 struct ip_address_option *ip = cfg_parser->opt->control_interface; 2363 if(ip == NULL) { 2364 cfg_parser->opt->control_interface = (yyvsp[0].ip); 2365 } else { 2366 while(ip->next != NULL) { ip = ip->next; } 2367 ip->next = (yyvsp[0].ip); 2368 } 2369 } 2370 #line 2371 "configparser.c" 2371 break; 2372 2373 case 115: /* remote_control_option: VAR_CONTROL_PORT number */ 2374 #line 672 "configparser.y" 2375 { 2376 if((yyvsp[0].llng) == 0) { 2377 yyerror("control port number expected"); 2378 } else { 2379 cfg_parser->opt->control_port = (int)(yyvsp[0].llng); 2380 } 2381 } 2382 #line 2383 "configparser.c" 2383 break; 2384 2385 case 116: /* remote_control_option: VAR_SERVER_KEY_FILE STRING */ 2386 #line 680 "configparser.y" 2387 { cfg_parser->opt->server_key_file = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2388 #line 2389 "configparser.c" 2389 break; 2390 2391 case 117: /* remote_control_option: VAR_SERVER_CERT_FILE STRING */ 2392 #line 682 "configparser.y" 2393 { cfg_parser->opt->server_cert_file = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2394 #line 2395 "configparser.c" 2395 break; 2396 2397 case 118: /* remote_control_option: VAR_CONTROL_KEY_FILE STRING */ 2398 #line 684 "configparser.y" 2399 { cfg_parser->opt->control_key_file = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2400 #line 2401 "configparser.c" 2401 break; 2402 2403 case 119: /* remote_control_option: VAR_CONTROL_CERT_FILE STRING */ 2404 #line 686 "configparser.y" 2405 { cfg_parser->opt->control_cert_file = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2406 #line 2407 "configparser.c" 2407 break; 2408 2409 case 120: /* $@2: %empty */ 2410 #line 691 "configparser.y" 2411 { 2412 tls_auth_options_type *tls_auth = tls_auth_options_create(cfg_parser->opt->region); 2413 assert(cfg_parser->tls_auth == NULL); 2414 cfg_parser->tls_auth = tls_auth; 2415 } 2416 #line 2417 "configparser.c" 2417 break; 2418 2419 case 121: /* tls_auth: VAR_TLS_AUTH $@2 tls_auth_block */ 2420 #line 697 "configparser.y" 2421 { 2422 struct tls_auth_options *tls_auth = cfg_parser->tls_auth; 2423 if(tls_auth->name == NULL) { 2424 yyerror("tls-auth has no name"); 2425 } else if(tls_auth->auth_domain_name == NULL) { 2426 yyerror("tls-auth %s has no auth-domain-name", tls_auth->name); 2427 } else if(tls_auth_options_find(cfg_parser->opt, tls_auth->name)) { 2428 yyerror("duplicate tls-auth %s", tls_auth->name); 2429 } else { 2430 tls_auth_options_insert(cfg_parser->opt, tls_auth); 2431 cfg_parser->tls_auth = NULL; 2432 } 2433 } 2434 #line 2435 "configparser.c" 2435 break; 2436 2437 case 124: /* tls_auth_option: VAR_NAME STRING */ 2438 #line 716 "configparser.y" 2439 { 2440 dname_type *dname; 2441 dname = (dname_type *)dname_parse(cfg_parser->opt->region, (yyvsp[0].str)); 2442 cfg_parser->tls_auth->name = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2443 if(dname == NULL) { 2444 yyerror("bad tls-auth name %s", (yyvsp[0].str)); 2445 } else { 2446 region_recycle(cfg_parser->opt->region, dname, dname_total_size(dname)); 2447 } 2448 } 2449 #line 2450 "configparser.c" 2450 break; 2451 2452 case 125: /* tls_auth_option: VAR_TLS_AUTH_DOMAIN_NAME STRING */ 2453 #line 727 "configparser.y" 2454 { 2455 cfg_parser->tls_auth->auth_domain_name = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2456 } 2457 #line 2458 "configparser.c" 2458 break; 2459 2460 case 126: /* tls_auth_option: VAR_TLS_AUTH_CLIENT_CERT STRING */ 2461 #line 731 "configparser.y" 2462 { 2463 cfg_parser->tls_auth->client_cert = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2464 } 2465 #line 2466 "configparser.c" 2466 break; 2467 2468 case 127: /* tls_auth_option: VAR_TLS_AUTH_CLIENT_KEY STRING */ 2469 #line 735 "configparser.y" 2470 { 2471 cfg_parser->tls_auth->client_key = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2472 } 2473 #line 2474 "configparser.c" 2474 break; 2475 2476 case 128: /* tls_auth_option: VAR_TLS_AUTH_CLIENT_KEY_PW STRING */ 2477 #line 739 "configparser.y" 2478 { 2479 cfg_parser->tls_auth->client_key_pw = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2480 } 2481 #line 2482 "configparser.c" 2482 break; 2483 2484 case 129: /* $@3: %empty */ 2485 #line 746 "configparser.y" 2486 { 2487 key_options_type *key = key_options_create(cfg_parser->opt->region); 2488 key->algorithm = region_strdup(cfg_parser->opt->region, "sha256"); 2489 assert(cfg_parser->key == NULL); 2490 cfg_parser->key = key; 2491 } 2492 #line 2493 "configparser.c" 2493 break; 2494 2495 case 130: /* key: VAR_KEY $@3 key_block */ 2496 #line 753 "configparser.y" 2497 { 2498 struct key_options *key = cfg_parser->key; 2499 if(key->name == NULL) { 2500 yyerror("tsig key has no name"); 2501 } else if(key->algorithm == NULL) { 2502 yyerror("tsig key %s has no algorithm", key->name); 2503 } else if(key->secret == NULL) { 2504 yyerror("tsig key %s has no secret blob", key->name); 2505 } else if(key_options_find(cfg_parser->opt, key->name)) { 2506 yyerror("duplicate tsig key %s", key->name); 2507 } else { 2508 key_options_insert(cfg_parser->opt, key); 2509 cfg_parser->key = NULL; 2510 } 2511 } 2512 #line 2513 "configparser.c" 2513 break; 2514 2515 case 133: /* key_option: VAR_NAME STRING */ 2516 #line 774 "configparser.y" 2517 { 2518 dname_type *dname; 2519 2520 dname = (dname_type *)dname_parse(cfg_parser->opt->region, (yyvsp[0].str)); 2521 cfg_parser->key->name = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2522 if(dname == NULL) { 2523 yyerror("bad tsig key name %s", (yyvsp[0].str)); 2524 } else { 2525 region_recycle(cfg_parser->opt->region, dname, dname_total_size(dname)); 2526 } 2527 } 2528 #line 2529 "configparser.c" 2529 break; 2530 2531 case 134: /* key_option: VAR_ALGORITHM STRING */ 2532 #line 786 "configparser.y" 2533 { 2534 if(tsig_get_algorithm_by_name((yyvsp[0].str)) == NULL) { 2535 yyerror("bad tsig key algorithm %s", (yyvsp[0].str)); 2536 } else { 2537 cfg_parser->key->algorithm = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2538 } 2539 } 2540 #line 2541 "configparser.c" 2541 break; 2542 2543 case 135: /* key_option: VAR_SECRET STRING */ 2544 #line 794 "configparser.y" 2545 { 2546 uint8_t data[16384]; 2547 int size; 2548 2549 cfg_parser->key->secret = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2550 size = b64_pton((yyvsp[0].str), data, sizeof(data)); 2551 if(size == -1) { 2552 yyerror("cannot base64 decode tsig secret %s", 2553 cfg_parser->key->name? 2554 cfg_parser->key->name:""); 2555 } else if(size != 0) { 2556 memset(data, 0xdd, size); /* wipe secret */ 2557 } 2558 } 2559 #line 2560 "configparser.c" 2560 break; 2561 2562 case 136: /* $@4: %empty */ 2563 #line 812 "configparser.y" 2564 { 2565 assert(cfg_parser->pattern == NULL); 2566 assert(cfg_parser->zone == NULL); 2567 cfg_parser->zone = zone_options_create(cfg_parser->opt->region); 2568 cfg_parser->zone->part_of_config = 1; 2569 cfg_parser->zone->pattern = cfg_parser->pattern = 2570 pattern_options_create(cfg_parser->opt->region); 2571 cfg_parser->zone->pattern->implicit = 1; 2572 } 2573 #line 2574 "configparser.c" 2574 break; 2575 2576 case 137: /* zone: VAR_ZONE $@4 zone_block */ 2577 #line 822 "configparser.y" 2578 { 2579 assert(cfg_parser->zone != NULL); 2580 if(cfg_parser->zone->name == NULL) { 2581 yyerror("zone has no name"); 2582 } else if(!nsd_options_insert_zone(cfg_parser->opt, cfg_parser->zone)) { 2583 yyerror("duplicate zone %s", cfg_parser->zone->name); 2584 } else if(!nsd_options_insert_pattern(cfg_parser->opt, cfg_parser->zone->pattern)) { 2585 yyerror("duplicate pattern %s", cfg_parser->zone->pattern->pname); 2586 } 2587 cfg_parser->pattern = NULL; 2588 cfg_parser->zone = NULL; 2589 } 2590 #line 2591 "configparser.c" 2591 break; 2592 2593 case 140: /* zone_option: VAR_NAME STRING */ 2594 #line 840 "configparser.y" 2595 { 2596 const char *marker = PATTERN_IMPLICIT_MARKER; 2597 char *pname = region_alloc(cfg_parser->opt->region, strlen((yyvsp[0].str)) + strlen(marker) + 1); 2598 memmove(pname, marker, strlen(marker)); 2599 memmove(pname + strlen(marker), (yyvsp[0].str), strlen((yyvsp[0].str)) + 1); 2600 cfg_parser->zone->pattern->pname = pname; 2601 cfg_parser->zone->name = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2602 if(pattern_options_find(cfg_parser->opt, pname)) { 2603 yyerror("zone %s cannot be created because implicit pattern %s " 2604 "already exists", (yyvsp[0].str), pname); 2605 } 2606 } 2607 #line 2608 "configparser.c" 2608 break; 2609 2610 case 142: /* $@5: %empty */ 2611 #line 856 "configparser.y" 2612 { 2613 assert(cfg_parser->pattern == NULL); 2614 cfg_parser->pattern = pattern_options_create(cfg_parser->opt->region); 2615 } 2616 #line 2617 "configparser.c" 2617 break; 2618 2619 case 143: /* pattern: VAR_PATTERN $@5 pattern_block */ 2620 #line 861 "configparser.y" 2621 { 2622 pattern_options_type *pattern = cfg_parser->pattern; 2623 if(pattern->pname == NULL) { 2624 yyerror("pattern has no name"); 2625 } else if(!nsd_options_insert_pattern(cfg_parser->opt, pattern)) { 2626 yyerror("duplicate pattern %s", pattern->pname); 2627 } 2628 cfg_parser->pattern = NULL; 2629 } 2630 #line 2631 "configparser.c" 2631 break; 2632 2633 case 146: /* pattern_option: VAR_NAME STRING */ 2634 #line 876 "configparser.y" 2635 { 2636 if(strchr((yyvsp[0].str), ' ')) { 2637 yyerror("space is not allowed in pattern name: '%s'", (yyvsp[0].str)); 2638 } 2639 cfg_parser->pattern->pname = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 2640 } 2641 #line 2642 "configparser.c" 2642 break; 2643 2644 case 148: /* pattern_or_zone_option: VAR_RRL_WHITELIST STRING */ 2645 #line 886 "configparser.y" 2646 { 2647 #ifdef RATELIMIT 2648 cfg_parser->pattern->rrl_whitelist |= rrlstr2type((yyvsp[0].str)); 2649 #endif 2650 } 2651 #line 2652 "configparser.c" 2652 break; 2653 2654 case 149: /* pattern_or_zone_option: VAR_ZONEFILE STRING */ 2655 #line 892 "configparser.y" 2656 { cfg_parser->pattern->zonefile = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2657 #line 2658 "configparser.c" 2658 break; 2659 2660 case 150: /* pattern_or_zone_option: VAR_ZONESTATS STRING */ 2661 #line 894 "configparser.y" 2662 { cfg_parser->pattern->zonestats = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); } 2663 #line 2664 "configparser.c" 2664 break; 2665 2666 case 151: /* pattern_or_zone_option: VAR_SIZE_LIMIT_XFR number */ 2667 #line 896 "configparser.y" 2668 { 2669 if((yyvsp[0].llng) > 0) { 2670 cfg_parser->pattern->size_limit_xfr = (int)(yyvsp[0].llng); 2671 } else { 2672 yyerror("expected a number greater than zero"); 2673 } 2674 } 2675 #line 2676 "configparser.c" 2676 break; 2677 2678 case 152: /* pattern_or_zone_option: VAR_MULTI_MASTER_CHECK boolean */ 2679 #line 904 "configparser.y" 2680 { cfg_parser->pattern->multi_master_check = (int)(yyvsp[0].bln); } 2681 #line 2682 "configparser.c" 2682 break; 2683 2684 case 153: /* pattern_or_zone_option: VAR_INCLUDE_PATTERN STRING */ 2685 #line 906 "configparser.y" 2686 { config_apply_pattern(cfg_parser->pattern, (yyvsp[0].str)); } 2687 #line 2688 "configparser.c" 2688 break; 2689 2690 case 154: /* $@6: %empty */ 2691 #line 908 "configparser.y" 2692 { 2693 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[-1].str), (yyvsp[0].str)); 2694 if(acl->blocked) 2695 yyerror("blocked address used for request-xfr"); 2696 if(acl->rangetype != acl_range_single) 2697 yyerror("address range used for request-xfr"); 2698 append_acl(&cfg_parser->pattern->request_xfr, acl); 2699 } 2700 #line 2701 "configparser.c" 2701 break; 2702 2703 case 155: /* pattern_or_zone_option: VAR_REQUEST_XFR STRING STRING $@6 tlsauth_option */ 2704 #line 917 "configparser.y" 2705 { } 2706 #line 2707 "configparser.c" 2707 break; 2708 2709 case 156: /* $@7: %empty */ 2710 #line 919 "configparser.y" 2711 { 2712 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[-1].str), (yyvsp[0].str)); 2713 acl->use_axfr_only = 1; 2714 if(acl->blocked) 2715 yyerror("blocked address used for request-xfr"); 2716 if(acl->rangetype != acl_range_single) 2717 yyerror("address range used for request-xfr"); 2718 append_acl(&cfg_parser->pattern->request_xfr, acl); 2719 } 2720 #line 2721 "configparser.c" 2721 break; 2722 2723 case 157: /* pattern_or_zone_option: VAR_REQUEST_XFR VAR_AXFR STRING STRING $@7 tlsauth_option */ 2724 #line 929 "configparser.y" 2725 { } 2726 #line 2727 "configparser.c" 2727 break; 2728 2729 case 158: /* pattern_or_zone_option: VAR_REQUEST_XFR VAR_UDP STRING STRING */ 2730 #line 931 "configparser.y" 2731 { 2732 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[-1].str), (yyvsp[0].str)); 2733 acl->allow_udp = 1; 2734 if(acl->blocked) 2735 yyerror("blocked address used for request-xfr"); 2736 if(acl->rangetype != acl_range_single) 2737 yyerror("address range used for request-xfr"); 2738 append_acl(&cfg_parser->pattern->request_xfr, acl); 2739 } 2740 #line 2741 "configparser.c" 2741 break; 2742 2743 case 159: /* pattern_or_zone_option: VAR_ALLOW_NOTIFY STRING STRING */ 2744 #line 941 "configparser.y" 2745 { 2746 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[-1].str), (yyvsp[0].str)); 2747 append_acl(&cfg_parser->pattern->allow_notify, acl); 2748 } 2749 #line 2750 "configparser.c" 2750 break; 2751 2752 case 160: /* pattern_or_zone_option: VAR_NOTIFY STRING STRING */ 2753 #line 946 "configparser.y" 2754 { 2755 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[-1].str), (yyvsp[0].str)); 2756 if(acl->blocked) 2757 yyerror("blocked address used for notify"); 2758 if(acl->rangetype != acl_range_single) 2759 yyerror("address range used for notify"); 2760 append_acl(&cfg_parser->pattern->notify, acl); 2761 } 2762 #line 2763 "configparser.c" 2763 break; 2764 2765 case 161: /* pattern_or_zone_option: VAR_PROVIDE_XFR STRING STRING */ 2766 #line 955 "configparser.y" 2767 { 2768 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[-1].str), (yyvsp[0].str)); 2769 append_acl(&cfg_parser->pattern->provide_xfr, acl); 2770 } 2771 #line 2772 "configparser.c" 2772 break; 2773 2774 case 162: /* pattern_or_zone_option: VAR_ALLOW_QUERY STRING STRING */ 2775 #line 960 "configparser.y" 2776 { 2777 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[-1].str), (yyvsp[0].str)); 2778 append_acl(&cfg_parser->pattern->allow_query, acl); 2779 } 2780 #line 2781 "configparser.c" 2781 break; 2782 2783 case 163: /* pattern_or_zone_option: VAR_OUTGOING_INTERFACE STRING */ 2784 #line 965 "configparser.y" 2785 { 2786 acl_options_type *acl = parse_acl_info(cfg_parser->opt->region, (yyvsp[0].str), "NOKEY"); 2787 append_acl(&cfg_parser->pattern->outgoing_interface, acl); 2788 } 2789 #line 2790 "configparser.c" 2790 break; 2791 2792 case 164: /* pattern_or_zone_option: VAR_ALLOW_AXFR_FALLBACK boolean */ 2793 #line 970 "configparser.y" 2794 { 2795 cfg_parser->pattern->allow_axfr_fallback = (yyvsp[0].bln); 2796 cfg_parser->pattern->allow_axfr_fallback_is_default = 0; 2797 } 2798 #line 2799 "configparser.c" 2799 break; 2800 2801 case 165: /* pattern_or_zone_option: VAR_NOTIFY_RETRY number */ 2802 #line 975 "configparser.y" 2803 { 2804 cfg_parser->pattern->notify_retry = (yyvsp[0].llng); 2805 cfg_parser->pattern->notify_retry_is_default = 0; 2806 } 2807 #line 2808 "configparser.c" 2808 break; 2809 2810 case 166: /* pattern_or_zone_option: VAR_MAX_REFRESH_TIME number */ 2811 #line 980 "configparser.y" 2812 { 2813 cfg_parser->pattern->max_refresh_time = (yyvsp[0].llng); 2814 cfg_parser->pattern->max_refresh_time_is_default = 0; 2815 } 2816 #line 2817 "configparser.c" 2817 break; 2818 2819 case 167: /* pattern_or_zone_option: VAR_MIN_REFRESH_TIME number */ 2820 #line 985 "configparser.y" 2821 { 2822 cfg_parser->pattern->min_refresh_time = (yyvsp[0].llng); 2823 cfg_parser->pattern->min_refresh_time_is_default = 0; 2824 } 2825 #line 2826 "configparser.c" 2826 break; 2827 2828 case 168: /* pattern_or_zone_option: VAR_MAX_RETRY_TIME number */ 2829 #line 990 "configparser.y" 2830 { 2831 cfg_parser->pattern->max_retry_time = (yyvsp[0].llng); 2832 cfg_parser->pattern->max_retry_time_is_default = 0; 2833 } 2834 #line 2835 "configparser.c" 2835 break; 2836 2837 case 169: /* pattern_or_zone_option: VAR_MIN_RETRY_TIME number */ 2838 #line 995 "configparser.y" 2839 { 2840 cfg_parser->pattern->min_retry_time = (yyvsp[0].llng); 2841 cfg_parser->pattern->min_retry_time_is_default = 0; 2842 } 2843 #line 2844 "configparser.c" 2844 break; 2845 2846 case 170: /* pattern_or_zone_option: VAR_MIN_EXPIRE_TIME STRING */ 2847 #line 1000 "configparser.y" 2848 { 2849 long long num; 2850 uint8_t expr; 2851 2852 if (!parse_expire_expr((yyvsp[0].str), &num, &expr)) { 2853 yyerror("expected an expire time in seconds or \"refresh+retry+1\""); 2854 YYABORT; /* trigger a parser error */ 2855 } 2856 cfg_parser->pattern->min_expire_time = num; 2857 cfg_parser->pattern->min_expire_time_expr = expr; 2858 } 2859 #line 2860 "configparser.c" 2860 break; 2861 2862 case 171: /* pattern_or_zone_option: VAR_STORE_IXFR boolean */ 2863 #line 1012 "configparser.y" 2864 { 2865 cfg_parser->pattern->store_ixfr = (yyvsp[0].bln); 2866 cfg_parser->pattern->store_ixfr_is_default = 0; 2867 } 2868 #line 2869 "configparser.c" 2869 break; 2870 2871 case 172: /* pattern_or_zone_option: VAR_IXFR_SIZE number */ 2872 #line 1017 "configparser.y" 2873 { 2874 cfg_parser->pattern->ixfr_size = (yyvsp[0].llng); 2875 cfg_parser->pattern->ixfr_size_is_default = 0; 2876 } 2877 #line 2878 "configparser.c" 2878 break; 2879 2880 case 173: /* pattern_or_zone_option: VAR_IXFR_NUMBER number */ 2881 #line 1022 "configparser.y" 2882 { 2883 cfg_parser->pattern->ixfr_number = (yyvsp[0].llng); 2884 cfg_parser->pattern->ixfr_number_is_default = 0; 2885 } 2886 #line 2887 "configparser.c" 2887 break; 2888 2889 case 174: /* pattern_or_zone_option: VAR_CREATE_IXFR boolean */ 2890 #line 1027 "configparser.y" 2891 { 2892 cfg_parser->pattern->create_ixfr = (yyvsp[0].bln); 2893 cfg_parser->pattern->create_ixfr_is_default = 0; 2894 } 2895 #line 2896 "configparser.c" 2896 break; 2897 2898 case 175: /* pattern_or_zone_option: VAR_VERIFY_ZONE boolean */ 2899 #line 1032 "configparser.y" 2900 { cfg_parser->pattern->verify_zone = (yyvsp[0].bln); } 2901 #line 2902 "configparser.c" 2902 break; 2903 2904 case 176: /* pattern_or_zone_option: VAR_VERIFIER command */ 2905 #line 1034 "configparser.y" 2906 { cfg_parser->pattern->verifier = (yyvsp[0].strv); } 2907 #line 2908 "configparser.c" 2908 break; 2909 2910 case 177: /* pattern_or_zone_option: VAR_VERIFIER_FEED_ZONE boolean */ 2911 #line 1036 "configparser.y" 2912 { cfg_parser->pattern->verifier_feed_zone = (yyvsp[0].bln); } 2913 #line 2914 "configparser.c" 2914 break; 2915 2916 case 178: /* pattern_or_zone_option: VAR_VERIFIER_TIMEOUT number */ 2917 #line 1038 "configparser.y" 2918 { cfg_parser->pattern->verifier_timeout = (yyvsp[0].llng); } 2919 #line 2920 "configparser.c" 2920 break; 2921 2922 case 182: /* verify_option: VAR_ENABLE boolean */ 2923 #line 1048 "configparser.y" 2924 { cfg_parser->opt->verify_enable = (yyvsp[0].bln); } 2925 #line 2926 "configparser.c" 2926 break; 2927 2928 case 183: /* verify_option: VAR_IP_ADDRESS ip_address */ 2929 #line 1050 "configparser.y" 2930 { 2931 struct ip_address_option *ip = cfg_parser->opt->verify_ip_addresses; 2932 if(!ip) { 2933 cfg_parser->opt->verify_ip_addresses = (yyvsp[0].ip); 2934 } else { 2935 while(ip->next) { ip = ip->next; } 2936 ip->next = (yyvsp[0].ip); 2937 } 2938 } 2939 #line 2940 "configparser.c" 2940 break; 2941 2942 case 184: /* verify_option: VAR_PORT number */ 2943 #line 1060 "configparser.y" 2944 { 2945 /* port number, stored as a string */ 2946 char buf[16]; 2947 (void)snprintf(buf, sizeof(buf), "%lld", (yyvsp[0].llng)); 2948 cfg_parser->opt->verify_port = region_strdup(cfg_parser->opt->region, buf); 2949 } 2950 #line 2951 "configparser.c" 2951 break; 2952 2953 case 185: /* verify_option: VAR_VERIFY_ZONES boolean */ 2954 #line 1067 "configparser.y" 2955 { cfg_parser->opt->verify_zones = (yyvsp[0].bln); } 2956 #line 2957 "configparser.c" 2957 break; 2958 2959 case 186: /* verify_option: VAR_VERIFIER command */ 2960 #line 1069 "configparser.y" 2961 { cfg_parser->opt->verifier = (yyvsp[0].strv); } 2962 #line 2963 "configparser.c" 2963 break; 2964 2965 case 187: /* verify_option: VAR_VERIFIER_COUNT number */ 2966 #line 1071 "configparser.y" 2967 { cfg_parser->opt->verifier_count = (int)(yyvsp[0].llng); } 2968 #line 2969 "configparser.c" 2969 break; 2970 2971 case 188: /* verify_option: VAR_VERIFIER_TIMEOUT number */ 2972 #line 1073 "configparser.y" 2973 { cfg_parser->opt->verifier_timeout = (int)(yyvsp[0].llng); } 2974 #line 2975 "configparser.c" 2975 break; 2976 2977 case 189: /* verify_option: VAR_VERIFIER_FEED_ZONE boolean */ 2978 #line 1075 "configparser.y" 2979 { cfg_parser->opt->verifier_feed_zone = (yyvsp[0].bln); } 2980 #line 2981 "configparser.c" 2981 break; 2982 2983 case 190: /* command: STRING arguments */ 2984 #line 1079 "configparser.y" 2985 { 2986 char **argv; 2987 size_t argc = 1; 2988 for(struct component *i = (yyvsp[0].comp); i; i = i->next) { 2989 argc++; 2990 } 2991 argv = region_alloc_zero( 2992 cfg_parser->opt->region, (argc + 1) * sizeof(char *)); 2993 argc = 0; 2994 argv[argc++] = (yyvsp[-1].str); 2995 for(struct component *j, *i = (yyvsp[0].comp); i; i = j) { 2996 j = i->next; 2997 argv[argc++] = i->str; 2998 region_recycle(cfg_parser->opt->region, i, sizeof(*i)); 2999 } 3000 (yyval.strv) = argv; 3001 } 3002 #line 3003 "configparser.c" 3003 break; 3004 3005 case 191: /* arguments: %empty */ 3006 #line 1098 "configparser.y" 3007 { (yyval.comp) = NULL; } 3008 #line 3009 "configparser.c" 3009 break; 3010 3011 case 192: /* arguments: arguments STRING */ 3012 #line 1100 "configparser.y" 3013 { 3014 struct component *comp = region_alloc_zero( 3015 cfg_parser->opt->region, sizeof(*comp)); 3016 comp->str = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 3017 if((yyvsp[-1].comp)) { 3018 struct component *tail = (yyvsp[-1].comp); 3019 while(tail->next) { 3020 tail = tail->next; 3021 } 3022 tail->next = comp; 3023 (yyval.comp) = (yyvsp[-1].comp); 3024 } else { 3025 (yyval.comp) = comp; 3026 } 3027 } 3028 #line 3029 "configparser.c" 3029 break; 3030 3031 case 193: /* ip_address: STRING */ 3032 #line 1118 "configparser.y" 3033 { 3034 struct ip_address_option *ip = region_alloc_zero( 3035 cfg_parser->opt->region, sizeof(*ip)); 3036 ip->address = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 3037 ip->fib = -1; 3038 (yyval.ip) = ip; 3039 } 3040 #line 3041 "configparser.c" 3041 break; 3042 3043 case 194: /* number: STRING */ 3044 #line 1128 "configparser.y" 3045 { 3046 if(!parse_number((yyvsp[0].str), &(yyval.llng))) { 3047 yyerror("expected a number"); 3048 YYABORT; /* trigger a parser error */ 3049 } 3050 } 3051 #line 3052 "configparser.c" 3052 break; 3053 3054 case 195: /* boolean: STRING */ 3055 #line 1137 "configparser.y" 3056 { 3057 if(!parse_boolean((yyvsp[0].str), &(yyval.bln))) { 3058 yyerror("expected yes or no"); 3059 YYABORT; /* trigger a parser error */ 3060 } 3061 } 3062 #line 3063 "configparser.c" 3063 break; 3064 3065 case 197: /* tlsauth_option: STRING */ 3066 #line 1146 "configparser.y" 3067 { char *tls_auth_name = region_strdup(cfg_parser->opt->region, (yyvsp[0].str)); 3068 add_to_last_acl(&cfg_parser->pattern->request_xfr, tls_auth_name);} 3069 #line 3070 "configparser.c" 3070 break; 3071 3072 3073 #line 3074 "configparser.c" 3074 3075 default: break; 3076 } 3077 /* User semantic actions sometimes alter yychar, and that requires 3078 that yytoken be updated with the new translation. We take the 3079 approach of translating immediately before every use of yytoken. 3080 One alternative is translating here after every semantic action, 3081 but that translation would be missed if the semantic action invokes 3082 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 3083 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 3084 incorrect destructor might then be invoked immediately. In the 3085 case of YYERROR or YYBACKUP, subsequent parser actions might lead 3086 to an incorrect destructor call or verbose syntax error message 3087 before the lookahead is translated. */ 3088 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 3089 3090 YYPOPSTACK (yylen); 3091 yylen = 0; 3092 3093 *++yyvsp = yyval; 3094 3095 /* Now 'shift' the result of the reduction. Determine what state 3096 that goes to, based on the state we popped back to and the rule 3097 number reduced by. */ 3098 { 3099 const int yylhs = yyr1[yyn] - YYNTOKENS; 3100 const int yyi = yypgoto[yylhs] + *yyssp; 3101 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp 3102 ? yytable[yyi] 3103 : yydefgoto[yylhs]); 3104 } 3105 3106 goto yynewstate; 3107 3108 3109 /*--------------------------------------. 3110 | yyerrlab -- here on detecting error. | 3111 `--------------------------------------*/ 3112 yyerrlab: 3113 /* Make sure we have latest lookahead translation. See comments at 3114 user semantic actions for why this is necessary. */ 3115 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); 3116 /* If not already recovering from an error, report this error. */ 3117 if (!yyerrstatus) 3118 { 3119 ++yynerrs; 3120 yyerror (YY_("syntax error")); 3121 } 3122 3123 if (yyerrstatus == 3) 3124 { 3125 /* If just tried and failed to reuse lookahead token after an 3126 error, discard it. */ 3127 3128 if (yychar <= YYEOF) 3129 { 3130 /* Return failure if at end of input. */ 3131 if (yychar == YYEOF) 3132 YYABORT; 3133 } 3134 else 3135 { 3136 yydestruct ("Error: discarding", 3137 yytoken, &yylval); 3138 yychar = YYEMPTY; 3139 } 3140 } 3141 3142 /* Else will try to reuse lookahead token after shifting the error 3143 token. */ 3144 goto yyerrlab1; 3145 3146 3147 /*---------------------------------------------------. 3148 | yyerrorlab -- error raised explicitly by YYERROR. | 3149 `---------------------------------------------------*/ 3150 yyerrorlab: 3151 /* Pacify compilers when the user code never invokes YYERROR and the 3152 label yyerrorlab therefore never appears in user code. */ 3153 if (0) 3154 YYERROR; 3155 3156 /* Do not reclaim the symbols of the rule whose action triggered 3157 this YYERROR. */ 3158 YYPOPSTACK (yylen); 3159 yylen = 0; 3160 YY_STACK_PRINT (yyss, yyssp); 3161 yystate = *yyssp; 3162 goto yyerrlab1; 3163 3164 3165 /*-------------------------------------------------------------. 3166 | yyerrlab1 -- common code for both syntax error and YYERROR. | 3167 `-------------------------------------------------------------*/ 3168 yyerrlab1: 3169 yyerrstatus = 3; /* Each real token shifted decrements this. */ 3170 3171 /* Pop stack until we find a state that shifts the error token. */ 3172 for (;;) 3173 { 3174 yyn = yypact[yystate]; 3175 if (!yypact_value_is_default (yyn)) 3176 { 3177 yyn += YYSYMBOL_YYerror; 3178 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) 3179 { 3180 yyn = yytable[yyn]; 3181 if (0 < yyn) 3182 break; 3183 } 3184 } 3185 3186 /* Pop the current state because it cannot handle the error token. */ 3187 if (yyssp == yyss) 3188 YYABORT; 3189 3190 3191 yydestruct ("Error: popping", 3192 YY_ACCESSING_SYMBOL (yystate), yyvsp); 3193 YYPOPSTACK (1); 3194 yystate = *yyssp; 3195 YY_STACK_PRINT (yyss, yyssp); 3196 } 3197 3198 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3199 *++yyvsp = yylval; 3200 YY_IGNORE_MAYBE_UNINITIALIZED_END 3201 3202 3203 /* Shift the error token. */ 3204 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 3205 3206 yystate = yyn; 3207 goto yynewstate; 3208 3209 3210 /*-------------------------------------. 3211 | yyacceptlab -- YYACCEPT comes here. | 3212 `-------------------------------------*/ 3213 yyacceptlab: 3214 yyresult = 0; 3215 goto yyreturn; 3216 3217 3218 /*-----------------------------------. 3219 | yyabortlab -- YYABORT comes here. | 3220 `-----------------------------------*/ 3221 yyabortlab: 3222 yyresult = 1; 3223 goto yyreturn; 3224 3225 3226 #if !defined yyoverflow 3227 /*-------------------------------------------------. 3228 | yyexhaustedlab -- memory exhaustion comes here. | 3229 `-------------------------------------------------*/ 3230 yyexhaustedlab: 3231 yyerror (YY_("memory exhausted")); 3232 yyresult = 2; 3233 goto yyreturn; 3234 #endif 3235 3236 3237 /*-------------------------------------------------------. 3238 | yyreturn -- parsing is finished, clean up and return. | 3239 `-------------------------------------------------------*/ 3240 yyreturn: 3241 if (yychar != YYEMPTY) 3242 { 3243 /* Make sure we have latest lookahead translation. See comments at 3244 user semantic actions for why this is necessary. */ 3245 yytoken = YYTRANSLATE (yychar); 3246 yydestruct ("Cleanup: discarding lookahead", 3247 yytoken, &yylval); 3248 } 3249 /* Do not reclaim the symbols of the rule whose action triggered 3250 this YYABORT or YYACCEPT. */ 3251 YYPOPSTACK (yylen); 3252 YY_STACK_PRINT (yyss, yyssp); 3253 while (yyssp != yyss) 3254 { 3255 yydestruct ("Cleanup: popping", 3256 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); 3257 YYPOPSTACK (1); 3258 } 3259 #ifndef yyoverflow 3260 if (yyss != yyssa) 3261 YYSTACK_FREE (yyss); 3262 #endif 3263 3264 return yyresult; 3265 } 3266 3267 #line 1149 "configparser.y" 3268 3269 3270 static void 3271 append_acl(struct acl_options **list, struct acl_options *acl) 3272 { 3273 assert(list != NULL); 3274 3275 if(*list == NULL) { 3276 *list = acl; 3277 } else { 3278 struct acl_options *tail = *list; 3279 while(tail->next != NULL) 3280 tail = tail->next; 3281 tail->next = acl; 3282 } 3283 } 3284 3285 static void 3286 add_to_last_acl(struct acl_options **list, char *tls_auth_name) 3287 { 3288 struct acl_options *tail = *list; 3289 assert(list != NULL); 3290 assert(*list != NULL); 3291 while(tail->next != NULL) 3292 tail = tail->next; 3293 tail->tls_auth_name = tls_auth_name; 3294 } 3295 3296 static int 3297 parse_boolean(const char *str, int *bln) 3298 { 3299 if(strcmp(str, "yes") == 0) { 3300 *bln = 1; 3301 } else if(strcmp(str, "no") == 0) { 3302 *bln = 0; 3303 } else { 3304 return 0; 3305 } 3306 3307 return 1; 3308 } 3309 3310 static int 3311 parse_expire_expr(const char *str, long long *num, uint8_t *expr) 3312 { 3313 if(parse_number(str, num)) { 3314 *expr = EXPIRE_TIME_HAS_VALUE; 3315 return 1; 3316 } 3317 if(strcmp(str, REFRESHPLUSRETRYPLUS1_STR) == 0) { 3318 *num = 0; 3319 *expr = REFRESHPLUSRETRYPLUS1; 3320 return 1; 3321 } 3322 return 0; 3323 } 3324 3325 static int 3326 parse_number(const char *str, long long *num) 3327 { 3328 /* ensure string consists entirely of digits */ 3329 size_t pos = 0; 3330 while(str[pos] >= '0' && str[pos] <= '9') { 3331 pos++; 3332 } 3333 3334 if(pos != 0 && str[pos] == '\0') { 3335 *num = strtoll(str, NULL, 10); 3336 return 1; 3337 } 3338 3339 return 0; 3340 } 3341 3342 static int 3343 parse_range(const char *str, long long *low, long long *high) 3344 { 3345 const char *ptr = str; 3346 long long num[2]; 3347 3348 /* require range to begin with a number */ 3349 if(*ptr < '0' || *ptr > '9') { 3350 return 0; 3351 } 3352 3353 num[0] = strtoll(ptr, (char **)&ptr, 10); 3354 3355 /* require number to be followed by nothing at all or a dash */ 3356 if(*ptr == '\0') { 3357 *low = num[0]; 3358 *high = num[0]; 3359 return 1; 3360 } else if(*ptr != '-') { 3361 return 0; 3362 } 3363 3364 ++ptr; 3365 /* require dash to be followed by a number */ 3366 if(*ptr < '0' || *ptr > '9') { 3367 return 0; 3368 } 3369 3370 num[1] = strtoll(ptr, (char **)&ptr, 10); 3371 3372 /* require number to be followed by nothing at all */ 3373 if(*ptr == '\0') { 3374 if(num[0] < num[1]) { 3375 *low = num[0]; 3376 *high = num[1]; 3377 } else { 3378 *low = num[1]; 3379 *high = num[0]; 3380 } 3381 return 1; 3382 } 3383 3384 return 0; 3385 } 3386
Indexes created Sat Mar 21 00:23:06 UTC 2026