From: Wouter Wijngaards Date: Tue, 5 Aug 2014 07:57:52 +0000 (+0000) Subject: - dnstap support, with a patch from Farsight Security, written by X-Git-Tag: release-1.5.0rc1~54 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=8ccba42b1fcf1c04aaf5e7141491367e8ce45463;p=thirdparty%2Funbound.git - dnstap support, with a patch from Farsight Security, written by Robert Edmonds. The --enable-dnstap needs libfstrm and protobuf-c. It is BSD licensed (see dnstap/dnstap.c). Building with --enable-dnstap needs pkg-config with this patch. - Noted dnstap in doc/README and doc/CREDITS. git-svn-id: file:///svn/unbound/trunk@3206 be551aaa-1e26-0410-a405-d3ace91eadb9 --- diff --git a/Makefile.in b/Makefile.in index 091449db7..dec1a1d9a 100644 --- a/Makefile.in +++ b/Makefile.in @@ -21,6 +21,8 @@ EXEEXT=@EXEEXT@ configfile=@ub_conf_file@ CHECKLOCK_SRC=testcode/checklocks.c CHECKLOCK_OBJ=@CHECKLOCK_OBJ@ +DNSTAP_SRC=@DNSTAP_SRC@ +DNSTAP_OBJ=@DNSTAP_OBJ@ WITH_PYTHONMODULE=@WITH_PYTHONMODULE@ WITH_PYUNBOUND=@WITH_PYUNBOUND@ PYTHON_SITE_PKG=@PYTHON_SITE_PKG@ @@ -43,6 +45,7 @@ PYUNBOUND_TARGET=@PYUNBOUND_TARGET@ # K&R C compilers), but causes problems if $U is defined in the env). U= +PROTOC_C=@PROTOC_C@ SWIG=@SWIG@ YACC=@YACC@ LEX=@LEX@ @@ -106,7 +109,7 @@ util/winsock_event.c validator/autotrust.c validator/val_anchor.c \ validator/validator.c validator/val_kcache.c validator/val_kentry.c \ validator/val_neg.c validator/val_nsec3.c validator/val_nsec.c \ validator/val_secalgo.c validator/val_sigcrypt.c \ -validator/val_utils.c dns64/dns64.c $(CHECKLOCK_SRC) +validator/val_utils.c dns64/dns64.c $(CHECKLOCK_SRC) $(DNSTAP_SRC) COMMON_OBJ_WITHOUT_NETCALL=dns.lo infra.lo rrset.lo dname.lo msgencode.lo \ msgparse.lo msgreply.lo packed_rrset.lo iterator.lo iter_delegpt.lo \ iter_donotq.lo iter_fwd.lo iter_hints.lo iter_priv.lo iter_resptype.lo \ @@ -117,7 +120,7 @@ random.lo rbtree.lo regional.lo rtt.lo dnstree.lo lookup3.lo lruhash.lo \ slabhash.lo timehist.lo tube.lo winsock_event.lo autotrust.lo val_anchor.lo \ validator.lo val_kcache.lo val_kentry.lo val_neg.lo val_nsec3.lo val_nsec.lo \ val_secalgo.lo val_sigcrypt.lo val_utils.lo dns64.lo \ -$(PYTHONMOD_OBJ) $(CHECKLOCK_OBJ) +$(PYTHONMOD_OBJ) $(CHECKLOCK_OBJ) $(DNSTAP_OBJ) COMMON_OBJ=$(COMMON_OBJ_WITHOUT_NETCALL) netevent.lo listen_dnsport.lo \ outside_network.lo # set to $COMMON_OBJ or to "" if --enableallsymbols @@ -357,6 +360,18 @@ unbound-control-setup: smallapp/unbound-control-setup.sh cp smallapp/unbound-control-setup.sh $@ -chmod +x $@ +# dnstap +dnstap.lo dnstap.o: $(srcdir)/dnstap/dnstap.c config.h dnstap/dnstap_config.h \ + dnstap/dnstap.pb-c.c dnstap/dnstap.pb-c.h $(srcdir)/dnstap/dnstap.h \ + $(srcdir)/util/config_file.h $(srcdir)/util/log.h \ + $(srcdir)/util/netevent.h $(srcdir)/util/net_help.h + +dnstap/dnstap.pb-c.c dnstap/dnstap.pb-c.h: $(srcdir)/dnstap/dnstap.proto + @-if test ! -d dnstap; then $(INSTALL) -d dnstap; fi + $(PROTOC_C) --c_out=. $(srcdir)/dnstap/dnstap.proto + +dnstap.pb-c.lo dnstap.pb-c.o: dnstap/dnstap.pb-c.c dnstap/dnstap.pb-c.h + # Python Module pythonmod.lo pythonmod.o: $(srcdir)/pythonmod/pythonmod.c config.h \ pythonmod/interface.h \ diff --git a/config.h.in b/config.h.in index 08ba66596..5f8f8a992 100644 --- a/config.h.in +++ b/config.h.in @@ -19,6 +19,9 @@ /* Whether daemon is deprecated */ #undef DEPRECATED_DAEMON +/* default dnstap socket path */ +#undef DNSTAP_SOCKET_PATH + /* Define if you want to use debug lock checking (slow). */ #undef ENABLE_LOCK_CHECKS @@ -539,6 +542,9 @@ /* define this to enable debug checks. */ #undef UNBOUND_DEBUG +/* Define to 1 to enable dnstap support */ +#undef USE_DNSTAP + /* Define this to enable ECDSA support. */ #undef USE_ECDSA diff --git a/configure b/configure index 34fa6e005..792ce8929 100755 --- a/configure +++ b/configure @@ -636,6 +636,18 @@ INSTALLTARGET ALLTARGET SOURCEFILE SOURCEDETERMINE +DNSTAP_OBJ +DNSTAP_SRC +opt_dnstap_socket_path +ENABLE_DNSTAP +libprotobuf_c_LIBS +libprotobuf_c_CFLAGS +libfstrm_LIBS +libfstrm_CFLAGS +PKG_CONFIG_LIBDIR +PKG_CONFIG_PATH +PKG_CONFIG +PROTOC_C UBSYMS EXTRALINK COMMON_OBJ_ALL_SYMBOLS @@ -824,6 +836,8 @@ with_libexpat enable_static_exe enable_lock_checks enable_allsymbols +enable_dnstap +with_dnstap_socket_path with_libunbound_only ' ac_precious_vars='build_alias @@ -837,7 +851,14 @@ CPPFLAGS CPP YACC YFLAGS -PYTHON_VERSION' +PYTHON_VERSION +PKG_CONFIG +PKG_CONFIG_PATH +PKG_CONFIG_LIBDIR +libfstrm_CFLAGS +libfstrm_LIBS +libprotobuf_c_CFLAGS +libprotobuf_c_LIBS' # Initialize some variables set by options. @@ -1481,6 +1502,7 @@ Optional Features: --enable-allsymbols export all symbols from libunbound and link binaries to it, smaller install size but libunbound export table is polluted by internal symbols + --enable-dnstap Enable dnstap support (requires fstrm, protobuf-c) Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] @@ -1525,6 +1547,8 @@ Optional Packages: an explicit path). Slower, but allows use of large outgoing port ranges. --with-libexpat=path specify explicit path for libexpat. + --with-dnstap-socket-path=pathname + set default dnstap socket path --with-libunbound-only do not build daemon and tool programs Some influential environment variables: @@ -1546,6 +1570,19 @@ Some influential environment variables: The installed Python version to use, for example '2.3'. This string will be appended to the Python interpreter canonical name. + PKG_CONFIG path to pkg-config utility + PKG_CONFIG_PATH + directories to add to pkg-config's search path + PKG_CONFIG_LIBDIR + path overriding pkg-config's built-in search path + libfstrm_CFLAGS + C compiler flags for libfstrm, overriding pkg-config + libfstrm_LIBS + linker flags for libfstrm, overriding pkg-config + libprotobuf_c_CFLAGS + C compiler flags for libprotobuf_c, overriding pkg-config + libprotobuf_c_LIBS + linker flags for libprotobuf_c, overriding pkg-config Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. @@ -19861,6 +19898,405 @@ if test x_$enable_lock_checks = x_yes; then echo checklock_thrjoin >> clubsyms.def fi +# check for dnstap if requested + + + + + + + +if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. +set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_PKG_CONFIG+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $PKG_CONFIG in + [\\/]* | ?:[\\/]*) + ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +PKG_CONFIG=$ac_cv_path_PKG_CONFIG +if test -n "$PKG_CONFIG"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 +$as_echo "$PKG_CONFIG" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_path_PKG_CONFIG"; then + ac_pt_PKG_CONFIG=$PKG_CONFIG + # Extract the first word of "pkg-config", so it can be a program name with args. +set dummy pkg-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $ac_pt_PKG_CONFIG in + [\\/]* | ?:[\\/]*) + ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG +if test -n "$ac_pt_PKG_CONFIG"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 +$as_echo "$ac_pt_PKG_CONFIG" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_pt_PKG_CONFIG" = x; then + PKG_CONFIG="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + PKG_CONFIG=$ac_pt_PKG_CONFIG + fi +else + PKG_CONFIG="$ac_cv_path_PKG_CONFIG" +fi + +fi +if test -n "$PKG_CONFIG"; then + _pkg_min_version=0.9.0 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 +$as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; } + if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + PKG_CONFIG="" + fi +fi + + # Check whether --enable-dnstap was given. +if test "${enable_dnstap+set}" = set; then : + enableval=$enable_dnstap; opt_dnstap=$enableval +else + opt_dnstap=no +fi + + + +# Check whether --with-dnstap-socket-path was given. +if test "${with_dnstap_socket_path+set}" = set; then : + withval=$with_dnstap_socket_path; opt_dnstap_socket_path=$withval +else + opt_dnstap_socket_path="$UNBOUND_RUN_DIR/dnstap.sock" +fi + + + if test "x$opt_dnstap" != "xno"; then + # Extract the first word of "protoc-c", so it can be a program name with args. +set dummy protoc-c; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_PROTOC_C+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $PROTOC_C in + [\\/]* | ?:[\\/]*) + ac_cv_path_PROTOC_C="$PROTOC_C" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_path_PROTOC_C="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +PROTOC_C=$ac_cv_path_PROTOC_C +if test -n "$PROTOC_C"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROTOC_C" >&5 +$as_echo "$PROTOC_C" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test -z "$PROTOC_C"; then + as_fn_error $? "The protoc-c program was not found. Please install protobuf-c!" "$LINENO" 5 + fi + +pkg_failed=no +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libfstrm" >&5 +$as_echo_n "checking for libfstrm... " >&6; } + +if test -n "$libfstrm_CFLAGS"; then + pkg_cv_libfstrm_CFLAGS="$libfstrm_CFLAGS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libfstrm\""; } >&5 + ($PKG_CONFIG --exists --print-errors "libfstrm") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_libfstrm_CFLAGS=`$PKG_CONFIG --cflags "libfstrm" 2>/dev/null` + test "x$?" != "x0" && pkg_failed=yes +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi +if test -n "$libfstrm_LIBS"; then + pkg_cv_libfstrm_LIBS="$libfstrm_LIBS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libfstrm\""; } >&5 + ($PKG_CONFIG --exists --print-errors "libfstrm") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_libfstrm_LIBS=`$PKG_CONFIG --libs "libfstrm" 2>/dev/null` + test "x$?" != "x0" && pkg_failed=yes +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi + + + +if test $pkg_failed = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + +if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then + _pkg_short_errors_supported=yes +else + _pkg_short_errors_supported=no +fi + if test $_pkg_short_errors_supported = yes; then + libfstrm_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libfstrm" 2>&1` + else + libfstrm_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libfstrm" 2>&1` + fi + # Put the nasty error message in config.log where it belongs + echo "$libfstrm_PKG_ERRORS" >&5 + + as_fn_error $? "Package requirements (libfstrm) were not met: + +$libfstrm_PKG_ERRORS + +Consider adjusting the PKG_CONFIG_PATH environment variable if you +installed software in a non-standard prefix. + +Alternatively, you may set the environment variables libfstrm_CFLAGS +and libfstrm_LIBS to avoid the need to call pkg-config. +See the pkg-config man page for more details." "$LINENO" 5 +elif test $pkg_failed = untried; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it +is in your PATH or set the PKG_CONFIG environment variable to the full +path to pkg-config. + +Alternatively, you may set the environment variables libfstrm_CFLAGS +and libfstrm_LIBS to avoid the need to call pkg-config. +See the pkg-config man page for more details. + +To get pkg-config, see . +See \`config.log' for more details" "$LINENO" 5; } +else + libfstrm_CFLAGS=$pkg_cv_libfstrm_CFLAGS + libfstrm_LIBS=$pkg_cv_libfstrm_LIBS + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + +fi + +pkg_failed=no +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libprotobuf_c" >&5 +$as_echo_n "checking for libprotobuf_c... " >&6; } + +if test -n "$libprotobuf_c_CFLAGS"; then + pkg_cv_libprotobuf_c_CFLAGS="$libprotobuf_c_CFLAGS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libprotobuf-c\""; } >&5 + ($PKG_CONFIG --exists --print-errors "libprotobuf-c") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_libprotobuf_c_CFLAGS=`$PKG_CONFIG --cflags "libprotobuf-c" 2>/dev/null` + test "x$?" != "x0" && pkg_failed=yes +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi +if test -n "$libprotobuf_c_LIBS"; then + pkg_cv_libprotobuf_c_LIBS="$libprotobuf_c_LIBS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libprotobuf-c\""; } >&5 + ($PKG_CONFIG --exists --print-errors "libprotobuf-c") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_libprotobuf_c_LIBS=`$PKG_CONFIG --libs "libprotobuf-c" 2>/dev/null` + test "x$?" != "x0" && pkg_failed=yes +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi + + + +if test $pkg_failed = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + +if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then + _pkg_short_errors_supported=yes +else + _pkg_short_errors_supported=no +fi + if test $_pkg_short_errors_supported = yes; then + libprotobuf_c_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libprotobuf-c" 2>&1` + else + libprotobuf_c_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libprotobuf-c" 2>&1` + fi + # Put the nasty error message in config.log where it belongs + echo "$libprotobuf_c_PKG_ERRORS" >&5 + + as_fn_error $? "Package requirements (libprotobuf-c) were not met: + +$libprotobuf_c_PKG_ERRORS + +Consider adjusting the PKG_CONFIG_PATH environment variable if you +installed software in a non-standard prefix. + +Alternatively, you may set the environment variables libprotobuf_c_CFLAGS +and libprotobuf_c_LIBS to avoid the need to call pkg-config. +See the pkg-config man page for more details." "$LINENO" 5 +elif test $pkg_failed = untried; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it +is in your PATH or set the PKG_CONFIG environment variable to the full +path to pkg-config. + +Alternatively, you may set the environment variables libprotobuf_c_CFLAGS +and libprotobuf_c_LIBS to avoid the need to call pkg-config. +See the pkg-config man page for more details. + +To get pkg-config, see . +See \`config.log' for more details" "$LINENO" 5; } +else + libprotobuf_c_CFLAGS=$pkg_cv_libprotobuf_c_CFLAGS + libprotobuf_c_LIBS=$pkg_cv_libprotobuf_c_LIBS + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + +fi + DNSTAP_CFLAGS="$libfstrm_CFLAGS $libprotobuf_c_CFLAGS" + DNSTAP_LIBS="$libfstrm_LIBS $libprotobuf_c_LIBS" + + LIBS="$LIBS $DNSTAP_LIBS" + CFLAGS="$CFLAGS $DNSTAP_CFLAGS" + +$as_echo "#define USE_DNSTAP 1" >>confdefs.h + + ENABLE_DNSTAP=1 + + + + hdr_dnstap_socket_path="`echo $opt_dnstap_socket_path | sed -e 's/\\\\/\\\\\\\\/g'`" + + +cat >>confdefs.h <<_ACEOF +#define DNSTAP_SOCKET_PATH "$hdr_dnstap_socket_path" +_ACEOF + + + DNSTAP_SRC="dnstap/dnstap.c dnstap/dnstap.pb-c.c" + + DNSTAP_OBJ="dnstap.lo dnstap.pb-c.lo" + + + else + + ENABLE_DNSTAP=0 + + + + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ${MAKE:-make} supports $< with implicit rule in scope" >&5 $as_echo_n "checking if ${MAKE:-make} supports $< with implicit rule in scope... " >&6; } # on openBSD, the implicit rule make $< work. @@ -19994,7 +20430,7 @@ _ACEOF -ac_config_files="$ac_config_files Makefile doc/example.conf doc/libunbound.3 doc/unbound.8 doc/unbound-anchor.8 doc/unbound-checkconf.8 doc/unbound.conf.5 doc/unbound-control.8 doc/unbound-host.1 smallapp/unbound-control-setup.sh" +ac_config_files="$ac_config_files Makefile doc/example.conf doc/libunbound.3 doc/unbound.8 doc/unbound-anchor.8 doc/unbound-checkconf.8 doc/unbound.conf.5 doc/unbound-control.8 doc/unbound-host.1 smallapp/unbound-control-setup.sh dnstap/dnstap_config.h" ac_config_headers="$ac_config_headers config.h" @@ -20986,6 +21422,7 @@ do "doc/unbound-control.8") CONFIG_FILES="$CONFIG_FILES doc/unbound-control.8" ;; "doc/unbound-host.1") CONFIG_FILES="$CONFIG_FILES doc/unbound-host.1" ;; "smallapp/unbound-control-setup.sh") CONFIG_FILES="$CONFIG_FILES smallapp/unbound-control-setup.sh" ;; + "dnstap/dnstap_config.h") CONFIG_FILES="$CONFIG_FILES dnstap/dnstap_config.h" ;; "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; diff --git a/configure.ac b/configure.ac index d5df2992d..6fb98a237 100644 --- a/configure.ac +++ b/configure.ac @@ -5,6 +5,8 @@ sinclude(acx_nlnetlabs.m4) sinclude(ax_pthread.m4) sinclude(acx_python.m4) sinclude(ac_pkg_swig.m4) +sinclude(pkg.m4) +sinclude(dnstap/dnstap.m4) # must be numbers. ac_defun because of later processing m4_define([VERSION_MAJOR],[1]) @@ -1094,6 +1096,27 @@ if test x_$enable_lock_checks = x_yes; then echo checklock_thrjoin >> clubsyms.def fi +# check for dnstap if requested +dt_DNSTAP([$UNBOUND_RUN_DIR/dnstap.sock], + [ + LIBS="$LIBS $DNSTAP_LIBS" + CFLAGS="$CFLAGS $DNSTAP_CFLAGS" + AC_DEFINE([USE_DNSTAP], [1], [Define to 1 to enable dnstap support]) + AC_SUBST([ENABLE_DNSTAP], [1]) + + AC_SUBST([opt_dnstap_socket_path]) + ACX_ESCAPE_BACKSLASH($opt_dnstap_socket_path, hdr_dnstap_socket_path) + AC_DEFINE_UNQUOTED(DNSTAP_SOCKET_PATH, + ["$hdr_dnstap_socket_path"], [default dnstap socket path]) + + AC_SUBST([DNSTAP_SRC], ["dnstap/dnstap.c dnstap/dnstap.pb-c.c"]) + AC_SUBST([DNSTAP_OBJ], ["dnstap.lo dnstap.pb-c.lo"]) + ], + [ + AC_SUBST([ENABLE_DNSTAP], [0]) + ] +) + AC_MSG_CHECKING([if ${MAKE:-make} supports $< with implicit rule in scope]) # on openBSD, the implicit rule make $< work. # on Solaris, it does not work ($? is changed sources, $^ lists dependencies). @@ -1345,6 +1368,6 @@ void *unbound_stat_realloc_log(void *ptr, size_t size, const char* file, ]) -AC_CONFIG_FILES([Makefile doc/example.conf doc/libunbound.3 doc/unbound.8 doc/unbound-anchor.8 doc/unbound-checkconf.8 doc/unbound.conf.5 doc/unbound-control.8 doc/unbound-host.1 smallapp/unbound-control-setup.sh]) +AC_CONFIG_FILES([Makefile doc/example.conf doc/libunbound.3 doc/unbound.8 doc/unbound-anchor.8 doc/unbound-checkconf.8 doc/unbound.conf.5 doc/unbound-control.8 doc/unbound-host.1 smallapp/unbound-control-setup.sh dnstap/dnstap_config.h]) AC_CONFIG_HEADER([config.h]) AC_OUTPUT diff --git a/daemon/daemon.c b/daemon/daemon.c index 2c237c55d..f05cdb198 100644 --- a/daemon/daemon.c +++ b/daemon/daemon.c @@ -401,6 +401,17 @@ daemon_create_workers(struct daemon* daemon) daemon->num = (daemon->cfg->num_threads?daemon->cfg->num_threads:1); daemon->workers = (struct worker**)calloc((size_t)daemon->num, sizeof(struct worker*)); + if(daemon->cfg->dnstap) { +#ifdef USE_DNSTAP + daemon->dtenv = dt_create(daemon->cfg->dnstap_socket_path, + daemon->num); + if (!daemon->dtenv) + fatal_exit("dt_create failed"); + dt_apply_cfg(daemon->dtenv, daemon->cfg); +#else + fatal_exit("dnstap enabled in config but not built with dnstap support"); +#endif + } for(i=0; inum; i++) { if(!(daemon->workers[i] = worker_create(daemon, i, shufport+numport*i/daemon->num, @@ -585,6 +596,9 @@ daemon_cleanup(struct daemon* daemon) free(daemon->workers); daemon->workers = NULL; daemon->num = 0; +#ifdef USE_DNSTAP + dt_delete(daemon->dtenv); +#endif daemon->cfg = NULL; } diff --git a/daemon/daemon.h b/daemon/daemon.h index 37ddf9e18..86ddab1df 100644 --- a/daemon/daemon.h +++ b/daemon/daemon.h @@ -59,6 +59,11 @@ struct local_zones; struct ub_randstate; struct daemon_remote; +#include "dnstap/dnstap_config.h" +#ifdef USE_DNSTAP +struct dt_env; +#endif + /** * Structure holding worker list. * Holds globally visible information. @@ -109,6 +114,10 @@ struct daemon { struct timeval time_last_stat; /** time when daemon started */ struct timeval time_boot; +#ifdef USE_DNSTAP + /** the dnstap environment master value, copied and changed by threads*/ + struct dt_env* dtenv; +#endif }; /** diff --git a/daemon/worker.c b/daemon/worker.c index aede1a68c..f90676213 100644 --- a/daemon/worker.c +++ b/daemon/worker.c @@ -777,16 +777,24 @@ worker_handle_request(struct comm_point* c, void* arg, int error, struct query_info qinfo; struct edns_data edns; enum acl_access acl; + int rc = 0; if(error != NETEVENT_NOERROR) { /* some bad tcp query DNS formats give these error calls */ verbose(VERB_ALGO, "handle request called with err=%d", error); return 0; } +#ifdef USE_DNSTAP + if(worker->dtenv.log_client_query_messages) + dt_msg_send_client_query(&worker->dtenv, &repinfo->addr, c->type, + c->buffer); +#endif acl = acl_list_lookup(worker->daemon->acl, &repinfo->addr, repinfo->addrlen); if((ret=deny_refuse_all(c, acl, worker, repinfo)) != -1) { + if(ret == 1) + goto send_reply; return ret; } if((ret=worker_check_request(c->buffer, worker)) != 0) { @@ -810,7 +818,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), LDNS_RCODE_FORMERR); server_stats_insrcode(&worker->stats, c->buffer); - return 1; + goto send_reply; } if(worker->env.cfg->log_queries) { char ip[128]; @@ -829,7 +837,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, worker->stats.qtype[qinfo.qtype]++; server_stats_insrcode(&worker->stats, c->buffer); } - return 1; + goto send_reply; } if((ret=parse_edns_from_pkt(c->buffer, &edns)) != 0) { verbose(VERB_ALGO, "worker parse edns: formerror."); @@ -838,7 +846,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, LDNS_QR_SET(sldns_buffer_begin(c->buffer)); LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret); server_stats_insrcode(&worker->stats, c->buffer); - return 1; + goto send_reply; } if(edns.edns_present && edns.edns_version != 0) { edns.ext_rcode = (uint8_t)(EDNS_RCODE_BADVERS>>4); @@ -851,7 +859,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, *(uint16_t*)(void *)sldns_buffer_begin(c->buffer), sldns_buffer_read_u16_at(c->buffer, 2), NULL); attach_edns_record(c->buffer, &edns); - return 1; + goto send_reply; } if(edns.edns_present && edns.udp_size < NORMAL_UDP_SIZE && worker->daemon->cfg->harden_short_bufsize) { @@ -879,7 +887,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, sldns_buffer_write_at(c->buffer, 4, (uint8_t*)"\0\0\0\0\0\0\0\0", 8); sldns_buffer_flip(c->buffer); - return 1; + goto send_reply; } if(worker->stats.extended) server_stats_insquery(&worker->stats, c, qinfo.qtype, @@ -889,7 +897,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, if(qinfo.qclass == LDNS_RR_CLASS_CH && answer_chaos(worker, &qinfo, &edns, c->buffer)) { server_stats_insrcode(&worker->stats, c->buffer); - return 1; + goto send_reply; } if(local_zones_answer(worker->daemon->local_zones, &qinfo, &edns, c->buffer, worker->scratchpad)) { @@ -899,13 +907,15 @@ worker_handle_request(struct comm_point* c, void* arg, int error, return 0; } server_stats_insrcode(&worker->stats, c->buffer); - return 1; + goto send_reply; } /* We've looked in our local zones. If the answer isn't there, we * might need to bail out based on ACLs now. */ if((ret=deny_refuse_non_local(c, acl, worker, repinfo)) != -1) { + if(ret == 1) + goto send_reply; return ret; } @@ -923,7 +933,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, server_stats_insrcode(&worker->stats, c->buffer); log_addr(VERB_ALGO, "refused nonrec (cache snoop) query from", &repinfo->addr, repinfo->addrlen); - return 1; + goto send_reply; } h = query_info_hash(&qinfo); if((e=slabhash_lookup(worker->env.msg_cache, h, &qinfo, 0))) { @@ -942,10 +952,11 @@ worker_handle_request(struct comm_point* c, void* arg, int error, reply_and_prefetch(worker, &qinfo, sldns_buffer_read_u16_at(c->buffer, 2), repinfo, leeway); - return 0; + rc = 0; + goto send_reply_rc; } lock_rw_unlock(&e->lock); - return 1; + goto send_reply; } verbose(VERB_ALGO, "answer from the cache failed"); lock_rw_unlock(&e->lock); @@ -955,7 +966,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error, *(uint16_t*)(void *)sldns_buffer_begin(c->buffer), sldns_buffer_read_u16_at(c->buffer, 2), repinfo, &edns)) { - return 1; + goto send_reply; } verbose(VERB_ALGO, "answer norec from cache -- " "need to validate or not primed"); @@ -977,6 +988,16 @@ worker_handle_request(struct comm_point* c, void* arg, int error, &edns, repinfo, *(uint16_t*)(void *)sldns_buffer_begin(c->buffer)); worker_mem_report(worker, NULL); return 0; + +send_reply: + rc = 1; +send_reply_rc: +#ifdef USE_DNSTAP + if(worker->dtenv.log_client_response_messages) + dt_msg_send_client_response(&worker->dtenv, &repinfo->addr, + c->type, c->buffer); +#endif + return rc; } void @@ -1084,6 +1105,14 @@ worker_create(struct daemon* daemon, int id, int* ports, int n) return NULL; } seed = 0; +#ifdef USE_DNSTAP + if(daemon->cfg->dnstap) { + log_assert(daemon->dtenv != NULL); + memcpy(&worker->dtenv, daemon->dtenv, sizeof(struct dt_env)); + if(!dt_init(&worker->dtenv)) + fatal_exit("dt_init failed"); + } +#endif return worker; } @@ -1091,6 +1120,11 @@ int worker_init(struct worker* worker, struct config_file *cfg, struct listen_port* ports, int do_sigs) { +#ifdef USE_DNSTAP + struct dt_env* dtenv = &worker->dtenv; +#else + void* dtenv = NULL; +#endif worker->need_to_exit = 0; worker->base = comm_base_create(do_sigs); if(!worker->base) { @@ -1139,7 +1173,8 @@ worker_init(struct worker* worker, struct config_file *cfg, } worker->front = listen_create(worker->base, ports, cfg->msg_buffer_size, (int)cfg->incoming_num_tcp, - worker->daemon->listen_sslctx, worker_handle_request, worker); + worker->daemon->listen_sslctx, dtenv, worker_handle_request, + worker); if(!worker->front) { log_err("could not create listening sockets"); worker_delete(worker); @@ -1152,7 +1187,8 @@ worker_init(struct worker* worker, struct config_file *cfg, worker->daemon->env->infra_cache, worker->rndstate, cfg->use_caps_bits_for_id, worker->ports, worker->numports, cfg->unwanted_threshold, &worker_alloc_cleanup, worker, - cfg->do_udp, worker->daemon->connect_sslctx, cfg->delay_close); + cfg->do_udp, worker->daemon->connect_sslctx, cfg->delay_close, + dtenv); if(!worker->back) { log_err("could not create outgoing sockets"); worker_delete(worker); diff --git a/daemon/worker.h b/daemon/worker.h index 83503ae89..ff69bc1ac 100644 --- a/daemon/worker.h +++ b/daemon/worker.h @@ -51,6 +51,7 @@ #include "util/data/msgparse.h" #include "daemon/stats.h" #include "util/module.h" +#include "dnstap/dnstap.h" struct listen_dnsport; struct outside_network; struct config_file; @@ -116,6 +117,11 @@ struct worker { /** module environment passed to modules, changed for this thread */ struct module_env env; + +#ifdef USE_DNSTAP + /** dnstap environment, changed for this thread */ + struct dt_env dtenv; +#endif }; /** diff --git a/dnstap/dnstap.c b/dnstap/dnstap.c new file mode 100644 index 000000000..413bd3745 --- /dev/null +++ b/dnstap/dnstap.c @@ -0,0 +1,499 @@ +/* dnstap support for Unbound */ + +/* + * Copyright (c) 2013-2014, Farsight Security, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "dnstap/dnstap_config.h" + +#ifdef USE_DNSTAP + +#include "config.h" +#include +#include "ldns/sbuffer.h" +#include "util/config_file.h" +#include "util/net_help.h" +#include "util/netevent.h" +#include "util/log.h" + +#include +#include + +#include "dnstap/dnstap.h" +#include "dnstap/dnstap.pb-c.h" + +#define DNSTAP_CONTENT_TYPE "protobuf:dnstap.Dnstap" +#define DNSTAP_INITIAL_BUF_SIZE 256 + +struct dt_msg { + void *buf; + size_t len_buf; + Dnstap__Dnstap d; + Dnstap__Message m; +}; + +static int +dt_pack(const Dnstap__Dnstap *d, void **buf, size_t *sz) +{ + ProtobufCBufferSimple sbuf; + + sbuf.base.append = protobuf_c_buffer_simple_append; + sbuf.len = 0; + sbuf.alloced = DNSTAP_INITIAL_BUF_SIZE; + sbuf.data = malloc(sbuf.alloced); + if (sbuf.data == NULL) + return 0; + sbuf.must_free_data = 1; + + *sz = dnstap__dnstap__pack_to_buffer(d, (ProtobufCBuffer *) &sbuf); + if (sbuf.data == NULL) + return 0; + *buf = sbuf.data; + + return 1; +} + +static void +dt_send(const struct dt_env *env, void *buf, size_t len_buf) +{ + fstrm_res res; + if (!buf) + return; + res = fstrm_io_submit(env->fio, env->fq, buf, len_buf, + fstrm_free_wrapper, NULL); + if (res != FSTRM_RES_SUCCESS) + free(buf); +} + +static void +dt_msg_init(const struct dt_env *env, + struct dt_msg *dm, + Dnstap__Message__Type mtype) +{ + memset(dm, 0, sizeof(*dm)); + dm->d.base.descriptor = &dnstap__dnstap__descriptor; + dm->m.base.descriptor = &dnstap__message__descriptor; + dm->d.type = DNSTAP__DNSTAP__TYPE__MESSAGE; + dm->d.message = &dm->m; + dm->m.type = mtype; + if (env->identity != NULL) { + dm->d.identity.data = (uint8_t *) env->identity; + dm->d.identity.len = (size_t) env->len_identity; + dm->d.has_identity = 1; + } + if (env->version != NULL) { + dm->d.version.data = (uint8_t *) env->version; + dm->d.version.len = (size_t) env->len_version; + dm->d.has_version = 1; + } +} + +struct dt_env * +dt_create(const char *socket_path, unsigned num_workers) +{ + char *fio_err; + struct dt_env *env; + struct fstrm_io_options *fopt; + struct fstrm_unix_writer_options *fuwopt; + + verbose(VERB_OPS, "opening dnstap socket %s", socket_path); + log_assert(socket_path != NULL); + log_assert(num_workers > 0); + + env = (struct dt_env *) calloc(1, sizeof(struct dt_env)); + if (!env) + return NULL; + + fuwopt = fstrm_unix_writer_options_init(); + fstrm_unix_writer_options_set_socket_path(fuwopt, socket_path); + fopt = fstrm_io_options_init(); + fstrm_io_options_set_content_type(fopt, + DNSTAP_CONTENT_TYPE, + sizeof(DNSTAP_CONTENT_TYPE) - 1); + fstrm_io_options_set_num_queues(fopt, num_workers); + fstrm_io_options_set_writer(fopt, fstrm_unix_writer, fuwopt); + env->fio = fstrm_io_init(fopt, &fio_err); + if (env->fio == NULL) { + verbose(VERB_DETAIL, "dt_create: fstrm_io_init() failed: %s", + fio_err); + free(fio_err); + free(env); + env = NULL; + } + fstrm_io_options_destroy(&fopt); + fstrm_unix_writer_options_destroy(&fuwopt); + + return env; +} + +static void +dt_apply_identity(struct dt_env *env, struct config_file *cfg) +{ + char buf[MAXHOSTNAMELEN+1]; + if (!cfg->dnstap_send_identity) + return; + free(env->identity); + if (cfg->dnstap_identity == NULL || cfg->dnstap_identity[0] == 0) { + if (gethostname(buf, MAXHOSTNAMELEN) == 0) { + buf[MAXHOSTNAMELEN] = 0; + env->identity = strdup(buf); + } else { + fatal_exit("dt_apply_identity: gethostname() failed"); + } + } else { + env->identity = strdup(cfg->dnstap_identity); + } + if (env->identity == NULL) + fatal_exit("dt_apply_identity: strdup() failed"); + env->len_identity = strlen(env->identity); + verbose(VERB_OPS, "dnstap identity field set to \"%s\"", + env->identity); +} + +static void +dt_apply_version(struct dt_env *env, struct config_file *cfg) +{ + if (!cfg->dnstap_send_version) + return; + free(env->version); + if (cfg->dnstap_version == NULL || cfg->dnstap_version[0] == 0) + env->version = strdup(PACKAGE_STRING); + else + env->version = strdup(cfg->dnstap_version); + if (env->version == NULL) + fatal_exit("dt_apply_version: strdup() failed"); + env->len_version = strlen(env->version); + verbose(VERB_OPS, "dnstap version field set to \"%s\"", + env->version); +} + +void +dt_apply_cfg(struct dt_env *env, struct config_file *cfg) +{ + if (!cfg->dnstap) + return; + + dt_apply_identity(env, cfg); + dt_apply_version(env, cfg); + if ((env->log_resolver_query_messages = + cfg->dnstap_log_resolver_query_messages)) + { + verbose(VERB_OPS, "dnstap Message/RESOLVER_QUERY enabled"); + } + if ((env->log_resolver_response_messages = + cfg->dnstap_log_resolver_response_messages)) + { + verbose(VERB_OPS, "dnstap Message/RESOLVER_RESPONSE enabled"); + } + if ((env->log_client_query_messages = + cfg->dnstap_log_client_query_messages)) + { + verbose(VERB_OPS, "dnstap Message/CLIENT_QUERY enabled"); + } + if ((env->log_client_response_messages = + cfg->dnstap_log_client_response_messages)) + { + verbose(VERB_OPS, "dnstap Message/CLIENT_RESPONSE enabled"); + } + if ((env->log_forwarder_query_messages = + cfg->dnstap_log_forwarder_query_messages)) + { + verbose(VERB_OPS, "dnstap Message/FORWARDER_QUERY enabled"); + } + if ((env->log_forwarder_response_messages = + cfg->dnstap_log_forwarder_response_messages)) + { + verbose(VERB_OPS, "dnstap Message/FORWARDER_RESPONSE enabled"); + } +} + +int +dt_init(struct dt_env *env) +{ + env->fq = fstrm_io_get_queue(env->fio); + if (env->fq == NULL) + return 0; + return 1; +} + +void +dt_delete(struct dt_env *env) +{ + if (!env) + return; + verbose(VERB_OPS, "closing dnstap socket"); + fstrm_io_destroy(&env->fio); + free(env->identity); + free(env->version); + free(env); +} + +static void +dt_fill_timeval(const struct timeval *tv, + uint64_t *time_sec, protobuf_c_boolean *has_time_sec, + uint32_t *time_nsec, protobuf_c_boolean *has_time_nsec) +{ + *time_sec = tv->tv_sec; + *time_nsec = tv->tv_usec * 1000; + *has_time_sec = 1; + *has_time_nsec = 1; +} + +static void +dt_fill_buffer(sldns_buffer *b, ProtobufCBinaryData *p, protobuf_c_boolean *has) +{ + log_assert(b != NULL); + p->len = sldns_buffer_limit(b); + p->data = sldns_buffer_begin(b); + *has = 1; +} + +static void +dt_msg_fill_net(struct dt_msg *dm, + struct sockaddr_storage *ss, + enum comm_point_type cptype, + ProtobufCBinaryData *addr, protobuf_c_boolean *has_addr, + uint32_t *port, protobuf_c_boolean *has_port) +{ + log_assert(ss->ss_family == AF_INET6 || ss->ss_family == AF_INET); + if (ss->ss_family == AF_INET6) { + struct sockaddr_in6 *s = (struct sockaddr_in6 *) ss; + + /* socket_family */ + dm->m.socket_family = DNSTAP__SOCKET_FAMILY__INET6; + dm->m.has_socket_family = 1; + + /* addr: query_address or response_address */ + addr->data = s->sin6_addr.s6_addr; + addr->len = 16; /* IPv6 */ + *has_addr = 1; + + /* port: query_port or response_port */ + *port = ntohs(s->sin6_port); + *has_port = 1; + } else if (ss->ss_family == AF_INET) { + struct sockaddr_in *s = (struct sockaddr_in *) ss; + + /* socket_family */ + dm->m.socket_family = DNSTAP__SOCKET_FAMILY__INET; + dm->m.has_socket_family = 1; + + /* addr: query_address or response_address */ + addr->data = (uint8_t *) &s->sin_addr.s_addr; + addr->len = 4; /* IPv4 */ + *has_addr = 1; + + /* port: query_port or response_port */ + *port = ntohs(s->sin_port); + *has_port = 1; + } + + log_assert(cptype == comm_udp || cptype == comm_tcp); + if (cptype == comm_udp) { + /* socket_protocol */ + dm->m.socket_protocol = DNSTAP__SOCKET_PROTOCOL__UDP; + dm->m.has_socket_protocol = 1; + } else if (cptype == comm_tcp) { + /* socket_protocol */ + dm->m.socket_protocol = DNSTAP__SOCKET_PROTOCOL__TCP; + dm->m.has_socket_protocol = 1; + } +} + +void +dt_msg_send_client_query(struct dt_env *env, + struct sockaddr_storage *qsock, + enum comm_point_type cptype, + sldns_buffer *qmsg) +{ + struct dt_msg dm; + struct timeval qtime; + + gettimeofday(&qtime, NULL); + + /* type */ + dt_msg_init(env, &dm, DNSTAP__MESSAGE__TYPE__CLIENT_QUERY); + + /* query_time */ + dt_fill_timeval(&qtime, + &dm.m.query_time_sec, &dm.m.has_query_time_sec, + &dm.m.query_time_nsec, &dm.m.has_query_time_nsec); + + /* query_message */ + dt_fill_buffer(qmsg, &dm.m.query_message, &dm.m.has_query_message); + + /* socket_family, socket_protocol, query_address, query_port */ + log_assert(cptype == comm_udp || cptype == comm_tcp); + dt_msg_fill_net(&dm, qsock, cptype, + &dm.m.query_address, &dm.m.has_query_address, + &dm.m.query_port, &dm.m.has_query_port); + + if (dt_pack(&dm.d, &dm.buf, &dm.len_buf)) + dt_send(env, dm.buf, dm.len_buf); +} + +void +dt_msg_send_client_response(struct dt_env *env, + struct sockaddr_storage *qsock, + enum comm_point_type cptype, + sldns_buffer *rmsg) +{ + struct dt_msg dm; + struct timeval rtime; + + gettimeofday(&rtime, NULL); + + /* type */ + dt_msg_init(env, &dm, DNSTAP__MESSAGE__TYPE__CLIENT_RESPONSE); + + /* response_time */ + dt_fill_timeval(&rtime, + &dm.m.response_time_sec, &dm.m.has_response_time_sec, + &dm.m.response_time_nsec, &dm.m.has_response_time_nsec); + + /* response_message */ + dt_fill_buffer(rmsg, &dm.m.response_message, &dm.m.has_response_message); + + /* socket_family, socket_protocol, query_address, query_port */ + log_assert(cptype == comm_udp || cptype == comm_tcp); + dt_msg_fill_net(&dm, qsock, cptype, + &dm.m.query_address, &dm.m.has_query_address, + &dm.m.query_port, &dm.m.has_query_port); + + if (dt_pack(&dm.d, &dm.buf, &dm.len_buf)) + dt_send(env, dm.buf, dm.len_buf); +} + +void +dt_msg_send_outside_query(struct dt_env *env, + struct sockaddr_storage *rsock, + enum comm_point_type cptype, + uint8_t *zone, size_t zone_len, + sldns_buffer *qmsg) +{ + struct dt_msg dm; + struct timeval qtime; + uint16_t qflags; + + gettimeofday(&qtime, NULL); + qflags = sldns_buffer_read_u16_at(qmsg, 2); + + /* type */ + if (qflags & BIT_RD) { + if (!env->log_forwarder_query_messages) + return; + dt_msg_init(env, &dm, DNSTAP__MESSAGE__TYPE__FORWARDER_QUERY); + } else { + if (!env->log_resolver_query_messages) + return; + dt_msg_init(env, &dm, DNSTAP__MESSAGE__TYPE__RESOLVER_QUERY); + } + + /* query_zone */ + dm.m.query_zone.data = zone; + dm.m.query_zone.len = zone_len; + dm.m.has_query_zone = 1; + + /* query_time_sec, query_time_nsec */ + dt_fill_timeval(&qtime, + &dm.m.query_time_sec, &dm.m.has_query_time_sec, + &dm.m.query_time_nsec, &dm.m.has_query_time_nsec); + + /* query_message */ + dt_fill_buffer(qmsg, &dm.m.query_message, &dm.m.has_query_message); + + /* socket_family, socket_protocol, response_address, response_port */ + log_assert(cptype == comm_udp || cptype == comm_tcp); + dt_msg_fill_net(&dm, rsock, cptype, + &dm.m.response_address, &dm.m.has_response_address, + &dm.m.response_port, &dm.m.has_response_port); + + if (dt_pack(&dm.d, &dm.buf, &dm.len_buf)) + dt_send(env, dm.buf, dm.len_buf); +} + +void +dt_msg_send_outside_response(struct dt_env *env, + struct sockaddr_storage *rsock, + enum comm_point_type cptype, + uint8_t *zone, size_t zone_len, + uint8_t *qbuf, size_t qbuf_len, + const struct timeval *qtime, + const struct timeval *rtime, + sldns_buffer *rmsg) +{ + struct dt_msg dm; + uint16_t qflags; + + log_assert(qbuf_len >= sizeof(qflags)); + memcpy(&qflags, qbuf, sizeof(qflags)); + qflags = ntohs(qflags); + + /* type */ + if (qflags & BIT_RD) { + if (!env->log_forwarder_response_messages) + return; + dt_msg_init(env, &dm, DNSTAP__MESSAGE__TYPE__FORWARDER_RESPONSE); + } else { + if (!env->log_resolver_query_messages) + return; + dt_msg_init(env, &dm, DNSTAP__MESSAGE__TYPE__RESOLVER_RESPONSE); + } + + /* query_zone */ + dm.m.query_zone.data = zone; + dm.m.query_zone.len = zone_len; + dm.m.has_query_zone = 1; + + /* query_time_sec, query_time_nsec */ + dt_fill_timeval(qtime, + &dm.m.query_time_sec, &dm.m.has_query_time_sec, + &dm.m.query_time_nsec, &dm.m.has_query_time_nsec); + + /* response_time_sec, response_time_nsec */ + dt_fill_timeval(rtime, + &dm.m.response_time_sec, &dm.m.has_response_time_sec, + &dm.m.response_time_nsec, &dm.m.has_response_time_nsec); + + /* response_message */ + dt_fill_buffer(rmsg, &dm.m.response_message, &dm.m.has_response_message); + + /* socket_family, socket_protocol, response_address, response_port */ + log_assert(cptype == comm_udp || cptype == comm_tcp); + dt_msg_fill_net(&dm, rsock, cptype, + &dm.m.response_address, &dm.m.has_response_address, + &dm.m.response_port, &dm.m.has_response_port); + + if (dt_pack(&dm.d, &dm.buf, &dm.len_buf)) + dt_send(env, dm.buf, dm.len_buf); +} + +#endif /* USE_DNSTAP */ diff --git a/dnstap/dnstap.h b/dnstap/dnstap.h new file mode 100644 index 000000000..d9121df7d --- /dev/null +++ b/dnstap/dnstap.h @@ -0,0 +1,188 @@ +/* dnstap support for Unbound */ + +/* + * Copyright (c) 2013-2014, Farsight Security, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef UNBOUND_DNSTAP_H +#define UNBOUND_DNSTAP_H + +#include "dnstap/dnstap_config.h" + +#ifdef USE_DNSTAP + +struct config_file; +struct fstrm_io; +struct fstrm_queue; +struct sldns_buffer; + +struct dt_env { + /** dnstap I/O socket */ + struct fstrm_io *fio; + + /** dnstap I/O queue */ + struct fstrm_queue *fq; + + /** dnstap "identity" field, NULL if disabled */ + char *identity; + + /** dnstap "version" field, NULL if disabled */ + char *version; + + /** length of "identity" field */ + unsigned len_identity; + + /** length of "version" field */ + unsigned len_version; + + /** whether to log Message/RESOLVER_QUERY */ + unsigned log_resolver_query_messages : 1; + /** whether to log Message/RESOLVER_RESPONSE */ + unsigned log_resolver_response_messages : 1; + /** whether to log Message/CLIENT_QUERY */ + unsigned log_client_query_messages : 1; + /** whether to log Message/CLIENT_RESPONSE */ + unsigned log_client_response_messages : 1; + /** whether to log Message/FORWARDER_QUERY */ + unsigned log_forwarder_query_messages : 1; + /** whether to log Message/FORWARDER_RESPONSE */ + unsigned log_forwarder_response_messages : 1; +}; + +/** + * Create dnstap environment object. Afterwards, call dt_apply_cfg() to fill in + * the config variables and dt_init() to fill in the per-worker state. Each + * worker needs a copy of this object but with its own I/O queue (the fq field + * of the structure) to ensure lock-free access to its own per-worker circular + * queue. Duplicate the environment object if more than one worker needs to + * share access to the dnstap I/O socket. + * @param socket_path: path to dnstap logging socket, must be non-NULL. + * @param num_workers: number of worker threads, must be > 0. + * @return dt_env object, NULL on failure. + */ +struct dt_env * +dt_create(const char *socket_path, unsigned num_workers); + +/** + * Apply config settings. + * @param env: dnstap environment object. + * @param cfg: new config settings. + */ +void +dt_apply_cfg(struct dt_env *env, struct config_file *cfg); + +/** + * Initialize per-worker state in dnstap environment object. + * @param env: dnstap environment object to initialize, created with dt_create(). + * @return: true on success, false on failure. + */ +int +dt_init(struct dt_env *env); + +/** + * Delete dnstap environment object. Closes dnstap I/O socket and deletes all + * per-worker I/O queues. + */ +void +dt_delete(struct dt_env *env); + +/** + * Create and send a new dnstap "Message" event of type CLIENT_QUERY. + * @param env: dnstap environment object. + * @param qsock: address/port of client. + * @param cptype: comm_udp or comm_tcp. + * @param qmsg: query message. + */ +void +dt_msg_send_client_query(struct dt_env *env, + struct sockaddr_storage *qsock, + enum comm_point_type cptype, + struct sldns_buffer *qmsg); + +/** + * Create and send a new dnstap "Message" event of type CLIENT_RESPONSE. + * @param env: dnstap environment object. + * @param qsock: address/port of client. + * @param cptype: comm_udp or comm_tcp. + * @param rmsg: response message. + */ +void +dt_msg_send_client_response(struct dt_env *env, + struct sockaddr_storage *qsock, + enum comm_point_type cptype, + struct sldns_buffer *rmsg); + +/** + * Create and send a new dnstap "Message" event of type RESOLVER_QUERY or + * FORWARDER_QUERY. The type used is dependent on the value of the RD bit + * in the query header. + * @param env: dnstap environment object. + * @param rsock: address/port of server the query is being sent to. + * @param cptype: comm_udp or comm_tcp. + * @param zone: query zone. + * @param zone_len: length of zone. + * @param qmsg: query message. + */ +void +dt_msg_send_outside_query(struct dt_env *env, + struct sockaddr_storage *rsock, + enum comm_point_type cptype, + uint8_t *zone, size_t zone_len, + struct sldns_buffer *qmsg); + +/** + * Create and send a new dnstap "Message" event of type RESOLVER_RESPONSE or + * FORWARDER_RESPONSE. The type used is dependent on the value of the RD bit + * in the query header. + * @param env: dnstap environment object. + * @param rsock: address/port of server the response was received from. + * @param cptype: comm_udp or comm_tcp. + * @param zone: query zone. + * @param zone_len: length of zone. + * @param qbuf: outside_network's qbuf key. + * @param qbuf_len: length of outside_network's qbuf key. + * @param qtime: time query message was sent. + * @param rtime: time response message was sent. + * @param rmsg: response message. + */ +void +dt_msg_send_outside_response(struct dt_env *env, + struct sockaddr_storage *rsock, + enum comm_point_type cptype, + uint8_t *zone, size_t zone_len, + uint8_t *qbuf, size_t qbuf_len, + const struct timeval *qtime, + const struct timeval *rtime, + struct sldns_buffer *rmsg); + +#endif /* USE_DNSTAP */ + +#endif /* UNBOUND_DNSTAP_H */ diff --git a/dnstap/dnstap.m4 b/dnstap/dnstap.m4 new file mode 100644 index 000000000..11cd001fe --- /dev/null +++ b/dnstap/dnstap.m4 @@ -0,0 +1,31 @@ +# dnstap.m4 + +# dt_DNSTAP(default_dnstap_socket_path, [action-if-true], [action-if-false]) +# -------------------------------------------------------------------------- +# Check for required dnstap libraries and add dnstap configure args. +AC_DEFUN([dt_DNSTAP], +[ + AC_ARG_ENABLE([dnstap], + AS_HELP_STRING([--enable-dnstap], + [Enable dnstap support (requires fstrm, protobuf-c)]), + [opt_dnstap=$enableval], [opt_dnstap=no]) + + AC_ARG_WITH([dnstap-socket-path], + AS_HELP_STRING([--with-dnstap-socket-path=pathname], + [set default dnstap socket path]), + [opt_dnstap_socket_path=$withval], [opt_dnstap_socket_path="$1"]) + + if test "x$opt_dnstap" != "xno"; then + AC_PATH_PROG([PROTOC_C], [protoc-c]) + if test -z "$PROTOC_C"; then + AC_MSG_ERROR([The protoc-c program was not found. Please install protobuf-c!]) + fi + PKG_CHECK_MODULES([libfstrm], [libfstrm]) + PKG_CHECK_MODULES([libprotobuf_c], [libprotobuf-c]) + DNSTAP_CFLAGS="$libfstrm_CFLAGS $libprotobuf_c_CFLAGS" + DNSTAP_LIBS="$libfstrm_LIBS $libprotobuf_c_LIBS" + $2 + else + $3 + fi +]) diff --git a/dnstap/dnstap.pb-c.c b/dnstap/dnstap.pb-c.c new file mode 100644 index 000000000..51100eb56 --- /dev/null +++ b/dnstap/dnstap.pb-c.c @@ -0,0 +1,518 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C_NO_DEPRECATED +#define PROTOBUF_C_NO_DEPRECATED +#endif + +#include "dnstap/dnstap.pb-c.h" +void dnstap__dnstap__init + (Dnstap__Dnstap *message) +{ + static Dnstap__Dnstap init_value = DNSTAP__DNSTAP__INIT; + *message = init_value; +} +size_t dnstap__dnstap__get_packed_size + (const Dnstap__Dnstap *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__dnstap__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t dnstap__dnstap__pack + (const Dnstap__Dnstap *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__dnstap__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t dnstap__dnstap__pack_to_buffer + (const Dnstap__Dnstap *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__dnstap__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Dnstap__Dnstap * + dnstap__dnstap__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Dnstap__Dnstap *) + protobuf_c_message_unpack (&dnstap__dnstap__descriptor, + allocator, len, data); +} +void dnstap__dnstap__free_unpacked + (Dnstap__Dnstap *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__dnstap__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void dnstap__message__init + (Dnstap__Message *message) +{ + static Dnstap__Message init_value = DNSTAP__MESSAGE__INIT; + *message = init_value; +} +size_t dnstap__message__get_packed_size + (const Dnstap__Message *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__message__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t dnstap__message__pack + (const Dnstap__Message *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__message__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t dnstap__message__pack_to_buffer + (const Dnstap__Message *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__message__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Dnstap__Message * + dnstap__message__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Dnstap__Message *) + protobuf_c_message_unpack (&dnstap__message__descriptor, + allocator, len, data); +} +void dnstap__message__free_unpacked + (Dnstap__Message *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &dnstap__message__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +const ProtobufCEnumValue dnstap__dnstap__type__enum_values_by_number[1] = +{ + { "MESSAGE", "DNSTAP__DNSTAP__TYPE__MESSAGE", 1 }, +}; +static const ProtobufCIntRange dnstap__dnstap__type__value_ranges[] = { +{1, 0},{0, 1} +}; +const ProtobufCEnumValueIndex dnstap__dnstap__type__enum_values_by_name[1] = +{ + { "MESSAGE", 0 }, +}; +const ProtobufCEnumDescriptor dnstap__dnstap__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "dnstap.Dnstap.Type", + "Type", + "Dnstap__Dnstap__Type", + "dnstap", + 1, + dnstap__dnstap__type__enum_values_by_number, + 1, + dnstap__dnstap__type__enum_values_by_name, + 1, + dnstap__dnstap__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor dnstap__dnstap__field_descriptors[5] = +{ + { + "identity", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, has_identity), + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, identity), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "version", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, has_version), + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, version), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "extra", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, has_extra), + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, extra), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "message", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, message), + &dnstap__message__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 15, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Dnstap__Dnstap, type), + &dnstap__dnstap__type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned dnstap__dnstap__field_indices_by_name[] = { + 2, /* field[2] = extra */ + 0, /* field[0] = identity */ + 3, /* field[3] = message */ + 4, /* field[4] = type */ + 1, /* field[1] = version */ +}; +static const ProtobufCIntRange dnstap__dnstap__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 14, 3 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor dnstap__dnstap__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "dnstap.Dnstap", + "Dnstap", + "Dnstap__Dnstap", + "dnstap", + sizeof(Dnstap__Dnstap), + 5, + dnstap__dnstap__field_descriptors, + dnstap__dnstap__field_indices_by_name, + 2, dnstap__dnstap__number_ranges, + (ProtobufCMessageInit) dnstap__dnstap__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue dnstap__message__type__enum_values_by_number[10] = +{ + { "AUTH_QUERY", "DNSTAP__MESSAGE__TYPE__AUTH_QUERY", 1 }, + { "AUTH_RESPONSE", "DNSTAP__MESSAGE__TYPE__AUTH_RESPONSE", 2 }, + { "RESOLVER_QUERY", "DNSTAP__MESSAGE__TYPE__RESOLVER_QUERY", 3 }, + { "RESOLVER_RESPONSE", "DNSTAP__MESSAGE__TYPE__RESOLVER_RESPONSE", 4 }, + { "CLIENT_QUERY", "DNSTAP__MESSAGE__TYPE__CLIENT_QUERY", 5 }, + { "CLIENT_RESPONSE", "DNSTAP__MESSAGE__TYPE__CLIENT_RESPONSE", 6 }, + { "FORWARDER_QUERY", "DNSTAP__MESSAGE__TYPE__FORWARDER_QUERY", 7 }, + { "FORWARDER_RESPONSE", "DNSTAP__MESSAGE__TYPE__FORWARDER_RESPONSE", 8 }, + { "STUB_QUERY", "DNSTAP__MESSAGE__TYPE__STUB_QUERY", 9 }, + { "STUB_RESPONSE", "DNSTAP__MESSAGE__TYPE__STUB_RESPONSE", 10 }, +}; +static const ProtobufCIntRange dnstap__message__type__value_ranges[] = { +{1, 0},{0, 10} +}; +const ProtobufCEnumValueIndex dnstap__message__type__enum_values_by_name[10] = +{ + { "AUTH_QUERY", 0 }, + { "AUTH_RESPONSE", 1 }, + { "CLIENT_QUERY", 4 }, + { "CLIENT_RESPONSE", 5 }, + { "FORWARDER_QUERY", 6 }, + { "FORWARDER_RESPONSE", 7 }, + { "RESOLVER_QUERY", 2 }, + { "RESOLVER_RESPONSE", 3 }, + { "STUB_QUERY", 8 }, + { "STUB_RESPONSE", 9 }, +}; +const ProtobufCEnumDescriptor dnstap__message__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "dnstap.Message.Type", + "Type", + "Dnstap__Message__Type", + "dnstap", + 10, + dnstap__message__type__enum_values_by_number, + 10, + dnstap__message__type__enum_values_by_name, + 1, + dnstap__message__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor dnstap__message__field_descriptors[14] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Dnstap__Message, type), + &dnstap__message__type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "socket_family", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_socket_family), + PROTOBUF_C_OFFSETOF(Dnstap__Message, socket_family), + &dnstap__socket_family__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "socket_protocol", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_socket_protocol), + PROTOBUF_C_OFFSETOF(Dnstap__Message, socket_protocol), + &dnstap__socket_protocol__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "query_address", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_query_address), + PROTOBUF_C_OFFSETOF(Dnstap__Message, query_address), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "response_address", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_response_address), + PROTOBUF_C_OFFSETOF(Dnstap__Message, response_address), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "query_port", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_query_port), + PROTOBUF_C_OFFSETOF(Dnstap__Message, query_port), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "response_port", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_response_port), + PROTOBUF_C_OFFSETOF(Dnstap__Message, response_port), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "query_time_sec", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT64, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_query_time_sec), + PROTOBUF_C_OFFSETOF(Dnstap__Message, query_time_sec), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "query_time_nsec", + 9, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FIXED32, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_query_time_nsec), + PROTOBUF_C_OFFSETOF(Dnstap__Message, query_time_nsec), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "query_message", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_query_message), + PROTOBUF_C_OFFSETOF(Dnstap__Message, query_message), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "query_zone", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_query_zone), + PROTOBUF_C_OFFSETOF(Dnstap__Message, query_zone), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "response_time_sec", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT64, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_response_time_sec), + PROTOBUF_C_OFFSETOF(Dnstap__Message, response_time_sec), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "response_time_nsec", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FIXED32, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_response_time_nsec), + PROTOBUF_C_OFFSETOF(Dnstap__Message, response_time_nsec), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "response_message", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Dnstap__Message, has_response_message), + PROTOBUF_C_OFFSETOF(Dnstap__Message, response_message), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned dnstap__message__field_indices_by_name[] = { + 3, /* field[3] = query_address */ + 9, /* field[9] = query_message */ + 5, /* field[5] = query_port */ + 8, /* field[8] = query_time_nsec */ + 7, /* field[7] = query_time_sec */ + 10, /* field[10] = query_zone */ + 4, /* field[4] = response_address */ + 13, /* field[13] = response_message */ + 6, /* field[6] = response_port */ + 12, /* field[12] = response_time_nsec */ + 11, /* field[11] = response_time_sec */ + 1, /* field[1] = socket_family */ + 2, /* field[2] = socket_protocol */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange dnstap__message__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 14 } +}; +const ProtobufCMessageDescriptor dnstap__message__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "dnstap.Message", + "Message", + "Dnstap__Message", + "dnstap", + sizeof(Dnstap__Message), + 14, + dnstap__message__field_descriptors, + dnstap__message__field_indices_by_name, + 1, dnstap__message__number_ranges, + (ProtobufCMessageInit) dnstap__message__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue dnstap__socket_family__enum_values_by_number[2] = +{ + { "INET", "DNSTAP__SOCKET_FAMILY__INET", 1 }, + { "INET6", "DNSTAP__SOCKET_FAMILY__INET6", 2 }, +}; +static const ProtobufCIntRange dnstap__socket_family__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex dnstap__socket_family__enum_values_by_name[2] = +{ + { "INET", 0 }, + { "INET6", 1 }, +}; +const ProtobufCEnumDescriptor dnstap__socket_family__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "dnstap.SocketFamily", + "SocketFamily", + "Dnstap__SocketFamily", + "dnstap", + 2, + dnstap__socket_family__enum_values_by_number, + 2, + dnstap__socket_family__enum_values_by_name, + 1, + dnstap__socket_family__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue dnstap__socket_protocol__enum_values_by_number[2] = +{ + { "UDP", "DNSTAP__SOCKET_PROTOCOL__UDP", 1 }, + { "TCP", "DNSTAP__SOCKET_PROTOCOL__TCP", 2 }, +}; +static const ProtobufCIntRange dnstap__socket_protocol__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex dnstap__socket_protocol__enum_values_by_name[2] = +{ + { "TCP", 1 }, + { "UDP", 0 }, +}; +const ProtobufCEnumDescriptor dnstap__socket_protocol__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "dnstap.SocketProtocol", + "SocketProtocol", + "Dnstap__SocketProtocol", + "dnstap", + 2, + dnstap__socket_protocol__enum_values_by_number, + 2, + dnstap__socket_protocol__enum_values_by_name, + 1, + dnstap__socket_protocol__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/dnstap/dnstap.pb-c.h b/dnstap/dnstap.pb-c.h new file mode 100644 index 000000000..d85e77715 --- /dev/null +++ b/dnstap/dnstap.pb-c.h @@ -0,0 +1,158 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ + +#ifndef PROTOBUF_C_dnstap_2fdnstap_2eproto__INCLUDED +#define PROTOBUF_C_dnstap_2fdnstap_2eproto__INCLUDED + +#include + +PROTOBUF_C_BEGIN_DECLS + + +typedef struct _Dnstap__Dnstap Dnstap__Dnstap; +typedef struct _Dnstap__Message Dnstap__Message; + + +/* --- enums --- */ + +typedef enum _Dnstap__Dnstap__Type { + DNSTAP__DNSTAP__TYPE__MESSAGE = 1 +} Dnstap__Dnstap__Type; +typedef enum _Dnstap__Message__Type { + DNSTAP__MESSAGE__TYPE__AUTH_QUERY = 1, + DNSTAP__MESSAGE__TYPE__AUTH_RESPONSE = 2, + DNSTAP__MESSAGE__TYPE__RESOLVER_QUERY = 3, + DNSTAP__MESSAGE__TYPE__RESOLVER_RESPONSE = 4, + DNSTAP__MESSAGE__TYPE__CLIENT_QUERY = 5, + DNSTAP__MESSAGE__TYPE__CLIENT_RESPONSE = 6, + DNSTAP__MESSAGE__TYPE__FORWARDER_QUERY = 7, + DNSTAP__MESSAGE__TYPE__FORWARDER_RESPONSE = 8, + DNSTAP__MESSAGE__TYPE__STUB_QUERY = 9, + DNSTAP__MESSAGE__TYPE__STUB_RESPONSE = 10 +} Dnstap__Message__Type; +typedef enum _Dnstap__SocketFamily { + DNSTAP__SOCKET_FAMILY__INET = 1, + DNSTAP__SOCKET_FAMILY__INET6 = 2 +} Dnstap__SocketFamily; +typedef enum _Dnstap__SocketProtocol { + DNSTAP__SOCKET_PROTOCOL__UDP = 1, + DNSTAP__SOCKET_PROTOCOL__TCP = 2 +} Dnstap__SocketProtocol; + +/* --- messages --- */ + +struct _Dnstap__Dnstap +{ + ProtobufCMessage base; + protobuf_c_boolean has_identity; + ProtobufCBinaryData identity; + protobuf_c_boolean has_version; + ProtobufCBinaryData version; + protobuf_c_boolean has_extra; + ProtobufCBinaryData extra; + Dnstap__Dnstap__Type type; + Dnstap__Message *message; +}; +#define DNSTAP__DNSTAP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&dnstap__dnstap__descriptor) \ + , 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL}, 0, NULL } + + +struct _Dnstap__Message +{ + ProtobufCMessage base; + Dnstap__Message__Type type; + protobuf_c_boolean has_socket_family; + Dnstap__SocketFamily socket_family; + protobuf_c_boolean has_socket_protocol; + Dnstap__SocketProtocol socket_protocol; + protobuf_c_boolean has_query_address; + ProtobufCBinaryData query_address; + protobuf_c_boolean has_response_address; + ProtobufCBinaryData response_address; + protobuf_c_boolean has_query_port; + uint32_t query_port; + protobuf_c_boolean has_response_port; + uint32_t response_port; + protobuf_c_boolean has_query_time_sec; + uint64_t query_time_sec; + protobuf_c_boolean has_query_time_nsec; + uint32_t query_time_nsec; + protobuf_c_boolean has_query_message; + ProtobufCBinaryData query_message; + protobuf_c_boolean has_query_zone; + ProtobufCBinaryData query_zone; + protobuf_c_boolean has_response_time_sec; + uint64_t response_time_sec; + protobuf_c_boolean has_response_time_nsec; + uint32_t response_time_nsec; + protobuf_c_boolean has_response_message; + ProtobufCBinaryData response_message; +}; +#define DNSTAP__MESSAGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&dnstap__message__descriptor) \ + , 0, 0,0, 0,0, 0,{0,NULL}, 0,{0,NULL}, 0,0, 0,0, 0,0, 0,0, 0,{0,NULL}, 0,{0,NULL}, 0,0, 0,0, 0,{0,NULL} } + + +/* Dnstap__Dnstap methods */ +void dnstap__dnstap__init + (Dnstap__Dnstap *message); +size_t dnstap__dnstap__get_packed_size + (const Dnstap__Dnstap *message); +size_t dnstap__dnstap__pack + (const Dnstap__Dnstap *message, + uint8_t *out); +size_t dnstap__dnstap__pack_to_buffer + (const Dnstap__Dnstap *message, + ProtobufCBuffer *buffer); +Dnstap__Dnstap * + dnstap__dnstap__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void dnstap__dnstap__free_unpacked + (Dnstap__Dnstap *message, + ProtobufCAllocator *allocator); +/* Dnstap__Message methods */ +void dnstap__message__init + (Dnstap__Message *message); +size_t dnstap__message__get_packed_size + (const Dnstap__Message *message); +size_t dnstap__message__pack + (const Dnstap__Message *message, + uint8_t *out); +size_t dnstap__message__pack_to_buffer + (const Dnstap__Message *message, + ProtobufCBuffer *buffer); +Dnstap__Message * + dnstap__message__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void dnstap__message__free_unpacked + (Dnstap__Message *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Dnstap__Dnstap_Closure) + (const Dnstap__Dnstap *message, + void *closure_data); +typedef void (*Dnstap__Message_Closure) + (const Dnstap__Message *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor dnstap__socket_family__descriptor; +extern const ProtobufCEnumDescriptor dnstap__socket_protocol__descriptor; +extern const ProtobufCMessageDescriptor dnstap__dnstap__descriptor; +extern const ProtobufCEnumDescriptor dnstap__dnstap__type__descriptor; +extern const ProtobufCMessageDescriptor dnstap__message__descriptor; +extern const ProtobufCEnumDescriptor dnstap__message__type__descriptor; + +PROTOBUF_C_END_DECLS + + +#endif /* PROTOBUF_dnstap_2fdnstap_2eproto__INCLUDED */ diff --git a/dnstap/dnstap.proto b/dnstap/dnstap.proto new file mode 100644 index 000000000..3504d99ed --- /dev/null +++ b/dnstap/dnstap.proto @@ -0,0 +1,262 @@ +// dnstap: flexible, structured event replication format for DNS software +// +// This file contains the protobuf schemas for the "dnstap" structured event +// replication format for DNS software. + +// Written in 2013-2014 by Farsight Security, Inc. +// +// To the extent possible under law, the author(s) have dedicated all +// copyright and related and neighboring rights to this file to the public +// domain worldwide. This file is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this file. If not, see: +// +// . + +package dnstap; + +// "Dnstap": this is the top-level dnstap type, which is a "union" type that +// contains other kinds of dnstap payloads, although currently only one type +// of dnstap payload is defined. +// See: https://developers.google.com/protocol-buffers/docs/techniques#union +message Dnstap { + // DNS server identity. + // If enabled, this is the identity string of the DNS server which generated + // this message. Typically this would be the same string as returned by an + // "NSID" (RFC 5001) query. + optional bytes identity = 1; + + // DNS server version. + // If enabled, this is the version string of the DNS server which generated + // this message. Typically this would be the same string as returned by a + // "version.bind" query. + optional bytes version = 2; + + // Extra data for this payload. + // This field can be used for adding an arbitrary byte-string annotation to + // the payload. No encoding or interpretation is applied or enforced. + optional bytes extra = 3; + + // Identifies which field below is filled in. + enum Type { + MESSAGE = 1; + } + required Type type = 15; + + // One of the following will be filled in. + optional Message message = 14; +} + +// SocketFamily: the network protocol family of a socket. This specifies how +// to interpret "network address" fields. +enum SocketFamily { + INET = 1; // IPv4 (RFC 791) + INET6 = 2; // IPv6 (RFC 2460) +} + +// SocketProtocol: the transport protocol of a socket. This specifies how to +// interpret "transport port" fields. +enum SocketProtocol { + UDP = 1; // User Datagram Protocol (RFC 768) + TCP = 2; // Transmission Control Protocol (RFC 793) +} + +// Message: a wire-format (RFC 1035 section 4) DNS message and associated +// metadata. Applications generating "Message" payloads should follow +// certain requirements based on the MessageType, see below. +message Message { + + // There are eight types of "Message" defined that correspond to the + // four arrows in the following diagram, slightly modified from RFC 1035 + // section 2: + + // +---------+ +----------+ +--------+ + // | | query | | query | | + // | Stub |-SQ--------CQ->| Recursive|-RQ----AQ->| Auth. | + // | Resolver| | Server | | Name | + // | |<-SR--------CR-| |<-RR----AR-| Server | + // +---------+ response | | response | | + // +----------+ +--------+ + + // Each arrow has two Type values each, one for each "end" of each arrow, + // because these are considered to be distinct events. Each end of each + // arrow on the diagram above has been marked with a two-letter Type + // mnemonic. Clockwise from upper left, these mnemonic values are: + // + // SQ: STUB_QUERY + // CQ: CLIENT_QUERY + // RQ: RESOLVER_QUERY + // AQ: AUTH_QUERY + // AR: AUTH_RESPONSE + // RR: RESOLVER_RESPONSE + // CR: CLIENT_RESPONSE + // SR: STUB_RESPONSE + + // Two additional types of "Message" have been defined for the + // "forwarding" case where an upstream DNS server is responsible for + // further recursion. These are not shown on the diagram above, but have + // the following mnemonic values: + + // FQ: FORWARDER_QUERY + // FR: FORWARDER_RESPONSE + + // The "Message" Type values are defined below. + + enum Type { + // AUTH_QUERY is a DNS query message received from a resolver by an + // authoritative name server, from the perspective of the authorative + // name server. + AUTH_QUERY = 1; + + // AUTH_RESPONSE is a DNS response message sent from an authoritative + // name server to a resolver, from the perspective of the authoritative + // name server. + AUTH_RESPONSE = 2; + + // RESOLVER_QUERY is a DNS query message sent from a resolver to an + // authoritative name server, from the perspective of the resolver. + // Resolvers typically clear the RD (recursion desired) bit when + // sending queries. + RESOLVER_QUERY = 3; + + // RESOLVER_RESPONSE is a DNS response message received from an + // authoritative name server by a resolver, from the perspective of + // the resolver. + RESOLVER_RESPONSE = 4; + + // CLIENT_QUERY is a DNS query message sent from a client to a DNS + // server which is expected to perform further recursion, from the + // perspective of the DNS server. The client may be a stub resolver or + // forwarder or some other type of software which typically sets the RD + // (recursion desired) bit when querying the DNS server. The DNS server + // may be a simple forwarding proxy or it may be a full recursive + // resolver. + CLIENT_QUERY = 5; + + // CLIENT_RESPONSE is a DNS response message sent from a DNS server to + // a client, from the perspective of the DNS server. The DNS server + // typically sets the RA (recursion available) bit when responding. + CLIENT_RESPONSE = 6; + + // FORWARDER_QUERY is a DNS query message sent from a downstream DNS + // server to an upstream DNS server which is expected to perform + // further recursion, from the perspective of the downstream DNS + // server. + FORWARDER_QUERY = 7; + + // FORWARDER_RESPONSE is a DNS response message sent from an upstream + // DNS server performing recursion to a downstream DNS server, from the + // perspective of the downstream DNS server. + FORWARDER_RESPONSE = 8; + + // STUB_QUERY is a DNS query message sent from a stub resolver to a DNS + // server, from the perspective of the stub resolver. + STUB_QUERY = 9; + + // STUB_RESPONSE is a DNS response message sent from a DNS server to a + // stub resolver, from the perspective of the stub resolver. + STUB_RESPONSE = 10; + } + + // One of the Type values described above. + required Type type = 1; + + // One of the SocketFamily values described above. + optional SocketFamily socket_family = 2; + + // One of the SocketProtocol values described above. + optional SocketProtocol socket_protocol = 3; + + // The network address of the message initiator. + // For SocketFamily INET, this field is 4 octets (IPv4 address). + // For SocketFamily INET6, this field is 16 octets (IPv6 address). + optional bytes query_address = 4; + + // The network address of the message responder. + // For SocketFamily INET, this field is 4 octets (IPv4 address). + // For SocketFamily INET6, this field is 16 octets (IPv6 address). + optional bytes response_address = 5; + + // The transport port of the message initiator. + // This is a 16-bit UDP or TCP port number, depending on SocketProtocol. + optional uint32 query_port = 6; + + // The transport port of the message responder. + // This is a 16-bit UDP or TCP port number, depending on SocketProtocol. + optional uint32 response_port = 7; + + // The time at which the DNS query message was sent or received, depending + // on whether this is an AUTH_QUERY, RESOLVER_QUERY, or CLIENT_QUERY. + // This is the number of seconds since the UNIX epoch. + optional uint64 query_time_sec = 8; + + // The time at which the DNS query message was sent or received. + // This is the seconds fraction, expressed as a count of nanoseconds. + optional fixed32 query_time_nsec = 9; + + // The initiator's original wire-format DNS query message, verbatim. + optional bytes query_message = 10; + + // The "zone" or "bailiwick" pertaining to the DNS query message. + // This is a wire-format DNS domain name. + optional bytes query_zone = 11; + + // The time at which the DNS response message was sent or received, + // depending on whether this is an AUTH_RESPONSE, RESOLVER_RESPONSE, or + // CLIENT_RESPONSE. + // This is the number of seconds since the UNIX epoch. + optional uint64 response_time_sec = 12; + + // The time at which the DNS response message was sent or received. + // This is the seconds fraction, expressed as a count of nanoseconds. + optional fixed32 response_time_nsec = 13; + + // The responder's original wire-format DNS response message, verbatim. + optional bytes response_message = 14; +} + +// All fields except for 'type' in the Message schema are optional. +// It is recommended that at least the following fields be filled in for +// particular types of Messages. + +// AUTH_QUERY: +// socket_family, socket_protocol +// query_address, query_port +// query_message +// query_time_sec, query_time_nsec + +// AUTH_RESPONSE: +// socket_family, socket_protocol +// query_address, query_port +// query_time_sec, query_time_nsec +// response_message +// response_time_sec, response_time_nsec + +// RESOLVER_QUERY: +// socket_family, socket_protocol +// query_name, query_type, query_class +// query_message +// query_time_sec, query_time_nsec +// query_zone +// response_address, response_port + +// RESOLVER_RESPONSE: +// socket_family, socket_protocol +// query_name, query_type, query_class +// query_time_sec, query_time_nsec +// query_zone +// response_address, response_port +// response_message +// response_time_sec, response_time_nsec + +// CLIENT_QUERY: +// socket_family, socket_protocol +// query_message +// query_time_sec, query_time_nsec + +// CLIENT_RESPONSE: +// socket_family, socket_protocol +// query_time_sec, query_time_nsec +// response_message +// response_time_sec, response_time_nsec diff --git a/dnstap/dnstap_config.h b/dnstap/dnstap_config.h new file mode 100644 index 000000000..58fb7e695 --- /dev/null +++ b/dnstap/dnstap_config.h @@ -0,0 +1,17 @@ +#ifndef UNBOUND_DNSTAP_CONFIG_H +#define UNBOUND_DNSTAP_CONFIG_H + +/* + * Process this file (dnstap_config.h.in) with AC_CONFIG_FILES to generate + * dnstap_config.h. + * + * This file exists so that USE_DNSTAP can be used without including config.h. + */ + +#if 1 /* ENABLE_DNSTAP */ +# ifndef USE_DNSTAP +# define USE_DNSTAP 1 +# endif +#endif + +#endif /* UNBOUND_DNSTAP_CONFIG_H */ diff --git a/dnstap/dnstap_config.h.in b/dnstap/dnstap_config.h.in new file mode 100644 index 000000000..c9f74893a --- /dev/null +++ b/dnstap/dnstap_config.h.in @@ -0,0 +1,17 @@ +#ifndef UNBOUND_DNSTAP_CONFIG_H +#define UNBOUND_DNSTAP_CONFIG_H + +/* + * Process this file (dnstap_config.h.in) with AC_CONFIG_FILES to generate + * dnstap_config.h. + * + * This file exists so that USE_DNSTAP can be used without including config.h. + */ + +#if @ENABLE_DNSTAP@ /* ENABLE_DNSTAP */ +# ifndef USE_DNSTAP +# define USE_DNSTAP 1 +# endif +#endif + +#endif /* UNBOUND_DNSTAP_CONFIG_H */ diff --git a/doc/CREDITS b/doc/CREDITS index e47332169..805327ad6 100644 --- a/doc/CREDITS +++ b/doc/CREDITS @@ -20,3 +20,4 @@ Luca Bruno - patch for windows support in libunbound hosts and resolvconf(). Tom Hendrikx - contributed split-itar.sh a useful script to 5011-track ITAR. Daisuke HIGASHI - patch for rrset-roundrobin and minimal-responses. Simon Perrault - DNS64 module. +Robert Edmonds - dnstap code. diff --git a/doc/Changelog b/doc/Changelog index 78b23d20d..7c526e9cf 100644 --- a/doc/Changelog +++ b/doc/Changelog @@ -1,3 +1,10 @@ +5 August 2014: Wouter + - dnstap support, with a patch from Farsight Security, written by + Robert Edmonds. The --enable-dnstap needs libfstrm and protobuf-c. + It is BSD licensed (see dnstap/dnstap.c). + Building with --enable-dnstap needs pkg-config with this patch. + - Noted dnstap in doc/README and doc/CREDITS. + 1 August 2014: Wouter - Patch add msg, rrset, infra and key cache sizes to stats command from Maciej Soltysiak. diff --git a/doc/README b/doc/README index 80366e549..1ae9f4f45 100644 --- a/doc/README +++ b/doc/README @@ -4,6 +4,7 @@ http://unbound.net This software is under BSD license, see LICENSE for details. The DNS64 module has BSD license in dns64/dns64.c. +The DNSTAP code has BSD license in dnstap/dnstap.c. * Download the latest release version of this software from http://unbound.net diff --git a/libunbound/libworker.c b/libunbound/libworker.c index c5807f062..e388e7956 100644 --- a/libunbound/libworker.c +++ b/libunbound/libworker.c @@ -233,7 +233,7 @@ libworker_setup(struct ub_ctx* ctx, int is_bg, struct event_base* eb) w->env->infra_cache, w->env->rnd, cfg->use_caps_bits_for_id, ports, numports, cfg->unwanted_threshold, &libworker_alloc_cleanup, w, cfg->do_udp, w->sslctx, - cfg->delay_close); + cfg->delay_close, NULL); if(!w->is_bg || w->is_bg_thread) { lock_basic_unlock(&ctx->cfglock); } diff --git a/pkg.m4 b/pkg.m4 new file mode 100644 index 000000000..9a71878c2 --- /dev/null +++ b/pkg.m4 @@ -0,0 +1,159 @@ +# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- +# serial 1 (pkg-config-0.24) +# +# Copyright © 2004 Scott James Remnant . +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# PKG_PROG_PKG_CONFIG([MIN-VERSION]) +# ---------------------------------- +AC_DEFUN([PKG_PROG_PKG_CONFIG], +[m4_pattern_forbid([^_?PKG_[A-Z_]+$]) +m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$]) +m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$]) +AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility]) +AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path]) +AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path]) + +if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then + AC_PATH_TOOL([PKG_CONFIG], [pkg-config]) +fi +if test -n "$PKG_CONFIG"; then + _pkg_min_version=m4_default([$1], [0.9.0]) + AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version]) + if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + PKG_CONFIG="" + fi +fi[]dnl +])# PKG_PROG_PKG_CONFIG + +# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# +# Check to see whether a particular set of modules exists. Similar +# to PKG_CHECK_MODULES(), but does not set variables or print errors. +# +# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG]) +# only at the first occurence in configure.ac, so if the first place +# it's called might be skipped (such as if it is within an "if", you +# have to call PKG_CHECK_EXISTS manually +# -------------------------------------------------------------- +AC_DEFUN([PKG_CHECK_EXISTS], +[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl +if test -n "$PKG_CONFIG" && \ + AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then + m4_default([$2], [:]) +m4_ifvaln([$3], [else + $3])dnl +fi]) + +# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES]) +# --------------------------------------------- +m4_define([_PKG_CONFIG], +[if test -n "$$1"; then + pkg_cv_[]$1="$$1" + elif test -n "$PKG_CONFIG"; then + PKG_CHECK_EXISTS([$3], + [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null` + test "x$?" != "x0" && pkg_failed=yes ], + [pkg_failed=yes]) + else + pkg_failed=untried +fi[]dnl +])# _PKG_CONFIG + +# _PKG_SHORT_ERRORS_SUPPORTED +# ----------------------------- +AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED], +[AC_REQUIRE([PKG_PROG_PKG_CONFIG]) +if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then + _pkg_short_errors_supported=yes +else + _pkg_short_errors_supported=no +fi[]dnl +])# _PKG_SHORT_ERRORS_SUPPORTED + + +# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], +# [ACTION-IF-NOT-FOUND]) +# +# +# Note that if there is a possibility the first call to +# PKG_CHECK_MODULES might not happen, you should be sure to include an +# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac +# +# +# -------------------------------------------------------------- +AC_DEFUN([PKG_CHECK_MODULES], +[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl +AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl +AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl + +pkg_failed=no +AC_MSG_CHECKING([for $1]) + +_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2]) +_PKG_CONFIG([$1][_LIBS], [libs], [$2]) + +m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS +and $1[]_LIBS to avoid the need to call pkg-config. +See the pkg-config man page for more details.]) + +if test $pkg_failed = yes; then + AC_MSG_RESULT([no]) + _PKG_SHORT_ERRORS_SUPPORTED + if test $_pkg_short_errors_supported = yes; then + $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1` + else + $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1` + fi + # Put the nasty error message in config.log where it belongs + echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD + + m4_default([$4], [AC_MSG_ERROR( +[Package requirements ($2) were not met: + +$$1_PKG_ERRORS + +Consider adjusting the PKG_CONFIG_PATH environment variable if you +installed software in a non-standard prefix. + +_PKG_TEXT])[]dnl + ]) +elif test $pkg_failed = untried; then + AC_MSG_RESULT([no]) + m4_default([$4], [AC_MSG_FAILURE( +[The pkg-config script could not be found or is too old. Make sure it +is in your PATH or set the PKG_CONFIG environment variable to the full +path to pkg-config. + +_PKG_TEXT + +To get pkg-config, see .])[]dnl + ]) +else + $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS + $1[]_LIBS=$pkg_cv_[]$1[]_LIBS + AC_MSG_RESULT([yes]) + $3 +fi[]dnl +])# PKG_CHECK_MODULES diff --git a/services/listen_dnsport.c b/services/listen_dnsport.c index e1d5f8b6f..b339eaac0 100644 --- a/services/listen_dnsport.c +++ b/services/listen_dnsport.c @@ -848,7 +848,7 @@ listen_cp_insert(struct comm_point* c, struct listen_dnsport* front) struct listen_dnsport* listen_create(struct comm_base* base, struct listen_port* ports, size_t bufsize, int tcp_accept_count, void* sslctx, - comm_point_callback_t* cb, void *cb_arg) + struct dt_env* dtenv, comm_point_callback_t* cb, void *cb_arg) { struct listen_dnsport* front = (struct listen_dnsport*) malloc(sizeof(struct listen_dnsport)); @@ -882,6 +882,7 @@ listen_create(struct comm_base* base, struct listen_port* ports, listen_delete(front); return NULL; } + cp->dtenv = dtenv; cp->do_not_close = 1; if(!listen_cp_insert(cp, front)) { log_err("malloc failed"); diff --git a/services/listen_dnsport.h b/services/listen_dnsport.h index 61fb9a0b4..075f6d281 100644 --- a/services/listen_dnsport.h +++ b/services/listen_dnsport.h @@ -129,6 +129,7 @@ void listening_ports_free(struct listen_port* list); * @param tcp_accept_count: max number of simultaneous TCP connections * from clients. * @param sslctx: nonNULL if ssl context. + * @param dtenv: nonNULL if dnstap enabled. * @param cb: callback function when a request arrives. It is passed * the packet and user argument. Return true to send a reply. * @param cb_arg: user data argument for callback function. @@ -136,7 +137,8 @@ void listening_ports_free(struct listen_port* list); */ struct listen_dnsport* listen_create(struct comm_base* base, struct listen_port* ports, size_t bufsize, int tcp_accept_count, - void* sslctx, comm_point_callback_t* cb, void* cb_arg); + void* sslctx, struct dt_env *dtenv, comm_point_callback_t* cb, + void* cb_arg); /** * delete the listening structure diff --git a/services/outside_network.c b/services/outside_network.c index a2083db24..1afb26ee5 100644 --- a/services/outside_network.c +++ b/services/outside_network.c @@ -58,6 +58,7 @@ #include "util/random.h" #include "util/fptr_wlist.h" #include "ldns/sbuffer.h" +#include "dnstap/dnstap.h" #ifdef HAVE_OPENSSL_SSL_H #include #endif @@ -75,11 +76,10 @@ #define OUTBOUND_UDP_RETRY 1 /** initiate TCP transaction for serviced query */ -static void serviced_tcp_initiate(struct outside_network* outnet, - struct serviced_query* sq, sldns_buffer* buff); +static void serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff); /** with a fd available, randomize and send UDP */ -static int randomize_and_send_udp(struct outside_network* outnet, - struct pending* pend, sldns_buffer* packet, int timeout); +static int randomize_and_send_udp(struct pending* pend, sldns_buffer* packet, + int timeout); int pending_cmp(const void* key1, const void* key2) @@ -378,7 +378,7 @@ outnet_send_wait_udp(struct outside_network* outnet) free(pend->pkt); /* freeing now makes get_mem correct */ pend->pkt = NULL; pend->pkt_len = 0; - if(!randomize_and_send_udp(outnet, pend, outnet->udp_buff, + if(!randomize_and_send_udp(pend, outnet->udp_buff, pend->timeout)) { /* callback error on pending */ if(pend->cb) { @@ -588,7 +588,7 @@ outside_network_create(struct comm_base *base, size_t bufsize, struct ub_randstate* rnd, int use_caps_for_id, int* availports, int numavailports, size_t unwanted_threshold, void (*unwanted_action)(void*), void* unwanted_param, int do_udp, - void* sslctx, int delayclose) + void* sslctx, int delayclose, struct dt_env* dtenv) { struct outside_network* outnet = (struct outside_network*) calloc(1, sizeof(struct outside_network)); @@ -604,6 +604,9 @@ outside_network_create(struct comm_base *base, size_t bufsize, outnet->infra = infra; outnet->rnd = rnd; outnet->sslctx = sslctx; +#ifdef USE_DNSTAP + outnet->dtenv = dtenv; +#endif outnet->svcd_overhead = 0; outnet->want_to_quit = 0; outnet->unwanted_threshold = unwanted_threshold; @@ -992,10 +995,10 @@ select_ifport(struct outside_network* outnet, struct pending* pend, } static int -randomize_and_send_udp(struct outside_network* outnet, struct pending* pend, - sldns_buffer* packet, int timeout) +randomize_and_send_udp(struct pending* pend, sldns_buffer* packet, int timeout) { struct timeval tv; + struct outside_network* outnet = pend->sq->outnet; /* select id */ if(!select_id(outnet, pend, packet)) { @@ -1028,30 +1031,38 @@ randomize_and_send_udp(struct outside_network* outnet, struct pending* pend, tv.tv_usec = (timeout%1000)*1000; #endif comm_timer_set(pend->timer, &tv); + +#ifdef USE_DNSTAP + if(outnet->dtenv && + (outnet->dtenv->log_resolver_query_messages || + outnet->dtenv->log_forwarder_query_messages)) + dt_msg_send_outside_query(outnet->dtenv, &pend->addr, comm_udp, + pend->sq->zone, pend->sq->zonelen, packet); +#endif return 1; } struct pending* -pending_udp_query(struct outside_network* outnet, sldns_buffer* packet, - struct sockaddr_storage* addr, socklen_t addrlen, int timeout, - comm_point_callback_t* cb, void* cb_arg) +pending_udp_query(struct serviced_query* sq, struct sldns_buffer* packet, + int timeout, comm_point_callback_t* cb, void* cb_arg) { struct pending* pend = (struct pending*)calloc(1, sizeof(*pend)); if(!pend) return NULL; - pend->outnet = outnet; - pend->addrlen = addrlen; - memmove(&pend->addr, addr, addrlen); + pend->outnet = sq->outnet; + pend->sq = sq; + pend->addrlen = sq->addrlen; + memmove(&pend->addr, &sq->addr, sq->addrlen); pend->cb = cb; pend->cb_arg = cb_arg; pend->node.key = pend; - pend->timer = comm_timer_create(outnet->base, pending_udp_timer_cb, + pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb, pend); if(!pend->timer) { free(pend); return NULL; } - if(outnet->unused_fds == NULL) { + if(sq->outnet->unused_fds == NULL) { /* no unused fd, cannot create a new port (randomly) */ verbose(VERB_ALGO, "no fds available, udp query waiting"); pend->timeout = timeout; @@ -1064,15 +1075,15 @@ pending_udp_query(struct outside_network* outnet, sldns_buffer* packet, return NULL; } /* put at end of waiting list */ - if(outnet->udp_wait_last) - outnet->udp_wait_last->next_waiting = pend; + if(sq->outnet->udp_wait_last) + sq->outnet->udp_wait_last->next_waiting = pend; else - outnet->udp_wait_first = pend; - outnet->udp_wait_last = pend; + sq->outnet->udp_wait_first = pend; + sq->outnet->udp_wait_last = pend; return pend; } - if(!randomize_and_send_udp(outnet, pend, packet, timeout)) { - pending_delete(outnet, pend); + if(!randomize_and_send_udp(pend, packet, timeout)) { + pending_delete(sq->outnet, pend); return NULL; } return pend; @@ -1114,12 +1125,11 @@ outnet_tcptimer(void* arg) use_free_buffer(outnet); } -struct waiting_tcp* -pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet, - struct sockaddr_storage* addr, socklen_t addrlen, int timeout, - comm_point_callback_t* callback, void* callback_arg, int ssl_upstream) +struct waiting_tcp* +pending_tcp_query(struct serviced_query* sq, sldns_buffer* packet, + int timeout, comm_point_callback_t* callback, void* callback_arg) { - struct pending_tcp* pend = outnet->tcp_free; + struct pending_tcp* pend = sq->outnet->tcp_free; struct waiting_tcp* w; struct timeval tv; uint16_t id; @@ -1129,20 +1139,20 @@ pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet, if(!w) { return NULL; } - if(!(w->timer = comm_timer_create(outnet->base, outnet_tcptimer, w))) { + if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) { free(w); return NULL; } w->pkt = NULL; w->pkt_len = 0; - id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff; + id = ((unsigned)ub_random(sq->outnet->rnd)>>8) & 0xffff; LDNS_ID_SET(sldns_buffer_begin(packet), id); - memcpy(&w->addr, addr, addrlen); - w->addrlen = addrlen; - w->outnet = outnet; + memcpy(&w->addr, &sq->addr, sq->addrlen); + w->addrlen = sq->addrlen; + w->outnet = sq->outnet; w->cb = callback; w->cb_arg = callback_arg; - w->ssl_upstream = ssl_upstream; + w->ssl_upstream = sq->ssl_upstream; #ifndef S_SPLINT_S tv.tv_sec = timeout; tv.tv_usec = 0; @@ -1155,16 +1165,23 @@ pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet, waiting_tcp_delete(w); return NULL; } +#ifdef USE_DNSTAP + if(sq->outnet->dtenv && + (sq->outnet->dtenv->log_resolver_query_messages || + sq->outnet->dtenv->log_forwarder_query_messages)) + dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr, + comm_tcp, sq->zone, sq->zonelen, packet); +#endif } else { /* queue up */ w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp); w->pkt_len = sldns_buffer_limit(packet); memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len); w->next_waiting = NULL; - if(outnet->tcp_wait_last) - outnet->tcp_wait_last->next_waiting = w; - else outnet->tcp_wait_first = w; - outnet->tcp_wait_last = w; + if(sq->outnet->tcp_wait_last) + sq->outnet->tcp_wait_last->next_waiting = w; + else sq->outnet->tcp_wait_first = w; + sq->outnet->tcp_wait_last = w; } return w; } @@ -1426,8 +1443,8 @@ serviced_udp_send(struct serviced_query* sq, sldns_buffer* buff) sq->last_sent_time = *sq->outnet->now_tv; sq->edns_lame_known = (int)edns_lame_known; verbose(VERB_ALGO, "serviced query UDP timeout=%d msec", rtt); - sq->pending = pending_udp_query(sq->outnet, buff, &sq->addr, - sq->addrlen, rtt, serviced_udp_callback, sq); + sq->pending = pending_udp_query(sq, buff, rtt, + serviced_udp_callback, sq); if(!sq->pending) return 0; return 1; @@ -1576,13 +1593,21 @@ serviced_tcp_callback(struct comm_point* c, void* arg, int error, if(error==NETEVENT_NOERROR) infra_update_tcp_works(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone, sq->zonelen); +#ifdef USE_DNSTAP + if(sq->outnet->dtenv && + (sq->outnet->dtenv->log_resolver_response_messages || + sq->outnet->dtenv->log_forwarder_response_messages)) + dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr, + c->type, sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen, + &sq->last_sent_time, sq->outnet->now_tv, c->buffer); +#endif if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS && (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) == LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin( c->buffer)) == LDNS_RCODE_NOTIMPL) ) { /* attempt to fallback to nonEDNS */ sq->status = serviced_query_TCP_EDNS_fallback; - serviced_tcp_initiate(sq->outnet, sq, c->buffer); + serviced_tcp_initiate(sq, c->buffer); return 0; } else if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS_fallback && @@ -1634,16 +1659,14 @@ serviced_tcp_callback(struct comm_point* c, void* arg, int error, } static void -serviced_tcp_initiate(struct outside_network* outnet, - struct serviced_query* sq, sldns_buffer* buff) +serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff) { verbose(VERB_ALGO, "initiate TCP query %s", sq->status==serviced_query_TCP_EDNS?"EDNS":""); serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS); sq->last_sent_time = *sq->outnet->now_tv; - sq->pending = pending_tcp_query(outnet, buff, &sq->addr, - sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback, - sq, sq->ssl_upstream); + sq->pending = pending_tcp_query(sq, buff, TCP_AUTH_QUERY_TIMEOUT, + serviced_tcp_callback, sq); if(!sq->pending) { /* delete from tree so that a retry by above layer does not * clash with this entry */ @@ -1667,9 +1690,8 @@ serviced_tcp_send(struct serviced_query* sq, sldns_buffer* buff) else sq->status = serviced_query_TCP; serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS); sq->last_sent_time = *sq->outnet->now_tv; - sq->pending = pending_tcp_query(sq->outnet, buff, &sq->addr, - sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback, - sq, sq->ssl_upstream); + sq->pending = pending_tcp_query(sq, buff, TCP_AUTH_QUERY_TIMEOUT, + serviced_tcp_callback, sq); return sq->pending != NULL; } @@ -1730,6 +1752,14 @@ serviced_udp_callback(struct comm_point* c, void* arg, int error, serviced_callbacks(sq, error, c, rep); return 0; } +#ifdef USE_DNSTAP + if(outnet->dtenv && + (outnet->dtenv->log_resolver_response_messages || + outnet->dtenv->log_forwarder_response_messages)) + dt_msg_send_outside_response(outnet->dtenv, &sq->addr, c->type, + sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen, + &sq->last_sent_time, sq->outnet->now_tv, c->buffer); +#endif if(!fallback_tcp) { if( (sq->status == serviced_query_UDP_EDNS ||sq->status == serviced_query_UDP_EDNS_FRAG) @@ -1818,7 +1848,7 @@ serviced_udp_callback(struct comm_point* c, void* arg, int error, /* if we have unfinished EDNS_fallback, start again */ sq->status = serviced_query_TCP_EDNS; else sq->status = serviced_query_TCP; - serviced_tcp_initiate(outnet, sq, c->buffer); + serviced_tcp_initiate(sq, c->buffer); return 0; } /* yay! an answer */ diff --git a/services/outside_network.h b/services/outside_network.h index b9124b57f..9959676d3 100644 --- a/services/outside_network.h +++ b/services/outside_network.h @@ -45,6 +45,7 @@ #include "util/rbtree.h" #include "util/netevent.h" +#include "dnstap/dnstap_config.h" struct pending; struct pending_timeout; struct ub_randstate; @@ -55,6 +56,8 @@ struct infra_cache; struct port_comm; struct port_if; struct sldns_buffer; +struct serviced_query; +struct dt_env; /** * Send queries to outside servers and wait for answers from servers. @@ -125,6 +128,10 @@ struct outside_network { struct ub_randstate* rnd; /** ssl context to create ssl wrapped TCP with DNS connections */ void* sslctx; +#ifdef USE_DNSTAP + /** dnstap environment */ + struct dt_env* dtenv; +#endif /** * Array of tcp pending used for outgoing TCP connections. @@ -212,6 +219,8 @@ struct pending { void* cb_arg; /** the outside network it is part of */ struct outside_network* outnet; + /** the corresponding serviced_query */ + struct serviced_query* sq; /*---- filled if udp pending is waiting -----*/ /** next in waiting list. */ @@ -387,6 +396,7 @@ struct serviced_query { * @param sslctx: context to create outgoing connections with (if enabled). * @param delayclose: if not 0, udp sockets are delayed before timeout closure. * msec to wait on timeouted udp sockets. + * @param dtenv: environment to send dnstap events with (if enabled). * @return: the new structure (with no pending answers) or NULL on error. */ struct outside_network* outside_network_create(struct comm_base* base, @@ -395,7 +405,7 @@ struct outside_network* outside_network_create(struct comm_base* base, struct ub_randstate* rnd, int use_caps_for_id, int* availports, int numavailports, size_t unwanted_threshold, void (*unwanted_action)(void*), void* unwanted_param, int do_udp, - void* sslctx, int delayclose); + void* sslctx, int delayclose, struct dt_env *dtenv); /** * Delete outside_network structure. @@ -412,39 +422,32 @@ void outside_network_quit_prepare(struct outside_network* outnet); /** * Send UDP query, create pending answer. * Changes the ID for the query to be random and unique for that destination. - * @param outnet: provides the event handling + * @param sq: serviced query. * @param packet: wireformat query to send to destination. - * @param addr: address to send to. - * @param addrlen: length of addr. * @param timeout: in milliseconds from now. * @param callback: function to call on error, timeout or reply. * @param callback_arg: user argument for callback function. * @return: NULL on error for malloc or socket. Else the pending query object. */ -struct pending* pending_udp_query(struct outside_network* outnet, - struct sldns_buffer* packet, struct sockaddr_storage* addr, - socklen_t addrlen, int timeout, comm_point_callback_t* callback, +struct pending* pending_udp_query(struct serviced_query* sq, + struct sldns_buffer* packet, int timeout, comm_point_callback_t* callback, void* callback_arg); /** * Send TCP query. May wait for TCP buffer. Selects ID to be random, and * checks id. - * @param outnet: provides the event handling. + * @param sq: serviced query. * @param packet: wireformat query to send to destination. copied from. - * @param addr: address to send to. - * @param addrlen: length of addr. * @param timeout: in seconds from now. * Timer starts running now. Timer may expire if all buffers are used, * without any query been sent to the server yet. * @param callback: function to call on error, timeout or reply. * @param callback_arg: user argument for callback function. - * @param ssl_upstream: if the tcp connection must use SSL. * @return: false on error for malloc or socket. Else the pending TCP object. */ -struct waiting_tcp* pending_tcp_query(struct outside_network* outnet, - struct sldns_buffer* packet, struct sockaddr_storage* addr, - socklen_t addrlen, int timeout, comm_point_callback_t* callback, - void* callback_arg, int ssl_upstream); +struct waiting_tcp* pending_tcp_query(struct serviced_query* sq, + struct sldns_buffer* packet, int timeout, comm_point_callback_t* callback, + void* callback_arg); /** * Delete pending answer. diff --git a/testcode/fake_event.c b/testcode/fake_event.c index 83ac805d5..de453aaa2 100644 --- a/testcode/fake_event.c +++ b/testcode/fake_event.c @@ -734,7 +734,8 @@ run_scenario(struct replay_runtime* runtime) struct listen_dnsport* listen_create(struct comm_base* base, struct listen_port* ATTR_UNUSED(ports), size_t bufsize, int ATTR_UNUSED(tcp_accept_count), - void* ATTR_UNUSED(sslctx), comm_point_callback_t* cb, void* cb_arg) + void* ATTR_UNUSED(sslctx), struct dt_env* ATTR_UNUSED(dtenv), + comm_point_callback_t* cb, void* cb_arg) { struct replay_runtime* runtime = (struct replay_runtime*)base; struct listen_dnsport* l= calloc(1, sizeof(struct listen_dnsport)); @@ -901,7 +902,7 @@ outside_network_create(struct comm_base* base, size_t bufsize, int ATTR_UNUSED(numavailports), size_t ATTR_UNUSED(unwanted_threshold), void (*unwanted_action)(void*), void* ATTR_UNUSED(unwanted_param), int ATTR_UNUSED(do_udp), void* ATTR_UNUSED(sslctx), - int ATTR_UNUSED(delayclose)) + int ATTR_UNUSED(delayclose), struct dt_env* ATTR_UNUSED(dtenv)) { struct replay_runtime* runtime = (struct replay_runtime*)base; struct outside_network* outnet = calloc(1, @@ -934,11 +935,11 @@ outside_network_quit_prepare(struct outside_network* ATTR_UNUSED(outnet)) } struct pending* -pending_udp_query(struct outside_network* outnet, sldns_buffer* packet, - struct sockaddr_storage* addr, socklen_t addrlen, int timeout, - comm_point_callback_t* callback, void* callback_arg) +pending_udp_query(struct serviced_query* sq, sldns_buffer* packet, + int timeout, comm_point_callback_t* callback, void* callback_arg) { - struct replay_runtime* runtime = (struct replay_runtime*)outnet->base; + struct replay_runtime* runtime = (struct replay_runtime*) + sq->outnet->base; struct fake_pending* pend = (struct fake_pending*)calloc(1, sizeof(struct fake_pending)); log_assert(pend); @@ -947,8 +948,8 @@ pending_udp_query(struct outside_network* outnet, sldns_buffer* packet, sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet), sldns_buffer_limit(packet)); sldns_buffer_flip(pend->buffer); - memcpy(&pend->addr, addr, addrlen); - pend->addrlen = addrlen; + memcpy(&pend->addr, &sq->addr, sq->addrlen); + pend->addrlen = sq->addrlen; pend->callback = callback; pend->cb_arg = callback_arg; pend->timeout = timeout/1000; @@ -983,13 +984,12 @@ pending_udp_query(struct outside_network* outnet, sldns_buffer* packet, return (struct pending*)pend; } -struct waiting_tcp* -pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet, - struct sockaddr_storage* addr, socklen_t addrlen, int timeout, - comm_point_callback_t* callback, void* callback_arg, - int ATTR_UNUSED(ssl_upstream)) +struct waiting_tcp* +pending_tcp_query(struct serviced_query* sq, sldns_buffer* packet, + int timeout, comm_point_callback_t* callback, void* callback_arg) { - struct replay_runtime* runtime = (struct replay_runtime*)outnet->base; + struct replay_runtime* runtime = (struct replay_runtime*) + sq->outnet->base; struct fake_pending* pend = (struct fake_pending*)calloc(1, sizeof(struct fake_pending)); log_assert(pend); @@ -998,8 +998,8 @@ pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet, sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet), sldns_buffer_limit(packet)); sldns_buffer_flip(pend->buffer); - memcpy(&pend->addr, addr, addrlen); - pend->addrlen = addrlen; + memcpy(&pend->addr, &sq->addr, sq->addrlen); + pend->addrlen = sq->addrlen; pend->callback = callback; pend->cb_arg = callback_arg; pend->timeout = timeout; diff --git a/util/config_file.c b/util/config_file.c index 79734444f..96ec2f11d 100644 --- a/util/config_file.c +++ b/util/config_file.c @@ -211,6 +211,10 @@ config_create(void) if(!(cfg->module_conf = strdup("validator iterator"))) goto error_exit; if(!(cfg->val_nsec3_key_iterations = strdup("1024 150 2048 500 4096 2500"))) goto error_exit; +#if defined(DNSTAP_SOCKET_PATH) + if(!(cfg->dnstap_socket_path = strdup(DNSTAP_SOCKET_PATH))) + goto error_exit; +#endif return cfg; error_exit: config_delete(cfg); @@ -888,6 +892,9 @@ config_delete(struct config_file* cfg) free(cfg->server_cert_file); free(cfg->control_key_file); free(cfg->control_cert_file); + free(cfg->dnstap_socket_path); + free(cfg->dnstap_identity); + free(cfg->dnstap_version); free(cfg); } diff --git a/util/config_file.h b/util/config_file.h index 6c7ea53c5..49ffbdde4 100644 --- a/util/config_file.h +++ b/util/config_file.h @@ -311,6 +311,32 @@ struct config_file { /* Synthetize all AAAA record despite the presence of an authoritative one */ int dns64_synthall; + + /** true to enable dnstap support */ + int dnstap; + /** dnstap socket path */ + char* dnstap_socket_path; + /** true to send "identity" via dnstap */ + int dnstap_send_identity; + /** true to send "version" via dnstap */ + int dnstap_send_version; + /** dnstap "identity", hostname is used if "". */ + char* dnstap_identity; + /** dnstap "version", package version is used if "". */ + char* dnstap_version; + + /** true to log dnstap RESOLVER_QUERY message events */ + int dnstap_log_resolver_query_messages; + /** true to log dnstap RESOLVER_RESPONSE message events */ + int dnstap_log_resolver_response_messages; + /** true to log dnstap CLIENT_QUERY message events */ + int dnstap_log_client_query_messages; + /** true to log dnstap CLIENT_RESPONSE message events */ + int dnstap_log_client_response_messages; + /** true to log dnstap FORWARDER_QUERY message events */ + int dnstap_log_forwarder_query_messages; + /** true to log dnstap FORWARDER_RESPONSE message events */ + int dnstap_log_forwarder_response_messages; }; /** diff --git a/util/configlexer.c b/util/configlexer.c index fcf3a1f7d..f1336a256 100644 --- a/util/configlexer.c +++ b/util/configlexer.c @@ -363,8 +363,8 @@ static void yy_fatal_error (yyconst char msg[] ); *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 149 -#define YY_END_OF_BUFFER 150 +#define YY_NUM_RULES 162 +#define YY_END_OF_BUFFER 163 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -372,164 +372,185 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[1420] = +static yyconst flex_int16_t yy_accept[1611] = { 0, - 1, 1, 131, 131, 135, 135, 139, 139, 143, 143, - 1, 1, 150, 147, 1, 129, 129, 148, 2, 148, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 131, - 132, 132, 133, 148, 135, 136, 136, 137, 148, 142, - 139, 140, 140, 141, 148, 143, 144, 144, 145, 148, - 146, 130, 2, 134, 148, 146, 147, 0, 1, 2, - 2, 2, 2, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 131, 0, 135, 0, 142, 0, 139, 143, - 0, 146, 0, 2, 2, 146, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 146, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 146, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 65, 147, 147, 147, 147, 147, 6, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 146, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 146, 147, - 147, 147, 147, 29, 147, 147, 147, 147, 147, 147, - 147, 147, 12, 13, 147, 15, 14, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 122, 147, 147, 147, 147, 147, - 3, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 146, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 138, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 32, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 33, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 80, 138, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 79, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 63, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 20, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 30, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 31, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 22, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 26, 147, 27, 147, 147, 147, 66, 147, - 67, 147, 64, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 5, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 82, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 23, 147, - 147, 147, 147, 107, 106, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 34, 147, 147, 147, 147, 147, - 147, 147, 147, 69, 68, 147, 147, 147, 147, 147, - 147, 147, 103, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 50, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 54, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 105, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 4, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 100, 147, 147, - 147, 147, 147, 147, 147, 116, 101, 147, 127, 147, - - 21, 147, 147, 147, 147, 71, 147, 72, 70, 147, - 147, 147, 147, 147, 147, 78, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 102, 147, 147, 147, 147, - 126, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 62, 147, 147, 147, 147, 147, 147, 147, - 147, 28, 147, 147, 17, 147, 147, 147, 16, 147, - 87, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 41, 42, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 73, 147, 147, - 147, 147, 147, 77, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 81, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 121, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 91, 147, 95, - 147, 147, 147, 147, 76, 147, 147, 114, 147, 147, - 147, 128, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 94, 147, 147, 147, 147, 43, 44, 147, - 49, 96, 147, 108, 104, 147, 147, 37, 147, 98, - 147, 147, 147, 147, 147, 7, 147, 61, 113, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 83, 147, 147, 123, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 97, 147, 36, 38, 147, 147, 147, 147, 147, 60, - 147, 147, 147, 147, 117, 18, 19, 147, 147, 147, - 147, 147, 147, 147, 58, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 119, 147, 147, 35, 147, 147, - 147, 147, 147, 147, 11, 147, 147, 147, 147, 147, - 147, 147, 10, 147, 147, 39, 147, 125, 118, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - - 90, 89, 147, 120, 115, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 45, 147, 124, 147, 147, - 147, 147, 40, 147, 147, 147, 84, 86, 109, 147, - 147, 147, 88, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 24, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 112, 147, 147, 147, 147, 147, 147, 147, 25, 147, - 9, 147, 147, 110, 51, 147, 147, 147, 93, 147, - 74, 147, 147, 147, 53, 57, 52, 147, 46, 147, - 8, 147, 147, 92, 147, 147, 147, 56, 147, 47, - - 147, 111, 147, 147, 85, 75, 55, 48, 147, 147, - 147, 147, 59, 147, 147, 147, 147, 99, 0 + 1, 1, 144, 144, 148, 148, 152, 152, 156, 156, + 1, 1, 163, 160, 1, 142, 142, 161, 2, 161, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 144, + 145, 145, 146, 161, 148, 149, 149, 150, 161, 155, + 152, 153, 153, 154, 161, 156, 157, 157, 158, 161, + 159, 143, 2, 147, 161, 159, 160, 0, 1, 2, + 2, 2, 2, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 144, 0, 148, 0, 155, 0, 152, 156, + 0, 159, 0, 2, 2, 159, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 159, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 159, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 160, 160, 65, 160, 160, 160, 160, + 160, 6, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 159, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 159, 160, 160, 160, 160, 29, 160, 160, 160, + 160, 160, 160, 160, 160, 129, 160, 12, 13, 160, + 15, 14, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 122, + 160, 160, 160, 160, 160, 3, 160, 160, 160, 160, + + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 159, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 151, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 32, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 33, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 80, 151, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 79, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 63, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 20, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 30, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 31, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 22, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 160, 26, 160, 27, 160, 160, 160, + 66, 160, 67, 160, 64, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 5, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 82, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 23, 160, 160, 160, + 160, 107, 106, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 34, 160, 160, 160, 160, 160, 160, 160, + 160, 69, 68, 160, 160, 160, 160, 160, 160, 160, + 103, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 50, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 54, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 105, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 4, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 100, 160, 160, 160, 160, 160, 160, + 160, 116, 101, 160, 127, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 21, 160, 160, 160, 160, + 71, 160, 72, 70, 160, 160, 160, 160, 160, 160, + 78, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 102, 160, 160, 160, 160, 126, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 62, 160, 160, + 160, 160, 160, 160, 160, 160, 28, 160, 160, 17, + + 160, 160, 160, 16, 160, 87, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 41, + 42, 160, 160, 160, 160, 160, 160, 130, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 73, 160, 160, 160, 160, 160, 77, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 81, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 121, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 91, 160, 95, 160, 160, 160, 160, 76, 160, + + 160, 114, 160, 160, 160, 128, 160, 160, 160, 160, + 160, 160, 160, 135, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 94, 160, 160, 160, 160, 43, + 44, 160, 49, 96, 160, 108, 104, 160, 160, 37, + 160, 98, 160, 160, 160, 160, 160, 7, 160, 61, + 113, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 83, 134, 160, 160, + 160, 160, 160, 160, 160, 160, 123, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 97, + + 160, 36, 38, 160, 160, 160, 160, 160, 60, 160, + 160, 160, 160, 117, 18, 19, 160, 160, 160, 160, + 160, 160, 160, 58, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 119, 160, 160, 160, 160, 160, 160, + 160, 160, 35, 160, 160, 160, 160, 160, 160, 11, + 160, 160, 160, 160, 160, 160, 160, 10, 160, 160, + 39, 160, 125, 118, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 90, 89, 160, 120, 115, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 45, 160, 124, 160, + + 160, 160, 160, 40, 160, 160, 160, 84, 86, 109, + 160, 160, 160, 88, 160, 160, 160, 160, 160, 160, + 160, 160, 131, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 24, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 133, 160, 160, 112, 160, 160, 160, 160, 160, + 160, 160, 25, 160, 9, 160, 160, 110, 51, 160, + 160, 160, 93, 160, 160, 160, 160, 160, 160, 132, + 74, 160, 160, 160, 53, 57, 52, 160, 46, 160, + 8, 160, 160, 92, 160, 160, 160, 160, 160, 160, + + 160, 160, 160, 56, 160, 47, 160, 111, 160, 160, + 85, 160, 160, 160, 160, 160, 160, 75, 55, 48, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 59, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 99, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 138, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, 136, 160, + + 139, 140, 160, 160, 160, 160, 160, 137, 141, 0 } ; static yyconst flex_int32_t yy_ec[256] = @@ -572,331 +593,373 @@ static yyconst flex_int32_t yy_meta[40] = 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[1434] = +static yyconst flex_int16_t yy_base[1625] = { 0, 0, 0, 37, 40, 44, 51, 63, 75, 56, 68, - 87, 108, 2308, 1868, 50, 2836, 2836, 2836, 129, 94, + 87, 108, 2844, 2315, 50, 3201, 3201, 3201, 129, 94, 70, 104, 130, 90, 92, 115, 127, 95, 84, 111, - 137, 148, 50, 150, 155, 157, 163, 171, 178, 1613, - 2836, 2836, 2836, 70, 1321, 2836, 2836, 2836, 42, 1271, - 1231, 2836, 2836, 2836, 195, 1162, 2836, 2836, 2836, 141, - 980, 2836, 202, 2836, 206, 122, 800, 212, 120, 0, + 137, 148, 50, 150, 155, 157, 163, 171, 178, 2213, + 3201, 3201, 3201, 70, 2102, 3201, 3201, 3201, 42, 1930, + 1613, 3201, 3201, 3201, 195, 1340, 3201, 3201, 3201, 141, + 1156, 3201, 202, 3201, 206, 122, 1017, 212, 120, 0, 223, 0, 0, 103, 147, 154, 158, 192, 199, 207, 208, 205, 209, 221, 218, 220, 224, 225, 229, 230, 231, 238, 251, 236, 247, 250, 237, 248, 256, 259, 167, 263, 254, 249, 264, 265, 271, 273, 274, 125, 275, 277, 284, 278, 281, 285, 288, 286, 289, 292, - 296, 298, 763, 308, 643, 315, 616, 326, 439, 381, + 296, 298, 987, 308, 860, 315, 829, 326, 692, 342, 319, 301, 330, 334, 0, 327, 331, 337, 314, 305, - 333, 335, 343, 340, 346, 349, 356, 350, 339, 352, - 49, 359, 361, 353, 354, 368, 364, 373, 371, 342, - 374, 384, 385, 392, 393, 391, 375, 394, 397, 404, - 406, 403, 182, 395, 405, 407, 408, 409, 412, 413, - 414, 419, 422, 420, 421, 426, 430, 427, 431, 434, - 444, 447, 448, 441, 445, 449, 456, 454, 455, 458, - - 452, 461, 463, 468, 474, 472, 465, 475, 477, 478, - 479, 489, 483, 491, 493, 499, 485, 495, 487, 496, - 500, 502, 503, 504, 511, 512, 510, 514, 517, 518, - 519, 521, 525, 524, 535, 529, 530, 541, 537, 542, - 543, 540, 548, 556, 552, 553, 554, 560, 561, 562, - 569, 565, 563, 566, 573, 567, 575, 576, 595, 585, - 583, 587, 593, 589, 579, 596, 601, 602, 603, 620, - 605, 613, 624, 623, 632, 606, 622, 631, 634, 633, - 636, 637, 639, 641, 642, 644, 652, 645, 662, 658, - 661, 666, 646, 667, 674, 660, 670, 672, 673, 675, - - 678, 680, 685, 2836, 687, 682, 689, 690, 692, 2836, - 691, 693, 694, 695, 698, 707, 696, 705, 709, 712, - 710, 715, 717, 718, 738, 721, 719, 729, 723, 722, - 731, 728, 747, 736, 740, 743, 749, 745, 750, 756, - 757, 759, 762, 775, 760, 761, 769, 778, 771, 773, - 781, 780, 786, 787, 788, 791, 793, 799, 797, 805, - 807, 798, 808, 810, 816, 817, 815, 809, 823, 822, - 812, 825, 830, 824, 839, 832, 835, 836, 843, 844, - 845, 847, 846, 854, 853, 852, 861, 851, 860, 865, - 866, 867, 868, 877, 874, 875, 880, 886, 887, 882, - - 888, 891, 892, 893, 894, 895, 896, 900, 902, 903, - 911, 897, 907, 913, 919, 921, 922, 904, 924, 925, - 928, 927, 931, 935, 929, 939, 941, 942, 943, 949, - 951, 944, 953, 2836, 963, 957, 959, 960, 964, 966, - 945, 967, 2836, 2836, 968, 2836, 2836, 974, 969, 973, - 981, 986, 987, 979, 989, 991, 996, 999, 1000, 1002, - 1007, 1009, 1010, 1003, 1011, 1013, 1018, 1016, 1020, 1022, - 1025, 1033, 1034, 1032, 1036, 1037, 1039, 1026, 1041, 1043, - 1049, 1051, 1057, 1053, 2836, 1055, 1040, 1060, 1056, 1062, - 2836, 1063, 1064, 1066, 1068, 1067, 1070, 1074, 1075, 1076, - - 1077, 1082, 1078, 1080, 1081, 1085, 1098, 1100, 1102, 1097, - 1103, 1104, 1105, 1107, 1117, 1110, 1111, 1114, 1123, 1119, - 1121, 1125, 1122, 1128, 1130, 1131, 1133, 1156, 1134, 1135, - 1141, 1136, 1140, 1143, 1144, 1142, 1146, 1148, 1169, 1170, - 1168, 1174, 1175, 1152, 1177, 1181, 1179, 1180, 1184, 1186, - 2836, 1197, 1191, 1185, 1195, 1198, 1200, 1201, 1202, 1206, - 1205, 1209, 1207, 1217, 2836, 1213, 1215, 1214, 1222, 1226, - 1230, 1228, 1238, 1241, 2836, 1245, 1242, 1247, 1234, 1248, - 1251, 1252, 1253, 1255, 1218, 1256, 1257, 1262, 1265, 1259, - 1264, 1266, 1269, 1270, 1276, 1275, 1278, 1279, 1282, 1281, - - 1286, 1296, 1299, 1287, 1301, 1293, 1295, 1303, 1308, 1305, - 1307, 1306, 1310, 2836, 239, 1313, 1311, 1314, 1322, 1324, - 1328, 1318, 1329, 1331, 1330, 1337, 1320, 1341, 1338, 1342, - 1344, 1346, 1349, 1347, 1353, 1350, 1357, 1351, 1359, 1362, - 1363, 1365, 1367, 1368, 1370, 1372, 1371, 1373, 2836, 1383, - 1379, 1381, 1380, 1385, 1397, 1394, 1395, 1398, 1404, 1401, - 1405, 1406, 1414, 1403, 1416, 1409, 1417, 1424, 1425, 1422, - 1426, 1428, 1418, 2836, 1432, 1433, 1431, 1438, 1434, 1439, - 1440, 1441, 1443, 1451, 1445, 1456, 2836, 1458, 1457, 1463, - 1465, 1466, 1470, 1467, 1474, 1471, 1475, 1476, 1478, 1487, - - 1477, 1479, 1489, 2836, 1497, 1498, 1494, 1505, 1481, 1501, - 1502, 1504, 1506, 1507, 1514, 1508, 1511, 1515, 1516, 1512, - 1510, 1518, 1519, 1522, 2836, 1539, 1537, 1521, 1523, 1525, - 1540, 1541, 1524, 1547, 1548, 1550, 1553, 1555, 1552, 1556, - 1557, 1558, 1554, 1565, 1560, 1562, 1573, 1576, 1582, 1583, - 1579, 2836, 1585, 1586, 1587, 1588, 1597, 1590, 1593, 1595, - 1598, 1599, 1600, 1608, 1602, 1604, 1609, 1610, 1605, 1611, - 1615, 1616, 1620, 1622, 1627, 1633, 1631, 1635, 1636, 1639, - 1637, 1649, 2836, 1638, 2836, 1645, 1646, 1653, 2836, 1655, - 2836, 1659, 2836, 1660, 1661, 1652, 1664, 1665, 1666, 1668, - - 1670, 1672, 1673, 1675, 1676, 1677, 1680, 1685, 2836, 1678, - 1684, 1693, 1682, 1686, 1688, 1701, 1695, 1709, 1691, 1705, - 1713, 1710, 2836, 1707, 1714, 1717, 1718, 1720, 1726, 1724, - 1727, 1728, 1729, 1730, 1732, 1733, 1737, 1734, 1740, 1741, - 1742, 1746, 1744, 1750, 1753, 1751, 1752, 1754, 2836, 1759, - 1757, 1767, 1765, 2836, 2836, 1769, 1770, 1777, 1778, 1780, - 1766, 1783, 1784, 1791, 1788, 1790, 1796, 1797, 1798, 1799, - 1800, 1801, 1803, 1804, 2836, 1811, 1805, 1813, 1814, 1807, - 1821, 1817, 1825, 2836, 2836, 1829, 1826, 1831, 1832, 1838, - 1836, 1835, 2836, 1840, 1841, 1842, 1843, 1850, 1854, 1844, - - 1846, 1857, 1858, 1859, 1862, 1869, 1865, 1866, 1870, 1879, - 1881, 2836, 1873, 1886, 1875, 1889, 1895, 1883, 1891, 1892, - 1894, 1896, 1898, 1900, 1906, 1902, 2836, 1908, 1907, 1914, - 1911, 1918, 1919, 1926, 1915, 1913, 1922, 1923, 1924, 1931, - 1928, 1937, 1932, 2836, 1935, 1940, 1941, 1946, 1948, 1947, - 1949, 1951, 1955, 2836, 1958, 1964, 1960, 1961, 1966, 1962, - 1969, 1970, 1972, 1974, 1976, 1975, 1979, 1983, 1984, 1986, - 1989, 1992, 1999, 1997, 2003, 2009, 2001, 2005, 2012, 2008, - 2011, 2013, 2014, 2021, 2018, 2024, 2022, 2836, 2023, 2029, - 2031, 2032, 2036, 2037, 2033, 2836, 2836, 2035, 2836, 2044, - - 2836, 2045, 2048, 2049, 2050, 2836, 2052, 2836, 2836, 2053, - 2060, 2054, 2061, 2063, 2069, 2836, 2070, 2064, 2072, 2074, - 2075, 2076, 2078, 2079, 2080, 2836, 2081, 2083, 2089, 2082, - 2836, 2092, 2097, 2093, 2098, 2099, 2104, 2105, 2102, 2108, - 2116, 2112, 2836, 2113, 2115, 2122, 2114, 2118, 2123, 2124, - 2131, 2836, 2134, 2135, 2836, 2136, 2137, 2138, 2836, 2141, - 2836, 2142, 2144, 2145, 2146, 2151, 2152, 2163, 2153, 2156, - 2164, 2158, 2166, 2167, 2836, 2836, 2168, 2174, 2178, 2176, - 2180, 2182, 2183, 2184, 2186, 2189, 2190, 2836, 2192, 2193, - 2196, 2194, 2197, 2836, 2201, 2195, 2207, 2208, 2202, 2205, - - 2211, 2213, 2223, 2225, 2214, 2228, 2230, 2219, 2836, 2231, - 2235, 2232, 2240, 2237, 2241, 2242, 2243, 2249, 2246, 2253, - 2836, 2257, 2250, 2260, 2254, 2258, 2262, 2264, 2266, 2269, - 2268, 2271, 2272, 2274, 2277, 2280, 2278, 2836, 2284, 2836, - 2285, 2287, 2297, 2298, 2836, 2293, 2300, 2836, 2302, 2296, - 2310, 2836, 2311, 2303, 2314, 2316, 2317, 2318, 2319, 2320, - 2328, 2324, 2836, 2326, 2327, 2333, 2329, 2836, 2836, 2334, - 2836, 2836, 2344, 2836, 2836, 2340, 2347, 2836, 2349, 2836, - 2355, 2351, 2338, 2336, 2356, 2836, 2360, 2836, 2836, 2357, - 2363, 2353, 2364, 2371, 2373, 2375, 2366, 2368, 2376, 2377, - - 2379, 2380, 2381, 2383, 2384, 2387, 2390, 2392, 2394, 2395, - 2396, 2397, 2398, 2400, 2836, 2404, 2406, 2836, 2412, 2408, - 2415, 2416, 2419, 2420, 2421, 2424, 2431, 2427, 2425, 2428, - 2836, 2432, 2836, 2836, 2429, 2435, 2446, 2439, 2441, 2836, - 2453, 2443, 2456, 2458, 2836, 2836, 2836, 2460, 2447, 2463, - 2465, 2466, 2464, 2467, 2836, 2473, 2474, 2476, 2477, 2485, - 2487, 2494, 2491, 2496, 2836, 2493, 2468, 2836, 2497, 2499, - 2501, 2502, 2503, 2505, 2836, 2506, 2507, 2509, 2513, 2516, - 2519, 2518, 2836, 2520, 2517, 2836, 2532, 2836, 2836, 2521, - 2533, 2535, 2537, 2540, 2543, 2528, 2544, 2550, 2548, 2478, - - 2836, 2836, 2549, 2836, 2836, 2551, 2552, 2553, 2556, 2559, - 2561, 2554, 2562, 2564, 2563, 2836, 2565, 2836, 2567, 2577, - 2578, 2571, 2836, 2581, 2579, 2569, 2836, 2836, 2836, 2584, - 2586, 2592, 2836, 2593, 2595, 2596, 2597, 2600, 2602, 2603, - 2605, 2606, 2608, 2607, 2609, 2617, 2618, 2836, 2621, 2610, - 2622, 2626, 2632, 2627, 2629, 2634, 2636, 2637, 2639, 2640, - 2836, 2642, 2643, 2651, 2653, 2658, 2655, 2662, 2836, 2663, - 2836, 2666, 2667, 2836, 2836, 2668, 2670, 2673, 2836, 2674, - 2836, 2671, 2681, 2682, 2836, 2836, 2836, 2684, 2836, 2685, - 2836, 2688, 2675, 2836, 2677, 2693, 2697, 2836, 2699, 2836, - - 2701, 2836, 2694, 2702, 2836, 2836, 2836, 2836, 2704, 2705, - 2710, 2707, 2836, 2711, 2713, 2712, 2715, 2836, 2836, 2744, - 2751, 2758, 2765, 2772, 94, 2779, 2786, 2793, 2800, 2807, - 2814, 2821, 2828 + 333, 335, 343, 340, 346, 349, 370, 350, 339, 352, + 49, 356, 354, 353, 361, 363, 362, 366, 364, 368, + 373, 377, 381, 392, 399, 386, 383, 401, 397, 405, + 408, 406, 182, 407, 409, 410, 385, 411, 414, 412, + 416, 418, 424, 420, 421, 422, 430, 428, 431, 441, + 444, 450, 433, 446, 448, 449, 456, 454, 453, 455, + + 461, 460, 463, 464, 474, 475, 477, 470, 472, 479, + 480, 481, 488, 489, 491, 493, 499, 495, 496, 497, + 500, 501, 504, 505, 507, 511, 517, 512, 508, 521, + 510, 516, 523, 534, 527, 538, 532, 533, 542, 540, + 545, 543, 546, 547, 558, 554, 555, 559, 556, 557, + 563, 571, 575, 565, 568, 569, 577, 579, 581, 599, + 585, 583, 587, 590, 589, 596, 610, 597, 606, 607, + 624, 603, 612, 625, 627, 628, 632, 631, 634, 636, + 635, 637, 638, 640, 641, 644, 645, 656, 659, 648, + 665, 662, 667, 664, 670, 593, 677, 673, 675, 674, + + 676, 646, 682, 678, 688, 3201, 690, 679, 685, 692, + 695, 3201, 696, 697, 698, 703, 702, 709, 705, 706, + 711, 714, 715, 719, 713, 720, 740, 722, 721, 731, + 735, 725, 733, 727, 743, 747, 749, 750, 751, 753, + 754, 755, 757, 758, 763, 774, 760, 768, 771, 778, + 779, 780, 782, 781, 787, 783, 794, 788, 798, 804, + 800, 806, 808, 814, 810, 811, 813, 820, 818, 819, + 812, 826, 823, 825, 830, 834, 827, 841, 837, 840, + 844, 847, 849, 850, 851, 853, 859, 857, 858, 866, + 868, 856, 864, 871, 872, 877, 884, 885, 881, 886, + + 892, 893, 888, 894, 897, 898, 899, 900, 901, 902, + 906, 908, 909, 917, 903, 913, 919, 925, 927, 928, + 910, 930, 931, 934, 933, 937, 941, 935, 945, 947, + 948, 949, 955, 957, 950, 959, 3201, 969, 963, 965, + 966, 970, 972, 951, 991, 3201, 973, 3201, 3201, 975, + 3201, 3201, 974, 979, 982, 994, 1014, 993, 981, 980, + 1001, 1007, 995, 1008, 997, 1019, 1022, 1023, 1011, 1015, + 1027, 1029, 1024, 1036, 1037, 1041, 1043, 1049, 1045, 1046, + 1047, 1050, 1051, 1056, 1053, 1063, 1057, 1064, 1066, 3201, + 1067, 1068, 1071, 1073, 1075, 3201, 1074, 1076, 1077, 1079, + + 1080, 1083, 1084, 1087, 1089, 1090, 1092, 1094, 1100, 1096, + 1097, 1110, 1117, 1114, 1104, 1113, 1115, 1119, 1121, 1129, + 1127, 1126, 1128, 1136, 1132, 1134, 1138, 1135, 1139, 1142, + 1145, 1146, 1170, 1147, 1148, 1149, 1153, 1154, 1157, 1158, + 1162, 1165, 1177, 1178, 1176, 1164, 1184, 1187, 1194, 1195, + 1197, 1191, 1155, 1199, 1204, 1206, 1208, 1188, 1211, 1212, + 3201, 1218, 1217, 1215, 1219, 1223, 1224, 1226, 1225, 1231, + 1227, 1237, 1229, 1245, 3201, 1230, 1239, 1233, 1241, 1250, + 1253, 1252, 1259, 1267, 3201, 1269, 1270, 1263, 1265, 1256, + 1272, 1273, 1277, 1278, 1279, 1281, 1284, 1287, 1289, 1288, + + 1292, 1291, 1293, 1296, 1300, 1299, 1302, 1301, 1305, 1303, + 1242, 1315, 1322, 1311, 1321, 1318, 1324, 1323, 1329, 1327, + 1330, 1328, 1331, 3201, 239, 1332, 1333, 1334, 1341, 1349, + 1350, 1343, 1351, 1353, 1352, 1359, 1342, 1363, 1360, 1364, + 1366, 1368, 1371, 1372, 1373, 1377, 1375, 1381, 1383, 1382, + 1384, 1385, 1391, 1394, 1392, 1396, 1397, 1398, 1399, 1400, + 1402, 1406, 1405, 1410, 3201, 1427, 1412, 1415, 1413, 1424, + 1435, 1428, 1431, 1432, 1442, 1438, 1440, 1443, 1449, 1446, + 1451, 1452, 1436, 1458, 1462, 1459, 1461, 1460, 1468, 3201, + 1463, 1470, 1471, 1472, 1473, 1475, 1477, 1480, 1481, 1488, + + 1482, 1494, 3201, 1496, 1490, 1484, 1501, 1502, 1505, 1507, + 1509, 1510, 1511, 1513, 1514, 1517, 1515, 1520, 1524, 3201, + 1528, 1532, 1529, 1540, 1536, 1525, 1537, 1539, 1541, 1542, + 1551, 1543, 1547, 1550, 1552, 1549, 1554, 1555, 1557, 1559, + 3201, 1571, 1572, 1574, 1414, 1562, 1583, 1556, 1575, 1558, + 1584, 1585, 1587, 1588, 1589, 1590, 1593, 1595, 1591, 1597, + 1596, 1599, 1600, 1608, 1598, 1617, 1618, 1619, 1601, 1623, + 1629, 1632, 1620, 3201, 1631, 1634, 1635, 1636, 1642, 1644, + 1638, 1640, 1645, 1646, 1647, 1656, 1648, 1650, 1654, 1658, + 1652, 1660, 1661, 1662, 1670, 1664, 1672, 1674, 1678, 1680, + + 1682, 1684, 1686, 1694, 3201, 1690, 3201, 1691, 1692, 1700, + 3201, 1702, 3201, 1704, 3201, 1707, 1711, 1699, 1697, 1705, + 1713, 1709, 1716, 1717, 1720, 1723, 1725, 1726, 1727, 1728, + 3201, 1729, 1734, 1731, 1735, 1738, 1739, 1740, 1744, 1756, + 1741, 1743, 1753, 1754, 3201, 1750, 1762, 1764, 1765, 1766, + 1773, 1770, 1771, 1777, 1767, 1778, 1788, 1786, 1779, 1789, + 1790, 1791, 1793, 1794, 1801, 1798, 1795, 1802, 1804, 1805, + 1806, 1807, 1814, 1811, 1812, 1815, 3201, 1823, 1821, 1817, + 1825, 3201, 3201, 1834, 1827, 1835, 1837, 1839, 1842, 1843, + 1845, 1849, 1847, 1850, 1851, 1856, 1857, 1858, 1859, 1862, + + 1860, 1866, 3201, 1872, 1868, 1878, 1869, 1865, 1887, 1879, + 1888, 3201, 3201, 1881, 1880, 1890, 1894, 1900, 1896, 1898, + 3201, 1899, 1901, 1902, 1904, 1906, 1914, 1903, 1910, 1918, + 1915, 1920, 1921, 1927, 1924, 1928, 1931, 1935, 1939, 3201, + 1940, 1942, 1943, 1945, 1944, 1947, 1948, 1951, 1952, 1957, + 1954, 1965, 1967, 1958, 1966, 1960, 1971, 1968, 1973, 1976, + 1983, 1981, 3201, 1987, 1986, 1994, 1990, 1992, 1995, 1998, + 1997, 1999, 2000, 2001, 2002, 2006, 2003, 2007, 2010, 3201, + 2013, 2018, 2012, 2024, 2025, 2014, 2032, 2026, 2028, 3201, + 2036, 2042, 2035, 2038, 2047, 2043, 2049, 2039, 2050, 2051, + + 2053, 2054, 2057, 2062, 2056, 2064, 2069, 2071, 2078, 2075, + 2081, 2082, 2079, 2083, 2089, 2086, 2087, 2088, 2092, 2099, + 2093, 2101, 2097, 3201, 2103, 2108, 2111, 2112, 2114, 2116, + 2104, 3201, 3201, 2120, 3201, 2121, 2124, 2125, 2126, 2128, + 2129, 2127, 2134, 2141, 2130, 3201, 2137, 2140, 2142, 2143, + 3201, 2154, 3201, 3201, 2147, 2155, 2156, 2159, 2162, 2166, + 3201, 2163, 2157, 2167, 2169, 2171, 2172, 2174, 2176, 2175, + 3201, 2180, 2179, 2178, 2188, 3201, 2187, 2193, 2182, 2189, + 2198, 2199, 2202, 2203, 2205, 2211, 2209, 3201, 2210, 2212, + 2216, 2218, 2219, 2220, 2223, 2224, 3201, 2233, 2234, 3201, + + 2227, 2217, 2235, 3201, 2241, 3201, 2242, 2243, 2244, 2245, + 2250, 2246, 2253, 2256, 2257, 2259, 2260, 2263, 2266, 3201, + 3201, 2267, 2271, 2277, 2268, 2279, 2282, 3201, 2265, 2283, + 2272, 2285, 2286, 2287, 2292, 2294, 2297, 2289, 2298, 2296, + 2299, 3201, 2302, 2306, 2307, 2309, 2310, 3201, 2312, 2313, + 2314, 2317, 2319, 2324, 2333, 2329, 2335, 2337, 2338, 2340, + 2344, 2341, 3201, 2345, 2347, 2348, 2352, 2353, 2349, 2356, + 2361, 2364, 2354, 2366, 3201, 2369, 2358, 2374, 2370, 2376, + 2378, 2372, 2380, 2381, 2382, 2385, 2386, 2389, 2390, 2396, + 2399, 3201, 2392, 3201, 2401, 2405, 2413, 2414, 3201, 2394, + + 2407, 3201, 2417, 2411, 2422, 3201, 2425, 2418, 2426, 2428, + 2429, 2430, 2433, 3201, 2431, 2436, 2438, 2441, 2442, 2444, + 2445, 2447, 2455, 2451, 3201, 2453, 2454, 2456, 2458, 3201, + 3201, 2466, 3201, 3201, 2471, 3201, 3201, 2463, 2473, 3201, + 2475, 3201, 2481, 2477, 2479, 2461, 2480, 3201, 2487, 3201, + 3201, 2484, 2488, 2482, 2492, 2494, 2499, 2501, 2491, 2502, + 2504, 2505, 2506, 2507, 2508, 2510, 2513, 2511, 2514, 2519, + 2515, 2521, 2523, 2524, 2525, 2527, 3201, 3201, 2531, 2536, + 2533, 2538, 2540, 2542, 2543, 2544, 3201, 2547, 2548, 2550, + 2552, 2553, 2556, 2559, 2564, 2573, 2560, 2566, 2567, 3201, + + 2569, 3201, 3201, 2574, 2576, 2581, 2577, 2582, 3201, 2584, + 2586, 2590, 2596, 3201, 3201, 3201, 2597, 2591, 2593, 2599, + 2601, 2603, 2607, 3201, 2608, 2609, 2611, 2610, 2618, 2620, + 2626, 2628, 2630, 3201, 2636, 2633, 2634, 2632, 2635, 2638, + 2640, 2612, 3201, 2644, 2642, 2643, 2648, 2653, 2649, 3201, + 2651, 2656, 2660, 2662, 2664, 2661, 2667, 3201, 2665, 2666, + 3201, 2677, 3201, 3201, 2668, 2680, 2682, 2684, 2687, 2690, + 2673, 2678, 2698, 2695, 2696, 3201, 3201, 2697, 3201, 3201, + 2699, 2701, 2702, 2704, 2705, 2708, 2709, 2710, 2711, 2712, + 2715, 2721, 2714, 2722, 2723, 2725, 3201, 2733, 3201, 2729, + + 2738, 2735, 2740, 3201, 2741, 2742, 2727, 3201, 3201, 3201, + 2746, 2743, 2753, 3201, 2755, 2756, 2757, 2758, 2759, 2766, + 2764, 2768, 3201, 2769, 2770, 2772, 2773, 2774, 2775, 2776, + 2781, 2779, 2780, 2792, 2793, 3201, 2796, 2783, 2787, 2801, + 2807, 2797, 2802, 2804, 2811, 2808, 2812, 2813, 2823, 2819, + 2822, 3201, 2826, 2815, 3201, 2827, 2828, 2830, 2839, 2843, + 2835, 2845, 3201, 2846, 3201, 2849, 2850, 3201, 3201, 2851, + 2853, 2856, 3201, 2857, 2854, 2858, 2860, 2863, 2864, 3201, + 3201, 2865, 2867, 2871, 3201, 3201, 3201, 2880, 3201, 2882, + 3201, 2888, 2868, 3201, 2873, 2890, 2870, 2881, 2876, 2893, + + 2894, 2892, 2901, 3201, 2903, 3201, 2905, 3201, 2906, 2907, + 3201, 2914, 2910, 2912, 2913, 2915, 2919, 3201, 3201, 3201, + 2916, 2921, 2923, 2925, 2922, 2926, 2927, 2928, 2930, 2937, + 2934, 2945, 2931, 2938, 2954, 2947, 3201, 2948, 2951, 2960, + 2962, 2958, 2964, 2959, 2965, 2966, 2967, 2968, 2969, 2971, + 2982, 2973, 2974, 2984, 2986, 2990, 2983, 2998, 2997, 2994, + 2999, 3000, 3008, 3004, 3007, 3201, 3005, 3006, 3009, 3011, + 3012, 3016, 3014, 3026, 3029, 3017, 3031, 3015, 3036, 3032, + 3037, 3040, 3041, 3042, 3201, 3043, 3045, 3047, 3049, 3051, + 3053, 3054, 3055, 3058, 3060, 3063, 3065, 3069, 3201, 3070, + + 3201, 3201, 3074, 3071, 3077, 3081, 3083, 3201, 3201, 3201, + 3109, 3116, 3123, 3130, 3137, 94, 3144, 3151, 3158, 3165, + 3172, 3179, 3186, 3193 } ; -static yyconst flex_int16_t yy_def[1434] = +static yyconst flex_int16_t yy_def[1625] = { 0, - 1419, 1, 1420, 1420, 1421, 1421, 1422, 1422, 1423, 1423, - 1424, 1424, 1419, 1425, 1419, 1419, 1419, 1419, 1426, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1427, - 1419, 1419, 1419, 1427, 1428, 1419, 1419, 1419, 1428, 1429, - 1419, 1419, 1419, 1419, 1429, 1430, 1419, 1419, 1419, 1430, - 1431, 1419, 1432, 1419, 1431, 1431, 1425, 1425, 1419, 1433, - 1426, 1433, 1426, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1427, 1427, 1428, 1428, 1429, 1429, 1419, 1430, - 1430, 1431, 1431, 1432, 1432, 1431, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1431, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1431, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1419, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1431, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1431, 1425, - 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1419, 1419, 1425, 1419, 1419, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, - 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1431, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1419, 1431, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1419, 1425, 1419, 1425, 1425, 1425, 1419, 1425, - 1419, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, - 1425, 1425, 1425, 1419, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1419, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1419, 1419, 1425, 1419, 1425, - - 1419, 1425, 1425, 1425, 1425, 1419, 1425, 1419, 1419, 1425, - 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, - 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1419, 1425, 1425, 1419, 1425, 1425, 1425, 1419, 1425, - 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1419, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1425, - 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1419, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1419, 1425, 1425, - 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1419, 1419, 1425, - 1419, 1419, 1425, 1419, 1419, 1425, 1425, 1419, 1425, 1419, - 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1419, 1419, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1419, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1419, 1425, 1419, 1419, 1425, 1425, 1425, 1425, 1425, 1419, - 1425, 1425, 1425, 1425, 1419, 1419, 1419, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1419, 1425, 1425, - 1425, 1425, 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1419, 1425, 1425, 1419, 1425, 1419, 1419, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - - 1419, 1419, 1425, 1419, 1419, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1419, 1425, 1425, - 1425, 1425, 1419, 1425, 1425, 1425, 1419, 1419, 1419, 1425, - 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, 1425, - 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, - 1419, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1419, 1425, - 1419, 1425, 1425, 1419, 1419, 1425, 1425, 1425, 1419, 1425, - 1419, 1425, 1425, 1425, 1419, 1419, 1419, 1425, 1419, 1425, - 1419, 1425, 1425, 1419, 1425, 1425, 1425, 1419, 1425, 1419, - - 1425, 1419, 1425, 1425, 1419, 1419, 1419, 1419, 1425, 1425, - 1425, 1425, 1419, 1425, 1425, 1425, 1425, 1419, 0, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419 + 1610, 1, 1611, 1611, 1612, 1612, 1613, 1613, 1614, 1614, + 1615, 1615, 1610, 1616, 1610, 1610, 1610, 1610, 1617, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1618, + 1610, 1610, 1610, 1618, 1619, 1610, 1610, 1610, 1619, 1620, + 1610, 1610, 1610, 1610, 1620, 1621, 1610, 1610, 1610, 1621, + 1622, 1610, 1623, 1610, 1622, 1622, 1616, 1616, 1610, 1624, + 1617, 1624, 1617, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1618, 1618, 1619, 1619, 1620, 1620, 1610, 1621, + 1621, 1622, 1622, 1623, 1623, 1622, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1622, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1622, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, + 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1622, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1622, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1610, 1610, 1616, + 1610, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1622, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1610, 1622, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1610, 1616, 1610, 1616, 1616, 1616, + 1610, 1616, 1610, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, + 1616, 1610, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1610, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1610, 1610, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, + 1610, 1616, 1610, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1610, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1610, + + 1616, 1616, 1616, 1610, 1616, 1610, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1610, 1616, 1610, 1616, 1616, 1616, 1616, 1610, 1616, + + 1616, 1610, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1610, + 1610, 1616, 1610, 1610, 1616, 1610, 1610, 1616, 1616, 1610, + 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1610, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1610, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + + 1616, 1610, 1610, 1616, 1616, 1616, 1616, 1616, 1610, 1616, + 1616, 1616, 1616, 1610, 1610, 1610, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, + 1610, 1616, 1610, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1610, 1610, 1616, 1610, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1610, 1616, + + 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1610, 1610, 1610, + 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1610, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1610, 1616, 1610, 1616, 1616, 1610, 1610, 1616, + 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1610, + 1610, 1616, 1616, 1616, 1610, 1610, 1610, 1616, 1610, 1616, + 1610, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, 1616, + + 1616, 1616, 1616, 1610, 1616, 1610, 1616, 1610, 1616, 1616, + 1610, 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1610, 1610, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1610, 1616, 1616, 1616, 1616, 1616, + 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1616, 1610, 1616, + + 1610, 1610, 1616, 1616, 1616, 1616, 1616, 1610, 1610, 0, + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, + 1610, 1610, 1610, 1610 } ; -static yyconst flex_int16_t yy_nxt[2876] = +static yyconst flex_int16_t yy_nxt[3241] = { 0, 14, 15, 16, 17, 18, 19, 18, 14, 14, 14, 14, 18, 20, 21, 14, 22, 23, 24, 25, 14, @@ -906,7 +969,7 @@ static yyconst flex_int16_t yy_nxt[2876] = 48, 69, 44, 46, 47, 70, 49, 48, 57, 58, 59, 68, 68, 49, 51, 52, 53, 54, 60, 18, 57, 58, 59, 123, 123, 55, 51, 52, 53, 54, - 60, 18, 68, 104, 214, 74, 75, 55, 15, 16, + 60, 18, 68, 104, 215, 74, 75, 55, 15, 16, 17, 62, 63, 64, 67, 67, 68, 67, 67, 65, 67, 95, 68, 76, 68, 67, 85, 68, 66, 15, @@ -920,7 +983,7 @@ static yyconst flex_int16_t yy_nxt[2876] = 107, 103, 110, 68, 113, 111, 139, 108, 114, 115, 68, 121, 169, 118, 68, 122, 127, 119, 127, 127, - 238, 127, 120, 72, 68, 72, 72, 132, 72, 132, + 239, 127, 120, 72, 68, 72, 72, 132, 72, 132, 132, 68, 132, 67, 135, 67, 67, 68, 67, 68, 68, 68, 141, 67, 72, 142, 72, 72, 147, 72, 68, 143, 68, 68, 72, 73, 68, 68, 144, 145, @@ -936,287 +999,327 @@ static yyconst flex_int16_t yy_nxt[2876] = 192, 125, 130, 130, 190, 198, 68, 127, 193, 127, 127, 132, 127, 132, 132, 72, 132, 72, 72, 133, 72, 197, 194, 68, 196, 68, 135, 68, 195, 68, - 201, 68, 68, 204, 68, 68, 202, 203, 68, 205, - 199, 68, 68, 211, 68, 68, 68, 200, 68, 213, - 212, 68, 206, 68, 224, 215, 68, 207, 216, 217, - 68, 218, 208, 68, 223, 68, 68, 68, 209, 210, - 222, 226, 219, 131, 221, 220, 68, 68, 227, 228, - - 230, 233, 225, 68, 68, 68, 68, 68, 232, 68, - 229, 235, 231, 236, 234, 68, 68, 68, 68, 68, - 68, 68, 237, 240, 68, 68, 68, 239, 242, 249, - 245, 68, 68, 68, 68, 251, 243, 253, 68, 68, - 129, 241, 68, 68, 244, 252, 68, 256, 246, 247, - 248, 257, 250, 133, 259, 255, 68, 68, 254, 68, - 68, 68, 260, 265, 68, 262, 68, 68, 68, 264, - 68, 266, 269, 68, 258, 68, 263, 68, 271, 261, - 68, 272, 267, 273, 68, 274, 68, 68, 268, 68, - 68, 68, 277, 275, 278, 68, 280, 68, 270, 68, - - 279, 68, 276, 68, 282, 68, 284, 68, 68, 281, - 283, 68, 68, 289, 68, 68, 68, 285, 293, 291, - 287, 288, 68, 68, 68, 286, 68, 294, 292, 68, - 68, 68, 290, 68, 295, 304, 68, 68, 298, 302, - 303, 68, 68, 296, 300, 301, 297, 68, 310, 68, - 305, 299, 68, 68, 68, 68, 312, 308, 306, 311, - 68, 307, 309, 315, 68, 68, 68, 313, 68, 318, - 317, 319, 68, 68, 68, 68, 325, 68, 68, 68, - 314, 68, 326, 324, 316, 68, 320, 68, 68, 321, - 331, 68, 322, 330, 323, 68, 327, 68, 328, 133, - - 329, 68, 333, 347, 342, 68, 332, 68, 68, 334, - 335, 346, 341, 68, 68, 68, 345, 68, 68, 336, - 343, 337, 338, 339, 344, 68, 340, 351, 128, 349, - 350, 354, 68, 348, 68, 68, 68, 352, 358, 353, - 355, 356, 357, 68, 68, 68, 68, 362, 68, 68, - 359, 68, 363, 68, 68, 126, 68, 68, 68, 360, - 361, 369, 366, 368, 68, 365, 371, 364, 370, 372, - 68, 376, 68, 68, 68, 367, 373, 374, 68, 68, - 377, 378, 68, 375, 68, 68, 68, 68, 383, 382, - 68, 380, 68, 379, 68, 384, 381, 68, 386, 68, - - 387, 68, 68, 68, 68, 68, 68, 68, 68, 389, - 68, 390, 395, 385, 397, 388, 391, 68, 396, 68, - 394, 68, 68, 392, 68, 393, 398, 68, 401, 68, - 68, 68, 403, 68, 68, 68, 413, 402, 415, 399, - 68, 68, 400, 68, 417, 404, 414, 412, 68, 405, - 68, 406, 68, 411, 416, 68, 407, 68, 408, 68, - 419, 68, 68, 420, 421, 418, 409, 425, 68, 68, - 422, 68, 68, 68, 133, 124, 410, 426, 429, 424, - 423, 68, 430, 68, 431, 68, 428, 68, 427, 434, - 68, 432, 68, 68, 433, 435, 437, 436, 68, 68, - - 68, 439, 443, 68, 444, 68, 445, 438, 446, 68, - 68, 68, 68, 442, 448, 440, 447, 68, 441, 68, - 68, 68, 68, 452, 68, 450, 451, 68, 68, 68, - 456, 449, 454, 453, 68, 68, 68, 68, 458, 457, - 459, 455, 68, 462, 68, 460, 464, 68, 68, 461, - 466, 68, 467, 465, 463, 68, 68, 68, 68, 68, - 469, 474, 471, 68, 68, 68, 68, 476, 478, 470, - 473, 475, 68, 68, 468, 472, 477, 68, 68, 68, - 68, 486, 482, 481, 484, 483, 68, 68, 485, 68, - 479, 480, 68, 490, 68, 488, 487, 491, 68, 68, - - 68, 492, 494, 68, 68, 68, 68, 68, 68, 68, - 489, 499, 68, 493, 68, 68, 68, 500, 504, 68, - 506, 495, 496, 68, 497, 68, 498, 501, 505, 507, - 503, 68, 502, 68, 68, 511, 68, 68, 509, 68, - 68, 68, 508, 68, 513, 514, 515, 68, 516, 512, - 510, 68, 517, 68, 68, 133, 68, 68, 519, 518, - 522, 68, 520, 68, 523, 68, 526, 524, 521, 68, - 528, 68, 68, 529, 527, 68, 68, 525, 68, 68, - 68, 68, 534, 530, 532, 68, 68, 538, 540, 539, - 531, 68, 133, 68, 535, 537, 533, 536, 68, 68, - - 541, 68, 542, 68, 547, 543, 550, 551, 68, 548, - 544, 68, 68, 553, 68, 68, 545, 546, 552, 68, - 555, 68, 68, 68, 556, 68, 549, 557, 68, 554, - 68, 561, 68, 560, 68, 558, 565, 68, 68, 564, - 566, 567, 559, 562, 68, 68, 68, 568, 68, 68, - 563, 68, 68, 68, 569, 68, 572, 570, 573, 571, - 575, 68, 574, 68, 577, 68, 580, 68, 68, 68, - 579, 576, 68, 581, 68, 68, 68, 583, 68, 68, - 68, 586, 68, 582, 578, 584, 68, 68, 68, 68, - 68, 592, 68, 68, 68, 591, 585, 68, 597, 587, - - 588, 589, 590, 595, 596, 600, 593, 601, 594, 68, - 68, 599, 68, 598, 68, 68, 68, 68, 602, 68, - 607, 605, 68, 68, 608, 609, 68, 604, 603, 68, - 612, 68, 614, 68, 68, 68, 615, 133, 606, 611, - 68, 610, 68, 68, 617, 68, 68, 68, 68, 616, - 626, 613, 68, 68, 68, 68, 68, 630, 68, 620, - 68, 618, 627, 629, 68, 644, 635, 619, 68, 631, - 632, 621, 634, 622, 131, 633, 636, 623, 628, 624, - 68, 68, 68, 637, 625, 641, 68, 68, 638, 68, - 639, 68, 68, 68, 645, 649, 68, 68, 68, 643, - - 642, 646, 650, 68, 651, 647, 652, 68, 640, 68, - 68, 648, 68, 68, 68, 655, 653, 68, 68, 68, - 654, 68, 657, 659, 663, 68, 68, 68, 662, 68, - 68, 656, 129, 658, 68, 661, 684, 660, 68, 667, - 68, 666, 68, 668, 664, 665, 68, 669, 672, 670, - 68, 671, 673, 68, 68, 675, 674, 68, 676, 68, - 68, 678, 677, 68, 68, 68, 680, 68, 68, 68, - 682, 68, 683, 687, 68, 686, 68, 68, 68, 690, - 679, 68, 68, 128, 685, 681, 688, 68, 68, 689, - 68, 68, 695, 68, 68, 696, 691, 698, 68, 68, - - 692, 694, 693, 701, 699, 68, 702, 68, 68, 697, - 700, 68, 704, 68, 703, 68, 708, 68, 68, 68, - 68, 706, 68, 68, 705, 68, 68, 707, 710, 716, - 68, 717, 68, 126, 68, 709, 68, 711, 714, 713, - 68, 68, 68, 68, 719, 718, 715, 712, 721, 68, - 68, 724, 725, 68, 68, 720, 68, 722, 68, 68, - 727, 68, 68, 68, 723, 68, 730, 729, 726, 68, - 732, 68, 735, 734, 68, 68, 728, 68, 731, 68, - 68, 733, 68, 68, 68, 68, 736, 738, 742, 737, - 746, 68, 68, 68, 745, 68, 739, 68, 741, 743, - - 740, 748, 750, 744, 751, 747, 68, 68, 752, 68, - 68, 756, 749, 68, 757, 68, 68, 68, 68, 755, - 754, 68, 758, 759, 761, 753, 68, 760, 68, 68, - 68, 765, 766, 762, 68, 763, 68, 68, 68, 767, - 68, 773, 768, 68, 68, 68, 68, 764, 774, 769, - 68, 68, 68, 68, 770, 68, 771, 68, 772, 779, - 775, 776, 783, 68, 777, 778, 780, 785, 68, 68, - 68, 781, 784, 786, 787, 68, 789, 68, 68, 68, - 782, 791, 68, 68, 792, 793, 68, 68, 68, 68, - 68, 68, 795, 68, 788, 797, 796, 800, 790, 68, - - 798, 68, 806, 794, 802, 803, 68, 799, 801, 68, - 68, 804, 805, 68, 68, 809, 68, 68, 68, 68, - 68, 812, 68, 68, 68, 808, 68, 68, 68, 816, - 68, 68, 807, 68, 68, 68, 68, 68, 810, 821, - 813, 825, 811, 814, 817, 815, 822, 818, 819, 68, - 823, 68, 68, 68, 820, 827, 830, 828, 824, 68, - 68, 826, 68, 831, 68, 68, 68, 68, 68, 68, - 68, 829, 68, 837, 68, 839, 838, 68, 832, 834, - 843, 833, 835, 836, 840, 68, 841, 842, 68, 846, - 847, 68, 848, 845, 68, 68, 849, 68, 68, 68, - - 68, 855, 68, 850, 853, 68, 844, 68, 854, 68, - 68, 68, 68, 851, 68, 861, 68, 68, 860, 852, - 68, 68, 68, 68, 856, 124, 857, 68, 68, 869, - 859, 866, 68, 862, 68, 863, 858, 870, 871, 68, - 864, 865, 868, 68, 867, 68, 875, 68, 68, 68, - 68, 68, 872, 876, 873, 877, 879, 68, 68, 882, - 883, 68, 881, 874, 68, 68, 884, 68, 880, 878, - 885, 68, 68, 68, 887, 886, 68, 68, 68, 888, - 68, 893, 68, 891, 68, 68, 895, 68, 68, 68, - 68, 890, 68, 898, 68, 892, 68, 68, 68, 897, - - 68, 889, 900, 68, 894, 68, 903, 68, 901, 896, - 902, 899, 908, 68, 904, 907, 909, 68, 905, 68, - 906, 68, 68, 910, 912, 68, 68, 915, 913, 68, - 68, 911, 68, 919, 916, 918, 68, 920, 68, 68, - 68, 68, 68, 914, 68, 68, 68, 924, 927, 68, - 926, 928, 68, 68, 68, 917, 68, 921, 68, 922, - 935, 923, 68, 68, 68, 68, 68, 925, 933, 68, - 929, 68, 932, 930, 931, 934, 940, 68, 68, 68, - 944, 68, 68, 936, 937, 945, 939, 938, 941, 68, - 68, 942, 68, 943, 946, 68, 68, 949, 953, 954, - - 68, 948, 68, 68, 950, 952, 947, 951, 68, 68, - 68, 68, 68, 68, 961, 68, 68, 68, 964, 68, - 966, 956, 955, 68, 958, 68, 68, 957, 969, 68, - 960, 962, 967, 68, 963, 965, 959, 68, 68, 968, - 971, 68, 970, 68, 68, 977, 972, 68, 68, 973, - 68, 974, 68, 68, 68, 68, 68, 981, 68, 982, - 983, 975, 68, 976, 978, 979, 68, 984, 988, 68, - 68, 68, 980, 987, 68, 985, 992, 68, 68, 986, - 68, 68, 68, 990, 989, 68, 991, 68, 995, 993, - 996, 68, 997, 68, 998, 68, 994, 999, 68, 1000, - - 1001, 68, 1002, 68, 68, 1006, 68, 68, 68, 1008, - 68, 1009, 68, 1010, 68, 1012, 1003, 1011, 68, 68, - 68, 1014, 1004, 68, 1005, 68, 68, 68, 1007, 1016, - 68, 68, 1017, 1018, 68, 68, 68, 1013, 68, 1019, - 68, 1020, 1026, 68, 68, 1022, 1021, 68, 1015, 68, - 1028, 1031, 68, 68, 1023, 1024, 1030, 1025, 68, 68, - 68, 68, 1036, 68, 1029, 1033, 1027, 68, 1032, 1034, - 68, 1040, 68, 68, 68, 1039, 68, 1043, 68, 1044, - 1042, 68, 68, 1038, 68, 1035, 68, 68, 68, 1037, - 1045, 68, 1041, 1050, 1052, 68, 68, 1055, 68, 1047, - - 1051, 68, 1046, 1049, 68, 1048, 1058, 1053, 1059, 68, - 1060, 68, 1054, 68, 1061, 68, 1062, 68, 1057, 1065, - 68, 68, 1056, 68, 68, 68, 68, 1067, 1070, 1064, - 68, 1072, 1066, 68, 68, 68, 68, 1068, 1074, 1063, - 1075, 68, 1076, 68, 68, 68, 1073, 68, 68, 68, - 1077, 1069, 1071, 1078, 1080, 1079, 68, 68, 1083, 1081, - 68, 68, 68, 1088, 68, 68, 68, 1090, 1082, 1084, - 1086, 1087, 68, 68, 1092, 68, 68, 1093, 1085, 1089, - 1094, 68, 68, 1091, 68, 1097, 68, 68, 68, 1095, - 68, 68, 68, 68, 68, 68, 1096, 1105, 1104, 1099, - - 1100, 68, 1101, 1107, 68, 68, 1102, 1098, 1109, 68, - 68, 68, 1103, 1112, 68, 1111, 68, 68, 1108, 1106, - 68, 1113, 1114, 1117, 68, 68, 68, 68, 68, 1118, - 68, 1110, 1115, 1121, 68, 68, 68, 1125, 1122, 1123, - 1116, 1120, 1124, 68, 1119, 1126, 68, 68, 68, 68, - 68, 1128, 1129, 68, 68, 1127, 68, 68, 68, 1133, - 1134, 1130, 1138, 68, 68, 68, 1132, 1137, 68, 1131, - 68, 1135, 1142, 1139, 1140, 68, 68, 1145, 68, 68, - 68, 1143, 1136, 1144, 1141, 1148, 68, 1146, 68, 1147, - 68, 1149, 68, 1152, 68, 68, 68, 1151, 68, 1153, - - 1150, 68, 68, 1155, 68, 68, 68, 68, 68, 68, - 1164, 1154, 1163, 68, 68, 1167, 1168, 68, 1161, 68, - 68, 1157, 1169, 68, 1159, 68, 68, 1156, 1158, 1160, - 1162, 68, 1165, 1166, 1171, 68, 1172, 68, 1170, 1174, - 68, 1175, 68, 68, 68, 1173, 1178, 68, 1177, 68, - 1176, 1180, 68, 68, 68, 68, 1184, 1183, 68, 1182, - 1186, 68, 68, 1179, 1188, 68, 68, 1181, 1189, 68, - 68, 1185, 68, 1191, 68, 1192, 68, 1187, 68, 1194, - 68, 68, 1193, 68, 68, 1198, 68, 1203, 1190, 68, - 68, 1196, 68, 1200, 1204, 1201, 68, 68, 1199, 68, - - 1207, 1195, 1197, 1202, 1208, 68, 1206, 1419, 68, 68, - 68, 1209, 68, 1214, 68, 68, 1205, 1213, 1217, 1210, - 1211, 1215, 68, 68, 1212, 1218, 68, 1216, 68, 68, - 68, 68, 68, 1219, 1221, 1224, 68, 1223, 68, 68, - 68, 68, 1225, 1229, 1227, 68, 68, 1230, 68, 1220, - 68, 1222, 68, 1228, 1226, 1231, 68, 1232, 1233, 68, - 1234, 68, 1235, 68, 1236, 68, 1237, 68, 68, 68, - 1238, 1240, 68, 1239, 1241, 68, 68, 1242, 68, 1243, - 68, 1244, 1245, 68, 1246, 68, 1247, 68, 68, 68, - 1248, 68, 68, 68, 1255, 68, 68, 1253, 1249, 68, - - 1250, 1251, 68, 1252, 68, 1256, 68, 68, 68, 68, - 68, 1265, 68, 1254, 1263, 1264, 68, 1259, 68, 1267, - 68, 1261, 1258, 1268, 68, 1257, 1262, 68, 68, 1269, - 1260, 68, 68, 68, 1266, 1275, 68, 68, 1276, 68, - 68, 68, 1270, 68, 68, 1419, 1271, 68, 1273, 1272, - 1282, 68, 1274, 68, 1277, 68, 1278, 1283, 68, 68, - 1279, 1281, 1419, 1280, 1286, 68, 1284, 1288, 68, 1289, - 68, 1285, 68, 1290, 1287, 68, 68, 68, 68, 68, - 68, 1291, 1293, 1294, 1292, 68, 68, 1296, 68, 68, - 68, 1298, 1307, 1299, 1334, 1295, 1301, 68, 1302, 68, - - 1297, 1303, 1304, 68, 1300, 68, 68, 1305, 68, 68, - 1306, 68, 1308, 68, 68, 68, 1312, 68, 68, 68, - 1316, 68, 1310, 1311, 1309, 68, 1313, 1318, 68, 68, - 68, 68, 68, 68, 1317, 1320, 1419, 1314, 1315, 1319, - 68, 1321, 1322, 1323, 68, 68, 1325, 68, 1327, 68, - 1326, 1328, 68, 1324, 1329, 68, 68, 1332, 1330, 1333, - 68, 68, 68, 68, 68, 68, 68, 1335, 68, 1339, - 1331, 68, 1337, 68, 68, 68, 68, 68, 1341, 68, - 1346, 68, 1336, 68, 1338, 1344, 1342, 1340, 1348, 68, - 68, 68, 1350, 68, 1349, 1345, 68, 1347, 68, 1355, - - 1343, 1354, 1351, 1352, 68, 68, 1353, 68, 68, 68, - 1357, 1361, 68, 1356, 68, 68, 1358, 68, 68, 68, - 68, 68, 68, 1362, 1360, 1366, 1365, 1359, 1369, 68, - 68, 1363, 1371, 68, 68, 1370, 1364, 1374, 68, 68, - 1368, 68, 1372, 1375, 68, 1367, 68, 1379, 68, 68, - 1381, 68, 68, 1377, 68, 68, 1373, 1419, 1376, 1419, - 1384, 1380, 1385, 68, 1386, 68, 1378, 68, 1383, 1387, - 68, 1382, 1388, 1389, 68, 68, 1390, 1391, 68, 68, - 68, 1394, 68, 68, 1392, 68, 68, 68, 1393, 68, - 1395, 1396, 1398, 68, 68, 1400, 68, 68, 1399, 1402, - - 68, 1401, 1403, 1397, 1405, 68, 68, 1404, 1406, 68, - 1407, 68, 1408, 68, 68, 1410, 68, 68, 1409, 68, - 1411, 1413, 68, 68, 68, 68, 1418, 68, 1414, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1412, 1415, 1416, - 1419, 1419, 1419, 1417, 40, 40, 40, 40, 40, 40, - 40, 45, 45, 45, 45, 45, 45, 45, 50, 50, - 50, 50, 50, 50, 50, 56, 56, 56, 56, 56, - 56, 56, 61, 61, 61, 61, 61, 61, 61, 71, - 71, 1419, 71, 71, 71, 71, 123, 123, 1419, 1419, - 1419, 123, 123, 125, 125, 1419, 1419, 125, 1419, 125, - - 127, 1419, 1419, 1419, 1419, 1419, 127, 130, 130, 1419, - 1419, 1419, 130, 130, 132, 1419, 1419, 1419, 1419, 1419, - 132, 134, 134, 1419, 134, 134, 134, 134, 72, 72, - 1419, 72, 72, 72, 72, 13, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419 + 201, 68, 68, 204, 131, 68, 202, 203, 68, 205, + 199, 68, 68, 212, 68, 68, 68, 200, 68, 214, + 213, 217, 216, 68, 68, 68, 68, 224, 68, 218, + 68, 206, 68, 223, 227, 68, 207, 220, 219, 68, + 221, 208, 222, 68, 228, 68, 209, 68, 68, 229, + + 225, 226, 210, 211, 68, 243, 231, 232, 234, 68, + 230, 68, 236, 68, 235, 237, 233, 68, 68, 68, + 68, 68, 68, 68, 68, 238, 68, 241, 68, 246, + 68, 250, 68, 68, 68, 252, 68, 254, 244, 240, + 68, 253, 68, 68, 242, 68, 245, 261, 248, 249, + 247, 258, 251, 68, 257, 256, 68, 260, 133, 255, + 68, 68, 68, 266, 262, 68, 68, 68, 68, 265, + 263, 267, 68, 68, 259, 68, 68, 273, 272, 264, + 268, 270, 68, 274, 68, 269, 68, 68, 275, 68, + 276, 68, 68, 68, 279, 282, 280, 271, 277, 278, + + 68, 68, 281, 68, 284, 68, 286, 68, 68, 68, + 285, 68, 68, 68, 291, 283, 68, 68, 295, 68, + 68, 293, 68, 68, 68, 290, 288, 287, 68, 68, + 289, 294, 296, 68, 292, 68, 297, 298, 306, 68, + 299, 302, 300, 301, 68, 68, 68, 303, 304, 305, + 68, 312, 68, 307, 68, 68, 314, 68, 68, 68, + 310, 308, 313, 311, 309, 317, 68, 68, 68, 68, + 68, 68, 319, 315, 320, 68, 321, 68, 327, 316, + 68, 68, 322, 68, 326, 323, 318, 68, 324, 68, + 325, 68, 328, 68, 333, 68, 331, 68, 329, 133, + + 330, 68, 68, 332, 344, 68, 380, 335, 68, 68, + 334, 68, 343, 336, 337, 68, 347, 349, 68, 68, + 345, 346, 68, 338, 68, 339, 340, 341, 348, 350, + 342, 353, 356, 351, 352, 354, 68, 68, 355, 68, + 68, 359, 360, 68, 68, 358, 68, 68, 68, 68, + 68, 365, 68, 68, 366, 357, 68, 68, 68, 386, + 68, 364, 362, 361, 363, 369, 371, 368, 68, 374, + 367, 68, 375, 372, 68, 373, 68, 68, 370, 68, + 376, 378, 68, 377, 381, 68, 68, 68, 68, 68, + 68, 68, 385, 129, 68, 379, 383, 68, 384, 387, + + 68, 389, 68, 390, 68, 392, 382, 68, 68, 68, + 68, 388, 391, 393, 68, 68, 400, 68, 68, 394, + 398, 68, 399, 68, 397, 68, 68, 68, 395, 396, + 404, 68, 68, 68, 68, 401, 406, 68, 416, 68, + 402, 407, 405, 68, 403, 68, 420, 68, 417, 415, + 418, 408, 68, 409, 414, 68, 422, 419, 410, 68, + 411, 68, 68, 68, 421, 68, 68, 68, 412, 68, + 68, 428, 68, 424, 423, 133, 429, 425, 413, 432, + 68, 433, 426, 68, 434, 431, 68, 427, 430, 437, + 68, 68, 68, 68, 68, 68, 436, 440, 435, 68, + + 68, 445, 442, 438, 439, 446, 68, 450, 441, 448, + 68, 443, 68, 447, 444, 449, 68, 451, 68, 452, + 68, 453, 68, 68, 68, 68, 68, 457, 455, 456, + 68, 68, 68, 461, 458, 68, 459, 68, 68, 68, + 462, 128, 68, 454, 460, 464, 68, 467, 469, 68, + 465, 463, 68, 68, 466, 471, 68, 468, 470, 68, + 472, 68, 68, 68, 474, 68, 479, 476, 68, 68, + 68, 68, 126, 481, 475, 480, 68, 478, 68, 477, + 68, 482, 473, 68, 68, 483, 484, 487, 486, 68, + 485, 489, 491, 68, 488, 490, 68, 68, 68, 495, + + 68, 493, 492, 496, 68, 68, 68, 497, 499, 68, + 68, 68, 68, 68, 68, 68, 494, 504, 68, 498, + 68, 68, 68, 505, 509, 68, 511, 500, 501, 68, + 502, 68, 503, 506, 510, 512, 508, 68, 507, 68, + 68, 516, 68, 68, 514, 68, 68, 68, 513, 68, + 518, 519, 520, 68, 521, 517, 515, 68, 522, 68, + 68, 133, 68, 68, 524, 523, 527, 68, 525, 68, + 528, 68, 531, 529, 526, 68, 533, 68, 68, 534, + 532, 68, 68, 530, 68, 68, 68, 68, 539, 535, + 537, 68, 68, 68, 68, 547, 536, 548, 549, 124, + + 545, 550, 538, 68, 546, 68, 68, 68, 540, 68, + 557, 558, 541, 68, 562, 542, 560, 559, 561, 68, + 68, 563, 543, 68, 564, 544, 68, 68, 551, 68, + 552, 68, 565, 553, 68, 68, 68, 566, 554, 68, + 567, 68, 571, 568, 555, 556, 569, 570, 68, 68, + 576, 572, 575, 68, 574, 68, 577, 68, 68, 68, + 578, 68, 68, 68, 579, 68, 573, 580, 68, 68, + 581, 587, 584, 583, 585, 68, 68, 586, 68, 68, + 68, 582, 589, 68, 591, 68, 68, 68, 68, 68, + 593, 68, 68, 596, 590, 68, 68, 588, 594, 68, + + 592, 68, 68, 602, 68, 601, 68, 595, 68, 68, + 597, 598, 68, 605, 599, 600, 68, 610, 607, 603, + 606, 604, 68, 609, 611, 68, 68, 68, 608, 68, + 612, 68, 615, 68, 617, 613, 618, 614, 68, 68, + 68, 68, 619, 622, 68, 624, 68, 68, 68, 625, + 133, 68, 616, 621, 68, 627, 620, 68, 68, 68, + 68, 68, 626, 636, 623, 68, 68, 68, 133, 68, + 68, 640, 630, 628, 68, 637, 68, 68, 643, 659, + 639, 629, 68, 641, 642, 631, 638, 632, 68, 68, + 68, 633, 644, 634, 645, 647, 68, 649, 635, 68, + + 68, 652, 648, 68, 646, 651, 68, 68, 653, 68, + 650, 68, 660, 654, 657, 655, 68, 658, 68, 664, + 68, 661, 665, 68, 68, 667, 662, 68, 666, 68, + 68, 68, 668, 656, 663, 68, 68, 68, 68, 68, + 671, 68, 68, 68, 670, 68, 669, 673, 675, 68, + 678, 68, 679, 68, 68, 672, 674, 68, 683, 676, + 682, 680, 68, 677, 68, 68, 716, 684, 68, 681, + 685, 68, 687, 686, 688, 68, 689, 68, 693, 68, + 690, 68, 68, 691, 68, 68, 692, 696, 695, 68, + 68, 68, 694, 68, 698, 699, 68, 700, 703, 68, + + 68, 68, 702, 68, 68, 68, 697, 706, 68, 701, + 704, 68, 68, 68, 68, 68, 711, 68, 705, 712, + 714, 707, 717, 68, 708, 710, 715, 68, 709, 718, + 68, 713, 720, 68, 68, 68, 68, 724, 719, 68, + 68, 68, 68, 68, 68, 68, 68, 723, 732, 721, + 722, 726, 131, 68, 68, 68, 733, 725, 729, 727, + 730, 68, 68, 68, 68, 68, 731, 734, 728, 735, + 737, 68, 68, 740, 741, 68, 68, 736, 68, 738, + 68, 745, 743, 68, 68, 68, 739, 68, 746, 68, + 742, 747, 749, 68, 68, 68, 68, 68, 744, 748, + + 752, 754, 751, 68, 68, 750, 68, 756, 68, 68, + 68, 68, 68, 753, 68, 757, 755, 68, 68, 758, + 764, 760, 68, 759, 68, 68, 68, 68, 848, 761, + 763, 767, 762, 765, 768, 770, 68, 766, 769, 68, + 68, 772, 773, 68, 68, 771, 774, 68, 68, 778, + 68, 779, 68, 777, 68, 68, 776, 780, 68, 775, + 781, 68, 782, 68, 68, 787, 786, 783, 784, 788, + 68, 68, 68, 68, 68, 68, 789, 790, 785, 796, + 68, 791, 68, 68, 68, 68, 792, 68, 793, 68, + 794, 795, 68, 68, 68, 801, 68, 797, 799, 805, + + 68, 798, 68, 802, 800, 807, 68, 809, 68, 806, + 803, 808, 811, 68, 68, 810, 813, 68, 804, 68, + 815, 68, 68, 68, 814, 68, 68, 68, 817, 68, + 820, 819, 68, 818, 812, 824, 68, 68, 822, 825, + 68, 68, 816, 823, 68, 821, 826, 827, 68, 68, + 831, 68, 68, 68, 68, 68, 829, 828, 834, 68, + 830, 68, 68, 68, 68, 838, 68, 68, 68, 68, + 68, 68, 851, 832, 68, 835, 843, 833, 844, 836, + 837, 839, 845, 68, 68, 841, 68, 68, 849, 853, + 850, 840, 842, 846, 847, 68, 68, 68, 852, 68, + + 68, 68, 68, 68, 856, 68, 859, 68, 68, 68, + 68, 68, 68, 68, 129, 855, 865, 862, 857, 866, + 68, 858, 854, 860, 863, 867, 861, 864, 868, 68, + 68, 68, 68, 876, 872, 68, 874, 871, 869, 875, + 873, 68, 877, 68, 68, 870, 68, 68, 68, 881, + 68, 878, 68, 882, 68, 883, 68, 68, 68, 68, + 68, 879, 68, 889, 68, 888, 68, 880, 68, 884, + 68, 885, 68, 68, 68, 897, 68, 887, 894, 890, + 899, 891, 68, 886, 68, 892, 68, 898, 896, 893, + 68, 903, 68, 895, 68, 901, 68, 900, 68, 904, + + 905, 907, 68, 68, 68, 910, 68, 911, 909, 68, + 902, 68, 68, 912, 68, 913, 68, 68, 906, 68, + 908, 68, 914, 68, 915, 68, 916, 921, 68, 68, + 919, 918, 68, 923, 917, 68, 920, 68, 68, 68, + 68, 68, 926, 68, 931, 928, 68, 68, 925, 922, + 68, 68, 68, 68, 935, 68, 68, 924, 927, 929, + 930, 936, 68, 937, 940, 68, 68, 932, 68, 939, + 933, 934, 941, 938, 68, 943, 68, 68, 68, 68, + 949, 946, 68, 68, 947, 68, 942, 950, 944, 68, + 68, 68, 951, 954, 952, 955, 948, 945, 68, 956, + + 68, 68, 68, 68, 953, 68, 68, 68, 960, 957, + 68, 962, 963, 68, 68, 964, 68, 68, 68, 68, + 958, 971, 959, 68, 68, 965, 68, 68, 961, 68, + 969, 968, 970, 68, 966, 68, 967, 68, 977, 68, + 976, 978, 981, 972, 973, 980, 68, 68, 974, 68, + 975, 68, 982, 979, 68, 68, 989, 68, 990, 68, + 984, 68, 68, 68, 986, 983, 988, 987, 68, 68, + 68, 68, 68, 985, 68, 997, 992, 68, 68, 1000, + 68, 68, 991, 994, 68, 1002, 993, 1003, 998, 996, + 68, 68, 68, 68, 1005, 995, 999, 1004, 1001, 68, + + 68, 1009, 68, 1007, 1006, 1010, 68, 1013, 68, 1008, + 68, 68, 68, 68, 68, 68, 68, 1017, 68, 1018, + 1011, 1019, 68, 1020, 1014, 1012, 68, 68, 1015, 1024, + 68, 1016, 68, 68, 1028, 1021, 68, 1023, 1022, 68, + 68, 1025, 128, 68, 1026, 1027, 1032, 68, 1029, 1031, + 1033, 68, 68, 1035, 68, 68, 68, 68, 1030, 68, + 68, 1034, 1037, 68, 68, 1038, 68, 1036, 1041, 68, + 68, 1039, 68, 1042, 1047, 1040, 1046, 68, 68, 68, + 68, 1045, 1051, 68, 1053, 68, 1043, 1054, 68, 1044, + 1055, 1048, 1050, 68, 1057, 68, 1056, 1049, 68, 68, + + 1052, 1059, 68, 1061, 68, 1063, 68, 68, 1062, 68, + 68, 68, 68, 68, 68, 68, 1058, 1071, 68, 68, + 1073, 1064, 68, 1065, 68, 68, 68, 1060, 1066, 1076, + 68, 1067, 1068, 1069, 1075, 1070, 68, 68, 68, 1077, + 68, 1072, 1074, 1078, 68, 1081, 1079, 68, 68, 1085, + 68, 68, 1080, 1084, 68, 68, 1083, 1087, 1088, 68, + 1089, 68, 68, 68, 1082, 68, 68, 1086, 68, 68, + 1090, 1091, 1095, 1097, 68, 1100, 68, 1092, 1096, 1098, + 1094, 68, 1093, 68, 1099, 1103, 1104, 68, 1105, 1107, + 68, 68, 1106, 68, 68, 68, 1110, 1102, 68, 68, + + 68, 68, 1101, 1112, 68, 68, 1115, 1109, 1117, 68, + 1111, 68, 1113, 68, 126, 68, 68, 1108, 1119, 1120, + 68, 1118, 1121, 68, 68, 1125, 68, 1116, 68, 1114, + 1122, 1123, 68, 68, 1124, 1128, 68, 68, 68, 68, + 68, 68, 68, 1133, 1126, 1127, 68, 1130, 1135, 68, + 1137, 1134, 68, 68, 68, 68, 1136, 1129, 1131, 68, + 1132, 1138, 1144, 1140, 1141, 1142, 68, 68, 68, 68, + 1139, 68, 1146, 1143, 68, 68, 1147, 1148, 68, 68, + 1151, 68, 1149, 68, 68, 1145, 68, 68, 68, 1150, + 68, 68, 68, 1159, 68, 1153, 1154, 1158, 1155, 68, + + 68, 68, 1152, 1156, 1163, 68, 1165, 1157, 1160, 1161, + 68, 68, 1166, 1162, 68, 68, 1167, 68, 1171, 1168, + 1164, 68, 68, 68, 68, 124, 1172, 1175, 68, 68, + 68, 68, 68, 1169, 1179, 68, 68, 1170, 1174, 68, + 1177, 1173, 1176, 1178, 1180, 68, 68, 68, 1181, 1185, + 1182, 1183, 1184, 68, 68, 68, 68, 68, 68, 1187, + 1188, 1192, 68, 1186, 1194, 68, 1191, 1193, 68, 68, + 1189, 68, 68, 1196, 1199, 68, 1197, 68, 68, 68, + 68, 1190, 1202, 68, 68, 1198, 1200, 1195, 1201, 68, + 1203, 68, 1204, 1206, 68, 68, 1205, 68, 68, 68, + + 1208, 68, 1207, 1211, 68, 1214, 68, 1209, 68, 68, + 68, 68, 1210, 1215, 68, 1217, 1216, 1212, 68, 68, + 1213, 68, 68, 1225, 68, 68, 68, 68, 1226, 68, + 1219, 68, 1229, 1223, 1218, 1230, 68, 1221, 1220, 1227, + 1222, 68, 1228, 1224, 1231, 68, 1233, 68, 1234, 68, + 68, 1236, 68, 68, 1232, 1237, 68, 68, 1240, 68, + 68, 68, 1239, 1242, 68, 68, 68, 1244, 68, 1235, + 68, 1245, 1238, 68, 1246, 1248, 68, 1250, 68, 1241, + 1251, 68, 68, 1243, 68, 1249, 68, 1253, 68, 1247, + 68, 1254, 68, 68, 68, 1256, 1252, 68, 68, 1260, + + 1255, 68, 68, 1265, 68, 1258, 68, 1262, 68, 1257, + 1263, 68, 1261, 68, 1259, 1266, 1264, 68, 1269, 68, + 1270, 1273, 1268, 68, 1267, 68, 68, 1271, 1276, 68, + 68, 1274, 1275, 1277, 68, 1272, 1278, 68, 68, 1280, + 68, 68, 68, 68, 1279, 68, 1284, 1285, 68, 1287, + 68, 1286, 1281, 68, 68, 1282, 68, 68, 1288, 68, + 1290, 1283, 1293, 68, 1292, 68, 68, 68, 68, 1294, + 68, 1296, 1298, 68, 1289, 68, 1297, 1291, 68, 1299, + 1301, 1295, 1300, 68, 1302, 68, 1303, 68, 1304, 68, + 1305, 68, 68, 68, 68, 1307, 68, 1308, 1309, 68, + + 68, 1310, 1311, 68, 68, 1314, 68, 1306, 1312, 1313, + 1315, 68, 1316, 68, 68, 1317, 68, 68, 68, 68, + 68, 1324, 68, 68, 1322, 68, 68, 68, 1319, 1320, + 1321, 68, 1318, 68, 1325, 68, 68, 68, 1334, 68, + 1323, 1332, 1333, 68, 1328, 68, 1327, 1330, 68, 1326, + 68, 1329, 68, 1331, 68, 68, 68, 1342, 1343, 68, + 68, 1339, 68, 1335, 68, 68, 1336, 1337, 68, 1344, + 1338, 68, 68, 1341, 1340, 1350, 68, 1345, 68, 68, + 1351, 68, 1346, 1347, 1348, 68, 68, 1352, 68, 68, + 1349, 1357, 1358, 68, 68, 1361, 68, 1353, 68, 1354, + + 1355, 1363, 68, 68, 1359, 68, 1356, 1364, 68, 68, + 1365, 68, 1360, 68, 1367, 68, 1368, 1362, 1369, 68, + 68, 68, 68, 68, 68, 1366, 1373, 1371, 1374, 1376, + 68, 1377, 68, 1378, 1370, 1372, 1388, 1375, 68, 1379, + 68, 1380, 68, 1381, 68, 68, 68, 68, 68, 1382, + 68, 1383, 68, 1384, 68, 68, 68, 1387, 1386, 1389, + 68, 68, 1385, 68, 1391, 68, 1393, 1390, 68, 1392, + 1394, 1397, 68, 68, 68, 1399, 68, 68, 68, 68, + 68, 1400, 1395, 1398, 1401, 68, 1402, 1396, 1404, 68, + 68, 1403, 68, 1406, 68, 1408, 68, 1407, 1409, 68, + + 1405, 1410, 68, 1411, 1412, 1413, 1414, 68, 68, 68, + 68, 68, 1415, 68, 68, 1416, 68, 68, 1419, 1423, + 68, 68, 68, 68, 68, 1427, 68, 68, 1417, 1418, + 1425, 1422, 1420, 68, 68, 68, 1421, 68, 1429, 68, + 1424, 68, 1426, 1428, 1432, 68, 1430, 68, 1434, 1436, + 68, 1437, 68, 68, 68, 68, 1443, 1433, 68, 1435, + 1431, 1438, 1439, 1442, 1441, 68, 1440, 68, 68, 68, + 68, 68, 1445, 1450, 1444, 1448, 68, 1446, 68, 1452, + 68, 68, 68, 1455, 68, 68, 68, 68, 68, 1449, + 1447, 68, 68, 68, 1456, 68, 1459, 1454, 1460, 68, + + 1453, 1451, 1457, 1463, 68, 68, 1458, 1465, 68, 68, + 1464, 1462, 1468, 68, 68, 1466, 68, 1461, 1469, 68, + 68, 1467, 1473, 68, 68, 68, 1471, 68, 1470, 1475, + 1477, 68, 1474, 1480, 68, 68, 1472, 1481, 68, 68, + 68, 1485, 68, 1610, 1476, 1484, 1482, 68, 1478, 1479, + 1486, 68, 1488, 1483, 1487, 68, 1489, 68, 68, 1490, + 1491, 68, 68, 68, 1494, 68, 68, 1492, 68, 68, + 68, 1493, 68, 1495, 1496, 68, 68, 68, 1504, 68, + 68, 1502, 68, 68, 1497, 68, 1498, 1505, 68, 1499, + 1500, 1506, 68, 68, 68, 1509, 1501, 1503, 1507, 1508, + + 68, 1511, 68, 1510, 68, 68, 68, 1512, 1513, 1514, + 1515, 1516, 1518, 68, 1519, 68, 1520, 68, 68, 68, + 1522, 1523, 68, 1517, 68, 68, 68, 68, 68, 1525, + 1521, 68, 1529, 68, 68, 68, 1524, 68, 68, 68, + 68, 1537, 68, 68, 1526, 1527, 68, 1528, 1531, 68, + 68, 1539, 1533, 1530, 1534, 1536, 1532, 68, 1538, 68, + 68, 1543, 1540, 68, 1535, 1542, 68, 1547, 1541, 1548, + 68, 68, 68, 1544, 68, 1545, 68, 68, 68, 68, + 68, 68, 1546, 68, 1549, 68, 68, 1560, 1557, 1550, + 1551, 1552, 1554, 1555, 68, 68, 68, 1553, 68, 1558, + + 1556, 1561, 68, 1562, 1559, 1565, 68, 1563, 1566, 68, + 68, 68, 68, 1567, 1564, 1570, 68, 68, 68, 68, + 68, 68, 1573, 68, 68, 1577, 68, 68, 68, 68, + 1568, 1569, 1572, 1578, 1582, 1571, 1576, 1574, 68, 1580, + 1575, 68, 1581, 68, 68, 1579, 1584, 1585, 68, 68, + 1583, 1586, 68, 68, 68, 68, 1587, 68, 1589, 68, + 1591, 68, 1592, 68, 1595, 68, 68, 68, 1598, 1599, + 68, 1588, 68, 1590, 1601, 68, 1602, 68, 1593, 1600, + 1594, 68, 68, 68, 1596, 1597, 68, 1604, 1603, 68, + 1610, 1605, 1608, 68, 1609, 68, 1610, 1610, 1610, 1610, + + 1610, 1610, 1606, 1610, 1610, 1610, 1610, 1610, 1607, 40, + 40, 40, 40, 40, 40, 40, 45, 45, 45, 45, + 45, 45, 45, 50, 50, 50, 50, 50, 50, 50, + 56, 56, 56, 56, 56, 56, 56, 61, 61, 61, + 61, 61, 61, 61, 71, 71, 1610, 71, 71, 71, + 71, 123, 123, 1610, 1610, 1610, 123, 123, 125, 125, + 1610, 1610, 125, 1610, 125, 127, 1610, 1610, 1610, 1610, + 1610, 127, 130, 130, 1610, 1610, 1610, 130, 130, 132, + 1610, 1610, 1610, 1610, 1610, 132, 134, 134, 1610, 134, + 134, 134, 134, 72, 72, 1610, 72, 72, 72, 72, + + 13, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610 } ; -static yyconst flex_int16_t yy_chk[2876] = +static yyconst flex_int16_t yy_chk[3241] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -1227,7 +1330,7 @@ static yyconst flex_int16_t yy_chk[2876] = 9, 151, 33, 6, 7, 7, 7, 7, 9, 7, 10, 10, 10, 44, 44, 7, 8, 8, 8, 8, 10, 8, 21, 33, 151, 21, 21, 8, 11, 11, - 11, 11, 11, 11, 1425, 20, 29, 20, 20, 11, + 11, 11, 11, 11, 1616, 20, 29, 20, 20, 11, 20, 29, 24, 21, 25, 20, 24, 28, 11, 12, 12, 12, 12, 12, 12, 74, 22, 22, 74, 25, @@ -1245,7 +1348,7 @@ static yyconst flex_int16_t yy_chk[2876] = 81, 83, 78, 68, 71, 79, 71, 71, 84, 71, 85, 80, 86, 84, 71, 71, 87, 88, 81, 82, 83, 89, 90, 91, 85, 89, 84, 90, 94, 97, - 92, 615, 86, 92, 87, 88, 92, 91, 93, 95, + 92, 625, 86, 92, 87, 88, 92, 91, 93, 95, 98, 104, 96, 93, 95, 96, 103, 94, 99, 96, 92, 100, 99, 97, 98, 102, 105, 106, 100, 103, 105, 104, 102, 107, 95, 108, 109, 111, 107, 112, @@ -1256,284 +1359,324 @@ static yyconst flex_int16_t yy_chk[2876] = 121, 126, 131, 131, 119, 140, 139, 128, 122, 128, 128, 133, 128, 133, 133, 134, 133, 134, 134, 136, 134, 139, 136, 137, 138, 141, 134, 142, 137, 138, - 143, 149, 144, 145, 160, 143, 143, 144, 145, 146, - 141, 146, 148, 148, 150, 154, 155, 142, 147, 150, - 149, 152, 147, 153, 160, 152, 157, 147, 153, 154, - 156, 155, 147, 159, 159, 158, 161, 167, 147, 147, - 158, 162, 156, 130, 157, 156, 162, 163, 163, 164, - - 165, 168, 161, 166, 164, 165, 168, 174, 167, 169, - 164, 170, 166, 171, 169, 172, 170, 175, 171, 176, - 177, 178, 172, 175, 179, 180, 181, 174, 177, 183, - 180, 182, 184, 185, 183, 185, 178, 187, 186, 188, - 129, 176, 187, 189, 179, 186, 190, 190, 181, 182, - 182, 191, 184, 194, 192, 189, 191, 195, 188, 192, - 193, 196, 193, 197, 201, 194, 198, 199, 197, 196, - 200, 198, 201, 202, 191, 203, 195, 207, 203, 193, - 204, 204, 199, 205, 206, 206, 205, 208, 200, 209, - 210, 211, 209, 207, 210, 213, 212, 217, 202, 219, - - 211, 212, 208, 214, 214, 215, 216, 218, 220, 213, - 215, 216, 221, 221, 222, 223, 224, 217, 225, 223, - 219, 220, 227, 225, 226, 218, 228, 226, 224, 229, - 230, 231, 222, 232, 227, 234, 234, 233, 229, 233, - 233, 236, 237, 228, 231, 232, 228, 235, 239, 239, - 235, 230, 242, 238, 240, 241, 241, 237, 236, 240, - 243, 236, 238, 244, 245, 246, 247, 242, 244, 247, - 246, 247, 248, 249, 250, 253, 251, 252, 254, 256, - 243, 251, 252, 250, 245, 255, 248, 257, 258, 249, - 257, 265, 249, 256, 249, 261, 253, 260, 254, 262, - - 255, 264, 258, 266, 261, 263, 257, 259, 266, 259, - 259, 265, 260, 267, 268, 269, 264, 271, 276, 259, - 262, 259, 259, 259, 263, 272, 259, 270, 127, 268, - 269, 273, 270, 267, 277, 274, 273, 271, 276, 272, - 274, 275, 275, 278, 275, 280, 279, 280, 281, 282, - 277, 283, 281, 284, 285, 125, 286, 288, 293, 278, - 279, 286, 284, 285, 287, 283, 288, 282, 287, 289, - 290, 293, 296, 291, 289, 284, 290, 291, 292, 294, - 294, 295, 297, 292, 298, 299, 295, 300, 300, 299, - 301, 297, 302, 296, 306, 301, 298, 303, 303, 305, - - 305, 307, 308, 311, 309, 312, 313, 314, 317, 307, - 315, 308, 314, 302, 316, 306, 309, 318, 315, 316, - 313, 319, 321, 311, 320, 312, 317, 322, 320, 323, - 324, 327, 322, 326, 330, 329, 328, 321, 329, 318, - 332, 328, 319, 331, 331, 323, 328, 327, 334, 324, - 325, 325, 335, 326, 330, 336, 325, 338, 325, 333, - 333, 337, 339, 334, 335, 332, 325, 339, 340, 341, - 336, 342, 345, 346, 343, 123, 325, 340, 343, 338, - 337, 347, 344, 349, 345, 350, 342, 344, 341, 348, - 348, 346, 352, 351, 347, 349, 351, 350, 353, 354, - - 355, 353, 356, 356, 357, 357, 358, 352, 359, 359, - 362, 358, 67, 355, 361, 354, 360, 360, 354, 361, - 363, 368, 364, 365, 371, 363, 364, 367, 365, 366, - 369, 362, 367, 366, 370, 369, 374, 372, 371, 370, - 372, 368, 373, 373, 376, 372, 375, 377, 378, 372, - 377, 375, 378, 376, 374, 379, 380, 381, 383, 382, - 379, 384, 381, 388, 386, 385, 384, 386, 388, 380, - 383, 385, 389, 387, 378, 382, 387, 390, 391, 392, - 393, 395, 392, 391, 394, 393, 395, 396, 394, 394, - 389, 390, 397, 398, 400, 397, 396, 398, 398, 399, - - 401, 399, 401, 402, 403, 404, 405, 406, 407, 412, - 397, 406, 408, 400, 409, 410, 418, 407, 411, 413, - 413, 402, 403, 411, 404, 414, 405, 408, 412, 414, - 410, 415, 409, 416, 417, 418, 419, 420, 416, 422, - 421, 425, 415, 423, 420, 421, 422, 424, 423, 419, - 417, 426, 424, 427, 428, 429, 432, 441, 426, 425, - 429, 430, 427, 431, 430, 433, 433, 431, 428, 436, - 435, 437, 438, 436, 433, 435, 439, 432, 440, 442, - 445, 449, 441, 437, 439, 450, 448, 449, 451, 450, - 438, 454, 61, 451, 442, 448, 440, 445, 452, 453, - - 452, 455, 452, 456, 453, 452, 456, 457, 457, 454, - 452, 458, 459, 459, 460, 464, 452, 452, 458, 461, - 461, 462, 463, 465, 462, 466, 455, 463, 468, 460, - 467, 467, 469, 466, 470, 464, 471, 471, 478, 470, - 472, 473, 465, 468, 474, 472, 473, 474, 475, 476, - 469, 477, 487, 479, 475, 480, 478, 476, 479, 477, - 481, 481, 480, 482, 483, 484, 487, 486, 489, 483, - 486, 482, 488, 488, 490, 492, 493, 490, 494, 496, - 495, 493, 497, 489, 484, 490, 498, 499, 500, 501, - 503, 499, 504, 505, 502, 498, 492, 506, 504, 494, - - 495, 496, 497, 502, 503, 507, 500, 508, 501, 510, - 507, 506, 508, 505, 509, 511, 512, 513, 509, 514, - 514, 512, 516, 517, 515, 516, 518, 511, 510, 515, - 519, 520, 521, 521, 523, 519, 522, 522, 513, 518, - 524, 517, 525, 526, 524, 527, 529, 530, 532, 523, - 529, 520, 533, 531, 536, 534, 535, 533, 537, 527, - 538, 525, 530, 532, 544, 544, 538, 526, 528, 534, - 535, 528, 537, 528, 56, 536, 539, 528, 531, 528, - 541, 539, 540, 540, 528, 541, 542, 543, 540, 545, - 540, 547, 548, 546, 545, 549, 549, 554, 550, 543, - - 542, 546, 550, 553, 552, 547, 553, 555, 540, 552, - 556, 548, 557, 558, 559, 556, 554, 561, 560, 563, - 555, 562, 558, 560, 564, 566, 568, 567, 563, 564, - 585, 557, 51, 559, 569, 562, 585, 561, 570, 569, - 572, 568, 571, 570, 566, 567, 579, 571, 574, 572, - 573, 573, 576, 574, 577, 577, 576, 576, 577, 578, - 580, 579, 578, 581, 582, 583, 581, 584, 586, 587, - 583, 590, 584, 588, 588, 587, 591, 589, 592, 591, - 580, 593, 594, 50, 586, 582, 589, 596, 595, 590, - 597, 598, 596, 600, 599, 597, 592, 599, 601, 604, - - 593, 595, 594, 602, 600, 606, 603, 607, 602, 598, - 601, 603, 605, 605, 604, 608, 609, 610, 612, 611, - 609, 607, 613, 617, 606, 616, 618, 608, 611, 619, - 622, 620, 627, 45, 619, 610, 620, 612, 617, 616, - 621, 623, 625, 624, 622, 621, 618, 613, 624, 626, - 629, 627, 628, 628, 630, 623, 631, 625, 632, 634, - 630, 633, 636, 638, 626, 635, 633, 632, 629, 637, - 635, 639, 638, 637, 640, 641, 631, 642, 634, 643, - 644, 636, 645, 647, 646, 648, 639, 641, 645, 640, - 650, 651, 653, 652, 648, 650, 642, 654, 644, 646, - - 643, 652, 654, 647, 655, 651, 656, 657, 655, 655, - 658, 659, 653, 660, 660, 664, 659, 661, 662, 658, - 657, 666, 661, 662, 664, 656, 663, 663, 665, 667, - 673, 668, 669, 665, 670, 666, 668, 669, 671, 670, - 672, 673, 671, 677, 675, 676, 679, 667, 675, 672, - 678, 680, 681, 682, 672, 683, 672, 685, 672, 680, - 676, 677, 684, 684, 678, 679, 681, 686, 686, 689, - 688, 682, 685, 688, 689, 690, 691, 691, 692, 694, - 683, 693, 693, 696, 694, 695, 695, 697, 698, 701, - 699, 702, 697, 709, 690, 699, 698, 702, 692, 700, - - 700, 703, 709, 696, 705, 706, 707, 701, 703, 705, - 706, 707, 708, 710, 711, 712, 712, 708, 713, 714, - 716, 715, 721, 717, 720, 711, 715, 718, 719, 719, - 722, 723, 710, 728, 724, 729, 733, 730, 713, 724, - 716, 728, 714, 717, 720, 718, 726, 721, 722, 727, - 726, 726, 731, 732, 723, 730, 733, 731, 727, 734, - 735, 729, 736, 734, 739, 737, 743, 738, 740, 741, - 742, 732, 745, 740, 746, 742, 741, 744, 735, 737, - 746, 736, 738, 739, 743, 747, 744, 745, 748, 749, - 750, 751, 751, 748, 749, 750, 753, 753, 754, 755, - - 756, 758, 758, 754, 757, 759, 747, 760, 757, 757, - 761, 762, 763, 755, 765, 764, 766, 769, 763, 756, - 764, 767, 768, 770, 759, 40, 760, 771, 772, 772, - 762, 769, 773, 765, 774, 766, 761, 773, 774, 775, - 767, 768, 771, 777, 770, 776, 778, 778, 779, 781, - 784, 780, 775, 779, 776, 780, 782, 786, 787, 787, - 788, 782, 786, 777, 796, 788, 790, 790, 784, 781, - 792, 792, 794, 795, 795, 794, 797, 798, 799, 796, - 800, 801, 801, 799, 802, 803, 803, 804, 805, 806, - 810, 798, 807, 806, 813, 800, 811, 808, 814, 805, - - 815, 797, 808, 819, 802, 812, 812, 817, 810, 804, - 811, 807, 817, 816, 813, 816, 818, 820, 814, 824, - 815, 818, 822, 819, 821, 821, 825, 825, 822, 826, - 827, 820, 828, 829, 826, 828, 830, 830, 829, 831, - 832, 833, 834, 824, 835, 836, 838, 834, 837, 837, - 836, 838, 839, 840, 841, 827, 843, 831, 842, 832, - 845, 833, 844, 846, 847, 845, 848, 835, 843, 851, - 839, 850, 842, 840, 841, 844, 851, 853, 861, 852, - 856, 856, 857, 846, 847, 857, 850, 848, 852, 858, - 859, 852, 860, 853, 858, 862, 863, 861, 864, 865, - - 865, 860, 866, 864, 862, 863, 859, 862, 867, 868, - 869, 870, 871, 872, 872, 873, 874, 877, 876, 880, - 878, 867, 866, 876, 869, 878, 879, 868, 881, 882, - 871, 873, 879, 881, 874, 877, 870, 883, 887, 880, - 883, 886, 882, 888, 889, 890, 883, 892, 891, 886, - 890, 887, 894, 895, 896, 897, 900, 895, 901, 896, - 897, 888, 898, 889, 891, 892, 899, 898, 902, 902, - 903, 904, 894, 901, 905, 899, 906, 907, 908, 900, - 14, 906, 909, 904, 903, 913, 905, 915, 909, 907, - 910, 910, 911, 911, 913, 918, 908, 914, 914, 915, - - 916, 916, 917, 919, 920, 921, 921, 917, 922, 923, - 923, 924, 924, 925, 926, 928, 918, 926, 925, 929, - 928, 930, 919, 931, 920, 936, 930, 935, 922, 932, - 932, 933, 933, 934, 937, 938, 939, 929, 934, 935, - 941, 935, 940, 940, 943, 936, 935, 945, 931, 942, - 942, 946, 946, 947, 937, 938, 945, 939, 948, 950, - 949, 951, 951, 952, 943, 948, 941, 953, 947, 949, - 955, 956, 957, 958, 960, 955, 956, 959, 959, 960, - 958, 961, 962, 953, 963, 950, 964, 966, 965, 952, - 961, 967, 957, 966, 968, 968, 969, 970, 970, 963, - - 967, 971, 962, 965, 972, 964, 973, 969, 974, 974, - 975, 973, 969, 977, 975, 975, 976, 978, 972, 979, - 980, 976, 971, 981, 979, 982, 983, 981, 984, 978, - 985, 986, 980, 984, 987, 989, 986, 982, 989, 977, - 990, 990, 991, 991, 992, 995, 987, 998, 993, 994, - 992, 983, 985, 993, 995, 994, 1000, 1002, 1002, 998, - 1003, 1004, 1005, 1007, 1007, 1010, 1012, 1011, 1000, 1002, - 1004, 1005, 1011, 1013, 1013, 1014, 1018, 1014, 1003, 1010, - 1015, 1015, 1017, 1012, 1019, 1019, 1020, 1021, 1022, 1017, - 1023, 1024, 1025, 1027, 1030, 1028, 1018, 1028, 1027, 1021, - - 1022, 1029, 1023, 1030, 1032, 1034, 1024, 1020, 1033, 1033, - 1035, 1036, 1025, 1036, 1039, 1035, 1037, 1038, 1032, 1029, - 1040, 1037, 1038, 1041, 1042, 1044, 1047, 1045, 1041, 1042, - 1048, 1034, 1039, 1046, 1046, 1049, 1050, 1049, 1047, 1048, - 1040, 1045, 1048, 1051, 1044, 1050, 1053, 1054, 1056, 1057, - 1058, 1053, 1054, 1060, 1062, 1051, 1063, 1064, 1065, 1060, - 1062, 1056, 1066, 1066, 1067, 1069, 1058, 1065, 1070, 1057, - 1072, 1063, 1070, 1067, 1068, 1068, 1071, 1073, 1073, 1074, - 1077, 1071, 1064, 1072, 1069, 1078, 1078, 1074, 1080, 1077, - 1079, 1079, 1081, 1082, 1082, 1083, 1084, 1081, 1085, 1083, - - 1080, 1086, 1087, 1085, 1089, 1090, 1092, 1096, 1091, 1093, - 1096, 1084, 1095, 1095, 1099, 1099, 1100, 1100, 1092, 1097, - 1098, 1087, 1101, 1101, 1090, 1102, 1105, 1086, 1089, 1091, - 1093, 1108, 1097, 1098, 1103, 1103, 1104, 1104, 1102, 1106, - 1106, 1107, 1107, 1110, 1112, 1105, 1111, 1111, 1110, 1114, - 1108, 1113, 1113, 1115, 1116, 1117, 1117, 1116, 1119, 1115, - 1118, 1118, 1123, 1112, 1120, 1120, 1125, 1114, 1122, 1122, - 1126, 1117, 1124, 1124, 1127, 1125, 1128, 1119, 1129, 1127, - 1131, 1130, 1126, 1132, 1133, 1131, 1134, 1136, 1123, 1135, - 1137, 1129, 1136, 1133, 1137, 1134, 1139, 1141, 1132, 1142, - - 1142, 1128, 1130, 1135, 1143, 1146, 1141, 13, 1150, 1143, - 1144, 1144, 1147, 1150, 1149, 1154, 1139, 1149, 1154, 1144, - 1146, 1151, 1151, 1153, 1147, 1155, 1155, 1153, 1156, 1157, - 1158, 1159, 1160, 1156, 1158, 1161, 1162, 1160, 1164, 1165, - 1161, 1167, 1162, 1167, 1165, 1166, 1170, 1170, 1184, 1157, - 1183, 1159, 1176, 1166, 1164, 1173, 1173, 1176, 1177, 1177, - 1179, 1179, 1181, 1182, 1182, 1192, 1183, 1181, 1185, 1190, - 1184, 1187, 1187, 1185, 1190, 1191, 1193, 1191, 1197, 1192, - 1198, 1193, 1194, 1194, 1195, 1195, 1196, 1196, 1199, 1200, - 1197, 1201, 1202, 1203, 1204, 1204, 1205, 1202, 1198, 1206, - - 1199, 1200, 1207, 1201, 1208, 1205, 1209, 1210, 1211, 1212, - 1213, 1214, 1214, 1203, 1212, 1213, 1216, 1208, 1217, 1217, - 1220, 1210, 1207, 1219, 1219, 1206, 1211, 1221, 1222, 1220, - 1209, 1223, 1224, 1225, 1216, 1226, 1226, 1229, 1227, 1228, - 1230, 1235, 1221, 1227, 1232, 0, 1222, 1236, 1224, 1223, - 1236, 1238, 1225, 1239, 1228, 1242, 1229, 1237, 1237, 1249, - 1230, 1235, 0, 1232, 1241, 1241, 1238, 1243, 1243, 1244, - 1244, 1239, 1248, 1248, 1242, 1250, 1253, 1251, 1252, 1254, - 1267, 1249, 1251, 1252, 1250, 1256, 1257, 1254, 1258, 1259, - 1300, 1257, 1267, 1258, 1300, 1253, 1260, 1260, 1261, 1261, - - 1256, 1262, 1263, 1263, 1259, 1266, 1262, 1264, 1264, 1269, - 1266, 1270, 1269, 1271, 1272, 1273, 1273, 1274, 1276, 1277, - 1278, 1278, 1271, 1272, 1270, 1279, 1274, 1280, 1280, 1285, - 1282, 1281, 1284, 1290, 1279, 1282, 0, 1276, 1277, 1281, - 1296, 1284, 1285, 1287, 1287, 1291, 1291, 1292, 1293, 1293, - 1292, 1294, 1294, 1290, 1295, 1295, 1297, 1298, 1296, 1299, - 1299, 1303, 1298, 1306, 1307, 1308, 1312, 1303, 1309, 1309, - 1297, 1310, 1307, 1311, 1313, 1315, 1314, 1317, 1311, 1319, - 1317, 1326, 1306, 1322, 1308, 1314, 1312, 1310, 1320, 1320, - 1321, 1325, 1322, 1324, 1321, 1315, 1330, 1319, 1331, 1331, - - 1313, 1330, 1324, 1325, 1332, 1334, 1326, 1335, 1336, 1337, - 1334, 1338, 1338, 1332, 1339, 1340, 1335, 1341, 1342, 1344, - 1343, 1345, 1350, 1339, 1337, 1343, 1342, 1336, 1346, 1346, - 1347, 1340, 1349, 1349, 1351, 1347, 1341, 1352, 1352, 1354, - 1345, 1355, 1350, 1353, 1353, 1344, 1356, 1357, 1357, 1358, - 1359, 1359, 1360, 1355, 1362, 1363, 1351, 0, 1354, 0, - 1363, 1358, 1364, 1364, 1365, 1365, 1356, 1367, 1362, 1366, - 1366, 1360, 1367, 1368, 1368, 1370, 1370, 1372, 1372, 1373, - 1376, 1377, 1377, 1382, 1373, 1378, 1380, 1393, 1376, 1395, - 1378, 1380, 1383, 1383, 1384, 1388, 1388, 1390, 1384, 1392, - - 1392, 1390, 1393, 1382, 1396, 1396, 1403, 1395, 1397, 1397, - 1399, 1399, 1401, 1401, 1404, 1404, 1409, 1410, 1403, 1412, - 1409, 1411, 1411, 1414, 1416, 1415, 1417, 1417, 1412, 0, - 0, 0, 0, 0, 0, 0, 0, 1410, 1414, 1415, - 0, 0, 0, 1416, 1420, 1420, 1420, 1420, 1420, 1420, - 1420, 1421, 1421, 1421, 1421, 1421, 1421, 1421, 1422, 1422, - 1422, 1422, 1422, 1422, 1422, 1423, 1423, 1423, 1423, 1423, - 1423, 1423, 1424, 1424, 1424, 1424, 1424, 1424, 1424, 1426, - 1426, 0, 1426, 1426, 1426, 1426, 1427, 1427, 0, 0, - 0, 1427, 1427, 1428, 1428, 0, 0, 1428, 0, 1428, - - 1429, 0, 0, 0, 0, 0, 1429, 1430, 1430, 0, - 0, 0, 1430, 1430, 1431, 0, 0, 0, 0, 0, - 1431, 1432, 1432, 0, 1432, 1432, 1432, 1432, 1433, 1433, - 0, 1433, 1433, 1433, 1433, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, - 1419, 1419, 1419, 1419, 1419 + 143, 149, 144, 145, 130, 143, 143, 144, 145, 146, + 141, 146, 148, 148, 150, 154, 153, 142, 152, 150, + 149, 153, 152, 155, 157, 156, 159, 159, 158, 154, + 160, 146, 147, 158, 162, 161, 147, 156, 155, 162, + 156, 147, 157, 163, 163, 167, 147, 177, 166, 164, + + 160, 161, 147, 147, 164, 177, 165, 166, 168, 169, + 164, 165, 170, 168, 169, 171, 167, 170, 172, 174, + 171, 175, 176, 178, 180, 172, 179, 175, 181, 180, + 182, 183, 184, 185, 186, 185, 183, 187, 178, 174, + 188, 186, 187, 189, 176, 193, 179, 193, 182, 182, + 181, 191, 184, 190, 190, 189, 191, 192, 194, 188, + 195, 196, 192, 197, 193, 199, 198, 200, 197, 196, + 194, 198, 202, 201, 191, 203, 204, 204, 203, 195, + 199, 201, 208, 205, 209, 200, 205, 206, 206, 207, + 207, 210, 211, 212, 210, 213, 211, 202, 208, 209, + + 213, 214, 212, 215, 215, 216, 217, 218, 219, 220, + 216, 217, 221, 222, 222, 214, 223, 224, 226, 225, + 229, 224, 231, 226, 228, 221, 219, 218, 232, 227, + 220, 225, 227, 230, 223, 233, 228, 229, 235, 235, + 229, 232, 230, 231, 237, 238, 234, 233, 234, 234, + 236, 240, 240, 236, 239, 242, 242, 241, 243, 244, + 238, 237, 241, 239, 237, 245, 246, 247, 249, 250, + 245, 248, 247, 243, 248, 251, 248, 254, 252, 244, + 255, 256, 249, 252, 251, 250, 246, 253, 250, 257, + 250, 258, 253, 259, 258, 262, 256, 261, 254, 263, + + 255, 265, 264, 257, 262, 296, 296, 259, 266, 268, + 258, 260, 261, 260, 260, 272, 265, 267, 269, 270, + 263, 264, 267, 260, 273, 260, 260, 260, 266, 268, + 260, 271, 274, 269, 270, 272, 271, 274, 273, 275, + 276, 277, 277, 278, 277, 276, 279, 281, 280, 282, + 283, 282, 284, 285, 283, 275, 286, 287, 302, 302, + 290, 281, 279, 278, 280, 286, 287, 285, 288, 290, + 284, 289, 291, 288, 292, 289, 294, 291, 286, 293, + 292, 294, 295, 293, 297, 298, 300, 299, 301, 297, + 304, 308, 301, 129, 303, 295, 299, 309, 300, 303, + + 305, 305, 307, 307, 310, 309, 298, 311, 313, 314, + 315, 304, 308, 310, 317, 316, 318, 319, 320, 311, + 316, 318, 317, 321, 315, 325, 322, 323, 313, 314, + 322, 324, 326, 329, 328, 319, 324, 332, 330, 334, + 320, 325, 323, 330, 321, 333, 333, 331, 330, 329, + 331, 326, 327, 327, 328, 335, 335, 332, 327, 336, + 327, 337, 338, 339, 334, 340, 341, 342, 327, 343, + 344, 341, 347, 337, 336, 345, 342, 338, 327, 345, + 348, 346, 339, 349, 347, 344, 346, 340, 343, 350, + 350, 351, 352, 354, 353, 356, 349, 353, 348, 355, + + 358, 357, 355, 351, 352, 357, 357, 361, 354, 359, + 359, 356, 361, 358, 356, 360, 360, 362, 362, 363, + 363, 364, 365, 366, 371, 367, 364, 368, 366, 367, + 369, 370, 368, 372, 369, 373, 370, 374, 372, 377, + 373, 127, 375, 365, 371, 375, 376, 376, 378, 379, + 375, 374, 380, 378, 375, 380, 381, 377, 379, 382, + 381, 383, 384, 385, 382, 386, 387, 384, 392, 388, + 389, 387, 125, 389, 383, 388, 393, 386, 390, 385, + 391, 390, 381, 394, 395, 391, 392, 395, 394, 396, + 393, 397, 398, 399, 396, 397, 397, 398, 400, 401, + + 403, 400, 399, 401, 401, 402, 404, 402, 404, 405, + 406, 407, 408, 409, 410, 415, 400, 409, 411, 403, + 412, 413, 421, 410, 414, 416, 416, 405, 406, 414, + 407, 417, 408, 411, 415, 417, 413, 418, 412, 419, + 420, 421, 422, 423, 419, 425, 424, 428, 418, 426, + 423, 424, 425, 427, 426, 422, 420, 429, 427, 430, + 431, 432, 435, 444, 429, 428, 432, 433, 430, 434, + 433, 436, 436, 434, 431, 439, 438, 440, 441, 439, + 436, 438, 442, 435, 443, 447, 453, 450, 444, 440, + 442, 454, 460, 459, 455, 453, 441, 454, 455, 123, + + 447, 456, 443, 445, 450, 458, 456, 463, 445, 465, + 458, 459, 445, 461, 463, 445, 461, 460, 462, 462, + 464, 464, 445, 469, 465, 445, 457, 470, 457, 67, + 457, 466, 466, 457, 467, 468, 473, 467, 457, 471, + 468, 472, 472, 469, 457, 457, 470, 471, 474, 475, + 477, 473, 476, 476, 475, 477, 478, 479, 480, 481, + 479, 478, 482, 483, 480, 485, 474, 481, 484, 487, + 482, 488, 485, 484, 486, 486, 488, 487, 489, 491, + 492, 483, 491, 493, 493, 494, 497, 495, 498, 499, + 495, 500, 501, 498, 492, 502, 503, 489, 495, 504, + + 494, 505, 506, 504, 507, 503, 508, 497, 510, 511, + 499, 500, 509, 507, 501, 502, 515, 512, 509, 505, + 508, 506, 512, 511, 513, 516, 514, 517, 510, 513, + 514, 518, 517, 519, 519, 515, 520, 516, 522, 521, + 523, 520, 521, 524, 525, 526, 526, 528, 524, 527, + 527, 529, 518, 523, 530, 529, 522, 531, 532, 534, + 535, 536, 528, 534, 525, 537, 538, 553, 61, 539, + 540, 538, 532, 530, 541, 535, 546, 542, 541, 553, + 537, 531, 533, 539, 540, 533, 536, 533, 545, 543, + 544, 533, 542, 533, 543, 544, 547, 546, 533, 548, + + 558, 549, 545, 552, 543, 548, 549, 550, 550, 551, + 547, 554, 554, 550, 551, 550, 555, 552, 556, 558, + 557, 555, 559, 559, 560, 562, 556, 564, 560, 563, + 562, 565, 563, 550, 557, 566, 567, 569, 568, 571, + 566, 573, 576, 570, 565, 578, 564, 568, 570, 572, + 573, 577, 574, 579, 611, 567, 569, 574, 579, 571, + 578, 576, 580, 572, 582, 581, 611, 580, 590, 577, + 581, 583, 583, 582, 584, 588, 586, 589, 588, 584, + 586, 586, 587, 587, 591, 592, 587, 591, 590, 593, + 594, 595, 589, 596, 593, 594, 597, 595, 598, 598, + + 600, 599, 597, 602, 601, 603, 592, 601, 604, 596, + 599, 606, 605, 608, 607, 610, 606, 609, 600, 607, + 609, 602, 612, 614, 603, 605, 610, 612, 604, 613, + 616, 608, 615, 615, 613, 618, 617, 619, 614, 620, + 622, 619, 621, 623, 626, 627, 628, 618, 629, 616, + 617, 621, 56, 629, 637, 632, 630, 620, 626, 622, + 627, 630, 631, 633, 635, 634, 628, 631, 623, 632, + 634, 636, 639, 637, 638, 638, 640, 633, 641, 635, + 642, 642, 640, 643, 644, 645, 636, 647, 643, 646, + 639, 644, 646, 648, 650, 649, 651, 652, 641, 645, + + 649, 651, 648, 653, 655, 647, 654, 653, 656, 657, + 658, 659, 660, 650, 661, 654, 652, 663, 662, 655, + 661, 657, 664, 656, 667, 669, 745, 668, 745, 658, + 660, 664, 659, 662, 666, 668, 670, 663, 667, 666, + 672, 670, 671, 673, 674, 669, 671, 671, 683, 675, + 676, 676, 677, 674, 675, 678, 673, 677, 680, 672, + 678, 679, 679, 681, 682, 684, 683, 680, 681, 685, + 684, 686, 688, 687, 685, 691, 686, 687, 682, 691, + 689, 688, 692, 693, 694, 695, 688, 696, 688, 697, + 688, 689, 698, 699, 701, 696, 706, 692, 694, 700, + + 700, 693, 705, 697, 695, 702, 702, 705, 704, 701, + 698, 704, 707, 707, 708, 706, 709, 709, 699, 710, + 711, 711, 712, 713, 710, 714, 715, 717, 713, 716, + 716, 715, 718, 714, 708, 721, 719, 726, 718, 722, + 721, 723, 712, 719, 722, 717, 723, 724, 725, 727, + 728, 728, 724, 729, 730, 732, 726, 725, 731, 733, + 727, 736, 734, 731, 735, 735, 737, 738, 748, 739, + 750, 740, 748, 729, 746, 732, 740, 730, 742, 733, + 734, 736, 742, 742, 743, 738, 744, 749, 746, 750, + 747, 737, 739, 743, 744, 747, 751, 752, 749, 753, + + 754, 755, 756, 759, 753, 757, 756, 758, 761, 760, + 765, 762, 763, 769, 51, 752, 762, 759, 754, 763, + 764, 755, 751, 757, 760, 764, 758, 761, 765, 766, + 767, 768, 773, 773, 769, 770, 771, 768, 766, 772, + 770, 771, 775, 775, 772, 767, 776, 777, 778, 779, + 781, 776, 782, 779, 779, 780, 780, 783, 784, 785, + 787, 777, 788, 786, 791, 785, 789, 778, 786, 781, + 790, 782, 792, 793, 794, 794, 796, 784, 791, 787, + 796, 788, 795, 783, 797, 789, 798, 795, 793, 790, + 799, 800, 800, 792, 801, 798, 802, 797, 803, 801, + + 802, 804, 806, 808, 809, 809, 804, 810, 808, 819, + 799, 818, 810, 812, 812, 814, 814, 820, 803, 816, + 806, 822, 816, 817, 817, 821, 818, 823, 823, 824, + 821, 820, 825, 825, 819, 826, 822, 827, 828, 829, + 830, 832, 828, 834, 834, 830, 833, 835, 827, 824, + 836, 837, 838, 841, 838, 842, 839, 826, 829, 832, + 833, 839, 846, 840, 843, 843, 844, 835, 840, 842, + 836, 837, 844, 841, 847, 847, 848, 849, 850, 855, + 851, 850, 852, 853, 850, 851, 846, 852, 848, 854, + 856, 859, 853, 856, 854, 857, 850, 849, 858, 858, + + 857, 860, 861, 862, 855, 863, 864, 867, 862, 859, + 866, 864, 865, 865, 868, 866, 869, 870, 871, 872, + 860, 873, 861, 874, 875, 867, 873, 876, 863, 880, + 871, 870, 872, 879, 868, 878, 869, 881, 880, 885, + 879, 880, 885, 874, 875, 884, 884, 886, 876, 887, + 878, 888, 886, 881, 889, 890, 892, 891, 893, 893, + 888, 892, 894, 895, 890, 887, 891, 890, 896, 897, + 898, 899, 901, 889, 900, 900, 895, 908, 902, 904, + 905, 907, 894, 897, 904, 906, 896, 907, 901, 899, + 906, 910, 915, 914, 909, 898, 902, 908, 905, 909, + + 911, 914, 916, 911, 910, 915, 917, 918, 919, 911, + 920, 922, 918, 923, 924, 928, 925, 923, 926, 924, + 916, 925, 929, 926, 919, 917, 927, 931, 920, 930, + 930, 922, 932, 933, 934, 927, 935, 929, 928, 934, + 936, 931, 50, 937, 932, 933, 938, 938, 935, 937, + 939, 939, 941, 942, 942, 943, 945, 944, 936, 946, + 947, 941, 944, 948, 949, 945, 951, 943, 948, 950, + 954, 946, 956, 949, 953, 947, 952, 952, 955, 953, + 958, 951, 957, 957, 959, 959, 949, 960, 960, 950, + 961, 954, 956, 962, 964, 961, 962, 955, 965, 964, + + 958, 966, 967, 968, 968, 970, 966, 969, 969, 971, + 970, 972, 973, 974, 975, 977, 965, 976, 976, 978, + 978, 971, 979, 971, 983, 981, 986, 967, 971, 982, + 982, 972, 973, 974, 981, 975, 984, 985, 988, 983, + 989, 977, 979, 984, 987, 987, 985, 993, 991, 992, + 994, 998, 986, 991, 992, 996, 989, 994, 995, 995, + 996, 997, 999, 1000, 988, 1001, 1002, 993, 1005, 1003, + 997, 998, 1002, 1004, 1004, 1006, 1006, 999, 1003, 1005, + 1001, 1007, 1000, 1008, 1005, 1009, 1010, 1010, 1011, 1012, + 1009, 1013, 1011, 1011, 1012, 1014, 1015, 1008, 1016, 1017, + + 1018, 1015, 1007, 1017, 1019, 1021, 1020, 1014, 1022, 1023, + 1016, 1020, 1018, 1022, 45, 1025, 1031, 1013, 1025, 1026, + 1026, 1023, 1027, 1027, 1028, 1031, 1029, 1021, 1030, 1019, + 1028, 1029, 1034, 1036, 1030, 1037, 1037, 1038, 1039, 1042, + 1040, 1041, 1045, 1042, 1034, 1036, 1043, 1039, 1044, 1047, + 1047, 1043, 1048, 1044, 1049, 1050, 1045, 1038, 1040, 1055, + 1041, 1047, 1056, 1049, 1050, 1052, 1052, 1056, 1057, 1063, + 1048, 1058, 1058, 1055, 1059, 1062, 1059, 1060, 1060, 1064, + 1064, 1065, 1062, 1066, 1067, 1057, 1068, 1070, 1069, 1063, + 1074, 1073, 1072, 1073, 1079, 1066, 1067, 1072, 1068, 1077, + + 1075, 1080, 1065, 1069, 1078, 1078, 1080, 1070, 1074, 1075, + 1081, 1082, 1081, 1077, 1083, 1084, 1082, 1085, 1086, 1083, + 1079, 1087, 1089, 1086, 1090, 40, 1087, 1091, 1091, 1102, + 1092, 1093, 1094, 1084, 1094, 1095, 1096, 1085, 1090, 1101, + 1093, 1089, 1092, 1093, 1095, 1098, 1099, 1103, 1096, 1102, + 1098, 1099, 1101, 1105, 1107, 1108, 1109, 1110, 1112, 1105, + 1107, 1111, 1111, 1103, 1113, 1113, 1110, 1112, 1114, 1115, + 1108, 1116, 1117, 1115, 1118, 1118, 1116, 1129, 1119, 1122, + 1125, 1109, 1123, 1123, 1131, 1117, 1119, 1114, 1122, 1124, + 1124, 1126, 1125, 1127, 1127, 1130, 1126, 1132, 1133, 1134, + + 1130, 1138, 1129, 1133, 1135, 1136, 1136, 1131, 1140, 1137, + 1139, 1141, 1132, 1137, 1143, 1139, 1138, 1134, 1144, 1145, + 1135, 1146, 1147, 1149, 1149, 1150, 1151, 14, 1150, 1152, + 1141, 1153, 1153, 1146, 1140, 1154, 1154, 1144, 1143, 1151, + 1145, 1156, 1152, 1147, 1155, 1155, 1157, 1157, 1158, 1158, + 1159, 1160, 1160, 1162, 1156, 1161, 1161, 1164, 1165, 1165, + 1166, 1169, 1164, 1167, 1167, 1168, 1173, 1169, 1170, 1159, + 1177, 1170, 1162, 1171, 1171, 1172, 1172, 1174, 1174, 1166, + 1176, 1176, 1179, 1168, 1182, 1173, 1178, 1178, 1180, 1171, + 1181, 1179, 1183, 1184, 1185, 1181, 1177, 1186, 1187, 1185, + + 1180, 1188, 1189, 1190, 1193, 1183, 1200, 1187, 1190, 1182, + 1188, 1191, 1186, 1195, 1184, 1191, 1189, 1196, 1196, 1201, + 1197, 1200, 1195, 1204, 1193, 1197, 1198, 1198, 1204, 1203, + 1208, 1201, 1203, 1205, 1205, 1198, 1207, 1207, 1209, 1209, + 1210, 1211, 1212, 1215, 1208, 1213, 1213, 1215, 1216, 1217, + 1217, 1216, 1210, 1218, 1219, 1211, 1220, 1221, 1218, 1222, + 1220, 1212, 1223, 1224, 1222, 1226, 1227, 1223, 1228, 1224, + 1229, 1227, 1229, 1246, 1219, 1238, 1228, 1221, 1232, 1232, + 1238, 1226, 1235, 1235, 1239, 1239, 1241, 1241, 1243, 1244, + 1244, 1245, 1247, 1243, 1254, 1246, 1252, 1247, 1249, 1249, + + 1253, 1252, 1253, 1259, 1255, 1256, 1256, 1245, 1254, 1255, + 1257, 1257, 1258, 1258, 1260, 1259, 1261, 1262, 1263, 1264, + 1265, 1266, 1266, 1268, 1264, 1267, 1269, 1271, 1261, 1262, + 1263, 1270, 1260, 1272, 1267, 1273, 1274, 1275, 1276, 1276, + 1265, 1274, 1275, 1279, 1270, 1281, 1269, 1272, 1280, 1268, + 1282, 1271, 1283, 1273, 1284, 1285, 1286, 1286, 1288, 1288, + 1289, 1283, 1290, 1279, 1291, 1292, 1280, 1281, 1293, 1289, + 1282, 1294, 1297, 1285, 1284, 1295, 1295, 1290, 1298, 1299, + 1296, 1301, 1291, 1292, 1293, 1296, 1304, 1297, 1305, 1307, + 1294, 1305, 1306, 1306, 1308, 1310, 1310, 1298, 1311, 1299, + + 1301, 1312, 1312, 1318, 1307, 1319, 1304, 1313, 1313, 1317, + 1317, 1320, 1308, 1321, 1319, 1322, 1320, 1311, 1321, 1323, + 1325, 1326, 1328, 1327, 1342, 1318, 1326, 1323, 1327, 1329, + 1329, 1330, 1330, 1331, 1322, 1325, 1342, 1328, 1331, 1332, + 1332, 1333, 1333, 1335, 1338, 1336, 1337, 1339, 1335, 1336, + 1340, 1337, 1341, 1338, 1345, 1346, 1344, 1341, 1340, 1344, + 1347, 1349, 1339, 1351, 1346, 1348, 1348, 1345, 1352, 1347, + 1349, 1353, 1353, 1356, 1354, 1355, 1355, 1359, 1360, 1357, + 1365, 1356, 1351, 1354, 1357, 1371, 1359, 1352, 1362, 1362, + 1372, 1360, 1366, 1366, 1367, 1368, 1368, 1367, 1369, 1369, + + 1365, 1370, 1370, 1371, 1372, 1373, 1374, 1374, 1375, 1378, + 1373, 1381, 1375, 1382, 1383, 1378, 1384, 1385, 1382, 1386, + 1386, 1387, 1388, 1389, 1390, 1390, 1393, 1391, 1381, 1381, + 1388, 1385, 1383, 1392, 1394, 1395, 1384, 1396, 1392, 1407, + 1387, 1400, 1389, 1391, 1395, 1398, 1393, 1402, 1398, 1401, + 1401, 1402, 1403, 1405, 1406, 1412, 1412, 1396, 1411, 1400, + 1394, 1403, 1405, 1411, 1407, 1413, 1406, 1415, 1416, 1417, + 1418, 1419, 1415, 1420, 1413, 1418, 1421, 1416, 1420, 1422, + 1422, 1424, 1425, 1426, 1426, 1427, 1428, 1429, 1430, 1419, + 1417, 1432, 1433, 1431, 1427, 1438, 1430, 1425, 1431, 1439, + + 1424, 1421, 1428, 1434, 1434, 1435, 1429, 1437, 1437, 1442, + 1435, 1433, 1440, 1440, 1443, 1438, 1444, 1432, 1441, 1441, + 1446, 1439, 1445, 1445, 1447, 1448, 1443, 1454, 1442, 1447, + 1449, 1450, 1446, 1451, 1451, 1449, 1444, 1453, 1453, 1456, + 1457, 1458, 1458, 13, 1448, 1457, 1454, 1461, 1450, 1450, + 1459, 1459, 1461, 1456, 1460, 1460, 1462, 1462, 1464, 1464, + 1466, 1466, 1467, 1470, 1471, 1471, 1475, 1467, 1472, 1474, + 1476, 1470, 1477, 1472, 1474, 1478, 1479, 1482, 1483, 1483, + 1493, 1479, 1497, 1484, 1475, 1495, 1476, 1484, 1499, 1477, + 1477, 1488, 1488, 1498, 1490, 1493, 1478, 1482, 1490, 1492, + + 1492, 1496, 1496, 1495, 1502, 1500, 1501, 1497, 1498, 1499, + 1500, 1501, 1503, 1503, 1505, 1505, 1507, 1507, 1509, 1510, + 1510, 1512, 1513, 1502, 1514, 1515, 1512, 1516, 1521, 1514, + 1509, 1517, 1521, 1522, 1525, 1523, 1513, 1524, 1526, 1527, + 1528, 1529, 1529, 1533, 1515, 1516, 1531, 1517, 1523, 1530, + 1534, 1531, 1525, 1522, 1526, 1528, 1524, 1532, 1530, 1536, + 1538, 1535, 1532, 1539, 1527, 1534, 1535, 1540, 1533, 1541, + 1542, 1544, 1540, 1536, 1541, 1538, 1543, 1545, 1546, 1547, + 1548, 1549, 1539, 1550, 1542, 1552, 1553, 1553, 1550, 1543, + 1544, 1545, 1547, 1548, 1551, 1557, 1554, 1546, 1555, 1551, + + 1549, 1554, 1556, 1555, 1552, 1558, 1560, 1556, 1559, 1559, + 1558, 1561, 1562, 1560, 1557, 1563, 1564, 1567, 1568, 1565, + 1563, 1569, 1567, 1570, 1571, 1571, 1573, 1578, 1572, 1576, + 1561, 1562, 1565, 1572, 1576, 1564, 1570, 1568, 1574, 1574, + 1569, 1575, 1575, 1577, 1580, 1573, 1578, 1579, 1579, 1581, + 1577, 1580, 1582, 1583, 1584, 1586, 1581, 1587, 1583, 1588, + 1586, 1589, 1587, 1590, 1590, 1591, 1592, 1593, 1593, 1594, + 1594, 1582, 1595, 1584, 1596, 1596, 1597, 1597, 1588, 1595, + 1589, 1598, 1600, 1604, 1591, 1592, 1603, 1600, 1598, 1605, + 0, 1603, 1606, 1606, 1607, 1607, 0, 0, 0, 0, + + 0, 0, 1604, 0, 0, 0, 0, 0, 1605, 1611, + 1611, 1611, 1611, 1611, 1611, 1611, 1612, 1612, 1612, 1612, + 1612, 1612, 1612, 1613, 1613, 1613, 1613, 1613, 1613, 1613, + 1614, 1614, 1614, 1614, 1614, 1614, 1614, 1615, 1615, 1615, + 1615, 1615, 1615, 1615, 1617, 1617, 0, 1617, 1617, 1617, + 1617, 1618, 1618, 0, 0, 0, 1618, 1618, 1619, 1619, + 0, 0, 1619, 0, 1619, 1620, 0, 0, 0, 0, + 0, 1620, 1621, 1621, 0, 0, 0, 1621, 1621, 1622, + 0, 0, 0, 0, 0, 1622, 1623, 1623, 0, 1623, + 1623, 1623, 1623, 1624, 1624, 0, 1624, 1624, 1624, 1624, + + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, + 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610, 1610 } ; static yy_state_type yy_last_accepting_state; @@ -1734,7 +1877,7 @@ static void config_end_include(void) #define YY_NO_INPUT 1 #endif -#line 1736 "" +#line 1879 "" #define INITIAL 0 #define quotedstring 1 @@ -1921,7 +2064,7 @@ YY_DECL #line 197 "./util/configlexer.lex" -#line 1923 "" +#line 2066 "" if ( !(yy_init) ) { @@ -1980,13 +2123,13 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1420 ) + if ( yy_current_state >= 1611 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_base[yy_current_state] != 2836 ); + while ( yy_base[yy_current_state] != 3201 ); yy_find_action: yy_act = yy_accept[yy_current_state]; @@ -2655,40 +2798,111 @@ YY_RULE_SETUP { YDVAR(1, VAR_DNS64_SYNTHALL) } YY_BREAK case 129: -/* rule 129 can match eol */ YY_RULE_SETUP #line 330 "./util/configlexer.lex" -{ LEXOUT(("NL\n")); cfg_parser->line++; } +{ YDVAR(0, VAR_DNSTAP) } YY_BREAK -/* Quoted strings. Strip leading and ending quotes */ case 130: YY_RULE_SETUP +#line 331 "./util/configlexer.lex" +{ YDVAR(1, VAR_DNSTAP_ENABLE) } + YY_BREAK +case 131: +YY_RULE_SETUP +#line 332 "./util/configlexer.lex" +{ YDVAR(1, VAR_DNSTAP_SOCKET_PATH) } + YY_BREAK +case 132: +YY_RULE_SETUP #line 333 "./util/configlexer.lex" +{ YDVAR(1, VAR_DNSTAP_SEND_IDENTITY) } + YY_BREAK +case 133: +YY_RULE_SETUP +#line 334 "./util/configlexer.lex" +{ YDVAR(1, VAR_DNSTAP_SEND_VERSION) } + YY_BREAK +case 134: +YY_RULE_SETUP +#line 335 "./util/configlexer.lex" +{ YDVAR(1, VAR_DNSTAP_IDENTITY) } + YY_BREAK +case 135: +YY_RULE_SETUP +#line 336 "./util/configlexer.lex" +{ YDVAR(1, VAR_DNSTAP_VERSION) } + YY_BREAK +case 136: +YY_RULE_SETUP +#line 337 "./util/configlexer.lex" +{ + YDVAR(1, VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES) } + YY_BREAK +case 137: +YY_RULE_SETUP +#line 339 "./util/configlexer.lex" +{ + YDVAR(1, VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES) } + YY_BREAK +case 138: +YY_RULE_SETUP +#line 341 "./util/configlexer.lex" +{ + YDVAR(1, VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES) } + YY_BREAK +case 139: +YY_RULE_SETUP +#line 343 "./util/configlexer.lex" +{ + YDVAR(1, VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES) } + YY_BREAK +case 140: +YY_RULE_SETUP +#line 345 "./util/configlexer.lex" +{ + YDVAR(1, VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES) } + YY_BREAK +case 141: +YY_RULE_SETUP +#line 347 "./util/configlexer.lex" +{ + YDVAR(1, VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES) } + YY_BREAK +case 142: +/* rule 142 can match eol */ +YY_RULE_SETUP +#line 349 "./util/configlexer.lex" +{ LEXOUT(("NL\n")); cfg_parser->line++; } + YY_BREAK +/* Quoted strings. Strip leading and ending quotes */ +case 143: +YY_RULE_SETUP +#line 352 "./util/configlexer.lex" { BEGIN(quotedstring); LEXOUT(("QS ")); } YY_BREAK case YY_STATE_EOF(quotedstring): -#line 334 "./util/configlexer.lex" +#line 353 "./util/configlexer.lex" { yyerror("EOF inside quoted string"); if(--num_args == 0) { BEGIN(INITIAL); } else { BEGIN(val); } } YY_BREAK -case 131: +case 144: YY_RULE_SETUP -#line 339 "./util/configlexer.lex" +#line 358 "./util/configlexer.lex" { LEXOUT(("STR(%s) ", yytext)); yymore(); } YY_BREAK -case 132: -/* rule 132 can match eol */ +case 145: +/* rule 145 can match eol */ YY_RULE_SETUP -#line 340 "./util/configlexer.lex" +#line 359 "./util/configlexer.lex" { yyerror("newline inside quoted string, no end \""); cfg_parser->line++; BEGIN(INITIAL); } YY_BREAK -case 133: +case 146: YY_RULE_SETUP -#line 342 "./util/configlexer.lex" +#line 361 "./util/configlexer.lex" { LEXOUT(("QE ")); if(--num_args == 0) { BEGIN(INITIAL); } @@ -2701,34 +2915,34 @@ YY_RULE_SETUP } YY_BREAK /* Single Quoted strings. Strip leading and ending quotes */ -case 134: +case 147: YY_RULE_SETUP -#line 354 "./util/configlexer.lex" +#line 373 "./util/configlexer.lex" { BEGIN(singlequotedstr); LEXOUT(("SQS ")); } YY_BREAK case YY_STATE_EOF(singlequotedstr): -#line 355 "./util/configlexer.lex" +#line 374 "./util/configlexer.lex" { yyerror("EOF inside quoted string"); if(--num_args == 0) { BEGIN(INITIAL); } else { BEGIN(val); } } YY_BREAK -case 135: +case 148: YY_RULE_SETUP -#line 360 "./util/configlexer.lex" +#line 379 "./util/configlexer.lex" { LEXOUT(("STR(%s) ", yytext)); yymore(); } YY_BREAK -case 136: -/* rule 136 can match eol */ +case 149: +/* rule 149 can match eol */ YY_RULE_SETUP -#line 361 "./util/configlexer.lex" +#line 380 "./util/configlexer.lex" { yyerror("newline inside quoted string, no end '"); cfg_parser->line++; BEGIN(INITIAL); } YY_BREAK -case 137: +case 150: YY_RULE_SETUP -#line 363 "./util/configlexer.lex" +#line 382 "./util/configlexer.lex" { LEXOUT(("SQE ")); if(--num_args == 0) { BEGIN(INITIAL); } @@ -2741,38 +2955,38 @@ YY_RULE_SETUP } YY_BREAK /* include: directive */ -case 138: +case 151: YY_RULE_SETUP -#line 375 "./util/configlexer.lex" +#line 394 "./util/configlexer.lex" { LEXOUT(("v(%s) ", yytext)); inc_prev = YYSTATE; BEGIN(include); } YY_BREAK case YY_STATE_EOF(include): -#line 377 "./util/configlexer.lex" +#line 396 "./util/configlexer.lex" { yyerror("EOF inside include directive"); BEGIN(inc_prev); } YY_BREAK -case 139: +case 152: YY_RULE_SETUP -#line 381 "./util/configlexer.lex" +#line 400 "./util/configlexer.lex" { LEXOUT(("ISP ")); /* ignore */ } YY_BREAK -case 140: -/* rule 140 can match eol */ +case 153: +/* rule 153 can match eol */ YY_RULE_SETUP -#line 382 "./util/configlexer.lex" +#line 401 "./util/configlexer.lex" { LEXOUT(("NL\n")); cfg_parser->line++;} YY_BREAK -case 141: +case 154: YY_RULE_SETUP -#line 383 "./util/configlexer.lex" +#line 402 "./util/configlexer.lex" { LEXOUT(("IQS ")); BEGIN(include_quoted); } YY_BREAK -case 142: +case 155: YY_RULE_SETUP -#line 384 "./util/configlexer.lex" +#line 403 "./util/configlexer.lex" { LEXOUT(("Iunquotedstr(%s) ", yytext)); config_start_include_glob(yytext); @@ -2780,27 +2994,27 @@ YY_RULE_SETUP } YY_BREAK case YY_STATE_EOF(include_quoted): -#line 389 "./util/configlexer.lex" +#line 408 "./util/configlexer.lex" { yyerror("EOF inside quoted string"); BEGIN(inc_prev); } YY_BREAK -case 143: +case 156: YY_RULE_SETUP -#line 393 "./util/configlexer.lex" +#line 412 "./util/configlexer.lex" { LEXOUT(("ISTR(%s) ", yytext)); yymore(); } YY_BREAK -case 144: -/* rule 144 can match eol */ +case 157: +/* rule 157 can match eol */ YY_RULE_SETUP -#line 394 "./util/configlexer.lex" +#line 413 "./util/configlexer.lex" { yyerror("newline before \" in include name"); cfg_parser->line++; BEGIN(inc_prev); } YY_BREAK -case 145: +case 158: YY_RULE_SETUP -#line 396 "./util/configlexer.lex" +#line 415 "./util/configlexer.lex" { LEXOUT(("IQE ")); yytext[yyleng - 1] = '\0'; @@ -2810,7 +3024,7 @@ YY_RULE_SETUP YY_BREAK case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(val): -#line 402 "./util/configlexer.lex" +#line 421 "./util/configlexer.lex" { LEXOUT(("LEXEOF ")); yy_set_bol(1); /* Set beginning of line, so "^" rules match. */ @@ -2822,33 +3036,33 @@ case YY_STATE_EOF(val): } } YY_BREAK -case 146: +case 159: YY_RULE_SETUP -#line 413 "./util/configlexer.lex" +#line 432 "./util/configlexer.lex" { LEXOUT(("unquotedstr(%s) ", yytext)); if(--num_args == 0) { BEGIN(INITIAL); } yylval.str = strdup(yytext); return STRING_ARG; } YY_BREAK -case 147: +case 160: YY_RULE_SETUP -#line 417 "./util/configlexer.lex" +#line 436 "./util/configlexer.lex" { ub_c_error_msg("unknown keyword '%s'", yytext); } YY_BREAK -case 148: +case 161: YY_RULE_SETUP -#line 421 "./util/configlexer.lex" +#line 440 "./util/configlexer.lex" { ub_c_error_msg("stray '%s'", yytext); } YY_BREAK -case 149: +case 162: YY_RULE_SETUP -#line 425 "./util/configlexer.lex" +#line 444 "./util/configlexer.lex" ECHO; YY_BREAK -#line 2850 "" +#line 3064 "" case YY_END_OF_BUFFER: { @@ -3138,7 +3352,7 @@ static int yy_get_next_buffer (void) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1420 ) + if ( yy_current_state >= 1611 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -3166,11 +3380,11 @@ static int yy_get_next_buffer (void) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1420 ) + if ( yy_current_state >= 1611 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 1419); + yy_is_jam = (yy_current_state == 1610); return yy_is_jam ? 0 : yy_current_state; } @@ -3803,7 +4017,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 425 "./util/configlexer.lex" +#line 444 "./util/configlexer.lex" diff --git a/util/configlexer.lex b/util/configlexer.lex index 39dade0d2..7ee7b9bd9 100644 --- a/util/configlexer.lex +++ b/util/configlexer.lex @@ -327,6 +327,25 @@ rrset-roundrobin{COLON} { YDVAR(1, VAR_RRSET_ROUNDROBIN) } max-udp-size{COLON} { YDVAR(1, VAR_MAX_UDP_SIZE) } dns64-prefix{COLON} { YDVAR(1, VAR_DNS64_PREFIX) } dns64-synthall{COLON} { YDVAR(1, VAR_DNS64_SYNTHALL) } +dnstap{COLON} { YDVAR(0, VAR_DNSTAP) } +dnstap-enable{COLON} { YDVAR(1, VAR_DNSTAP_ENABLE) } +dnstap-socket-path{COLON} { YDVAR(1, VAR_DNSTAP_SOCKET_PATH) } +dnstap-send-identity{COLON} { YDVAR(1, VAR_DNSTAP_SEND_IDENTITY) } +dnstap-send-version{COLON} { YDVAR(1, VAR_DNSTAP_SEND_VERSION) } +dnstap-identity{COLON} { YDVAR(1, VAR_DNSTAP_IDENTITY) } +dnstap-version{COLON} { YDVAR(1, VAR_DNSTAP_VERSION) } +dnstap-log-resolver-query-messages{COLON} { + YDVAR(1, VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES) } +dnstap-log-resolver-response-messages{COLON} { + YDVAR(1, VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES) } +dnstap-log-client-query-messages{COLON} { + YDVAR(1, VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES) } +dnstap-log-client-response-messages{COLON} { + YDVAR(1, VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES) } +dnstap-log-forwarder-query-messages{COLON} { + YDVAR(1, VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES) } +dnstap-log-forwarder-response-messages{COLON} { + YDVAR(1, VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES) } {NEWLINE} { LEXOUT(("NL\n")); cfg_parser->line++; } /* Quoted strings. Strip leading and ending quotes */ diff --git a/util/configparser.c b/util/configparser.c index c53c75cc4..089d675d9 100644 --- a/util/configparser.c +++ b/util/configparser.c @@ -259,7 +259,20 @@ extern int yydebug; VAR_DELAY_CLOSE = 387, VAR_UNBLOCK_LAN_ZONES = 388, VAR_DNS64_PREFIX = 389, - VAR_DNS64_SYNTHALL = 390 + VAR_DNS64_SYNTHALL = 390, + VAR_DNSTAP = 391, + VAR_DNSTAP_ENABLE = 392, + VAR_DNSTAP_SOCKET_PATH = 393, + VAR_DNSTAP_SEND_IDENTITY = 394, + VAR_DNSTAP_SEND_VERSION = 395, + VAR_DNSTAP_IDENTITY = 396, + VAR_DNSTAP_VERSION = 397, + VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES = 398, + VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES = 399, + VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES = 400, + VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES = 401, + VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES = 402, + VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES = 403 }; #endif /* Tokens. */ @@ -396,6 +409,19 @@ extern int yydebug; #define VAR_UNBLOCK_LAN_ZONES 388 #define VAR_DNS64_PREFIX 389 #define VAR_DNS64_SYNTHALL 390 +#define VAR_DNSTAP 391 +#define VAR_DNSTAP_ENABLE 392 +#define VAR_DNSTAP_SOCKET_PATH 393 +#define VAR_DNSTAP_SEND_IDENTITY 394 +#define VAR_DNSTAP_SEND_VERSION 395 +#define VAR_DNSTAP_IDENTITY 396 +#define VAR_DNSTAP_VERSION 397 +#define VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES 398 +#define VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES 399 +#define VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES 400 +#define VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES 401 +#define VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES 402 +#define VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES 403 @@ -409,7 +435,7 @@ typedef union YYSTYPE /* Line 350 of yacc.c */ -#line 413 "util/configparser.c" +#line 439 "util/configparser.c" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ @@ -437,7 +463,7 @@ int yyparse (); /* Copy the second part of user declarations. */ /* Line 353 of yacc.c */ -#line 441 "util/configparser.c" +#line 467 "util/configparser.c" #ifdef short # undef short @@ -657,20 +683,20 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 2 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 250 +#define YYLAST 276 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 136 +#define YYNTOKENS 149 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 139 +#define YYNNTS 154 /* YYNRULES -- Number of rules. */ -#define YYNRULES 265 +#define YYNRULES 293 /* YYNRULES -- Number of states. */ -#define YYNSTATES 389 +#define YYNSTATES 429 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 390 +#define YYMAXUTOK 403 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -717,7 +743,8 @@ static const yytype_uint8 yytranslate[] = 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135 + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148 }; #if YYDEBUG @@ -726,135 +753,148 @@ static const yytype_uint8 yytranslate[] = static const yytype_uint16 yyprhs[] = { 0, 0, 3, 4, 7, 10, 13, 16, 19, 22, - 24, 27, 28, 30, 32, 34, 36, 38, 40, 42, - 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, - 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, - 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, - 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, - 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, - 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, - 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, - 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, - 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, - 224, 226, 228, 230, 232, 234, 236, 238, 241, 242, - 244, 246, 248, 250, 252, 254, 257, 258, 260, 262, - 264, 266, 269, 272, 275, 278, 281, 284, 287, 290, + 25, 27, 30, 31, 33, 35, 37, 39, 41, 43, + 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, + 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, + 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, + 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, + 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, + 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, + 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, + 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, + 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, + 225, 227, 229, 231, 233, 235, 237, 239, 241, 244, + 245, 247, 249, 251, 253, 255, 257, 260, 261, 263, + 265, 267, 269, 272, 275, 278, 281, 284, 287, 290, 293, 296, 299, 302, 305, 308, 311, 314, 317, 320, 323, 326, 329, 332, 335, 338, 341, 344, 347, 350, 353, 356, 359, 362, 365, 368, 371, 374, 377, 380, 383, 386, 389, 392, 395, 398, 401, 404, 407, 410, 413, 416, 419, 422, 425, 428, 431, 434, 437, 440, 443, 446, 449, 452, 455, 458, 461, 464, 467, 470, - 473, 476, 479, 482, 485, 488, 491, 494, 497, 501, + 473, 476, 479, 482, 485, 488, 491, 494, 497, 500, 504, 507, 510, 513, 516, 519, 522, 525, 528, 531, - 534, 537, 540, 543, 546, 549, 552, 555, 559, 562, + 534, 537, 540, 543, 546, 549, 552, 555, 558, 562, 565, 568, 571, 574, 577, 580, 583, 586, 589, 592, - 595, 598, 601, 604, 607, 609, 612, 613, 615, 617, - 619, 621, 623, 625, 627, 630, 633, 636, 639, 642, - 645, 648, 650, 653, 654, 656 + 595, 598, 601, 604, 607, 610, 612, 615, 616, 618, + 620, 622, 624, 626, 628, 630, 633, 636, 639, 642, + 645, 648, 651, 653, 656, 657, 659, 661, 663, 665, + 667, 669, 671, 673, 675, 677, 679, 681, 684, 687, + 690, 693, 696, 699, 702, 705, 708, 711, 714, 717, + 719, 722, 723, 725 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int16 yyrhs[] = { - 137, 0, -1, -1, 137, 138, -1, 139, 140, -1, - 142, 143, -1, 145, 146, -1, 271, 272, -1, 261, - 262, -1, 11, -1, 140, 141, -1, -1, 148, -1, - 149, -1, 153, -1, 156, -1, 162, -1, 163, -1, - 164, -1, 165, -1, 154, -1, 175, -1, 176, -1, - 177, -1, 178, -1, 179, -1, 197, -1, 198, -1, - 199, -1, 203, -1, 204, -1, 159, -1, 205, -1, - 206, -1, 209, -1, 207, -1, 208, -1, 210, -1, - 211, -1, 212, -1, 223, -1, 188, -1, 189, -1, - 190, -1, 191, -1, 213, -1, 226, -1, 184, -1, - 186, -1, 227, -1, 232, -1, 233, -1, 234, -1, - 160, -1, 196, -1, 241, -1, 242, -1, 185, -1, - 237, -1, 172, -1, 155, -1, 180, -1, 224, -1, - 230, -1, 214, -1, 225, -1, 244, -1, 245, -1, - 161, -1, 150, -1, 171, -1, 217, -1, 151, -1, - 157, -1, 158, -1, 181, -1, 182, -1, 243, -1, - 216, -1, 218, -1, 219, -1, 152, -1, 246, -1, - 200, -1, 222, -1, 173, -1, 187, -1, 228, -1, - 229, -1, 231, -1, 236, -1, 183, -1, 238, -1, - 239, -1, 240, -1, 192, -1, 195, -1, 220, -1, - 221, -1, 193, -1, 215, -1, 235, -1, 174, -1, - 166, -1, 167, -1, 168, -1, 169, -1, 170, -1, - 247, -1, 248, -1, 249, -1, 194, -1, 201, -1, - 202, -1, 250, -1, 251, -1, 38, -1, 143, 144, - -1, -1, 252, -1, 253, -1, 254, -1, 256, -1, - 255, -1, 44, -1, 146, 147, -1, -1, 257, -1, - 258, -1, 259, -1, 260, -1, 13, 10, -1, 12, - 10, -1, 76, 10, -1, 79, 10, -1, 96, 10, - -1, 14, 10, -1, 16, 10, -1, 67, 10, -1, - 15, 10, -1, 80, 10, -1, 81, 10, -1, 31, - 10, -1, 60, 10, -1, 75, 10, -1, 17, 10, - -1, 18, 10, -1, 19, 10, -1, 20, 10, -1, - 122, 10, -1, 123, 10, -1, 124, 10, -1, 125, - 10, -1, 126, 10, -1, 77, 10, -1, 66, 10, - -1, 101, 10, -1, 121, 10, -1, 21, 10, -1, - 22, 10, -1, 23, 10, -1, 24, 10, -1, 25, - 10, -1, 68, 10, -1, 82, 10, -1, 83, 10, - -1, 109, 10, -1, 54, 10, -1, 64, 10, -1, - 55, 10, -1, 102, 10, -1, 48, 10, -1, 49, - 10, -1, 50, 10, -1, 51, 10, -1, 113, 10, - -1, 117, 10, -1, 118, 10, -1, 114, 10, -1, - 61, 10, -1, 26, 10, -1, 27, 10, -1, 28, - 10, -1, 98, 10, -1, 132, 10, -1, 133, 10, - -1, 29, 10, -1, 30, 10, -1, 32, 10, -1, - 33, 10, -1, 35, 10, -1, 36, 10, -1, 34, - 10, -1, 41, 10, -1, 42, 10, -1, 43, 10, - -1, 52, 10, -1, 71, 10, -1, 119, 10, -1, - 85, 10, -1, 78, 10, -1, 86, 10, -1, 87, - 10, -1, 115, 10, -1, 116, 10, -1, 100, 10, - -1, 47, 10, -1, 69, 10, -1, 72, 10, 10, - -1, 53, 10, -1, 56, 10, -1, 105, 10, -1, - 106, 10, -1, 70, 10, -1, 107, 10, -1, 57, - 10, -1, 58, 10, -1, 59, 10, -1, 120, 10, - -1, 108, 10, -1, 65, 10, -1, 111, 10, -1, - 112, 10, -1, 110, 10, -1, 62, 10, -1, 63, - 10, -1, 84, 10, -1, 73, 10, 10, -1, 74, - 10, -1, 97, 10, -1, 129, 10, -1, 130, 10, - -1, 131, 10, -1, 134, 10, -1, 135, 10, -1, - 37, 10, -1, 39, 10, -1, 40, 10, -1, 128, - 10, -1, 99, 10, -1, 37, 10, -1, 45, 10, - -1, 46, 10, -1, 127, 10, -1, 88, -1, 262, - 263, -1, -1, 264, -1, 266, -1, 265, -1, 267, - -1, 268, -1, 269, -1, 270, -1, 89, 10, -1, - 91, 10, -1, 90, 10, -1, 92, 10, -1, 93, - 10, -1, 94, 10, -1, 95, 10, -1, 103, -1, - 272, 273, -1, -1, 274, -1, 104, 10, -1 + 150, 0, -1, -1, 150, 151, -1, 152, 153, -1, + 155, 156, -1, 158, 159, -1, 299, 300, -1, 274, + 275, -1, 284, 285, -1, 11, -1, 153, 154, -1, + -1, 161, -1, 162, -1, 166, -1, 169, -1, 175, + -1, 176, -1, 177, -1, 178, -1, 167, -1, 188, + -1, 189, -1, 190, -1, 191, -1, 192, -1, 210, + -1, 211, -1, 212, -1, 216, -1, 217, -1, 172, + -1, 218, -1, 219, -1, 222, -1, 220, -1, 221, + -1, 223, -1, 224, -1, 225, -1, 236, -1, 201, + -1, 202, -1, 203, -1, 204, -1, 226, -1, 239, + -1, 197, -1, 199, -1, 240, -1, 245, -1, 246, + -1, 247, -1, 173, -1, 209, -1, 254, -1, 255, + -1, 198, -1, 250, -1, 185, -1, 168, -1, 193, + -1, 237, -1, 243, -1, 227, -1, 238, -1, 257, + -1, 258, -1, 174, -1, 163, -1, 184, -1, 230, + -1, 164, -1, 170, -1, 171, -1, 194, -1, 195, + -1, 256, -1, 229, -1, 231, -1, 232, -1, 165, + -1, 259, -1, 213, -1, 235, -1, 186, -1, 200, + -1, 241, -1, 242, -1, 244, -1, 249, -1, 196, + -1, 251, -1, 252, -1, 253, -1, 205, -1, 208, + -1, 233, -1, 234, -1, 206, -1, 228, -1, 248, + -1, 187, -1, 179, -1, 180, -1, 181, -1, 182, + -1, 183, -1, 260, -1, 261, -1, 262, -1, 207, + -1, 214, -1, 215, -1, 263, -1, 264, -1, 38, + -1, 156, 157, -1, -1, 265, -1, 266, -1, 267, + -1, 269, -1, 268, -1, 44, -1, 159, 160, -1, + -1, 270, -1, 271, -1, 272, -1, 273, -1, 13, + 10, -1, 12, 10, -1, 76, 10, -1, 79, 10, + -1, 96, 10, -1, 14, 10, -1, 16, 10, -1, + 67, 10, -1, 15, 10, -1, 80, 10, -1, 81, + 10, -1, 31, 10, -1, 60, 10, -1, 75, 10, + -1, 17, 10, -1, 18, 10, -1, 19, 10, -1, + 20, 10, -1, 122, 10, -1, 123, 10, -1, 124, + 10, -1, 125, 10, -1, 126, 10, -1, 77, 10, + -1, 66, 10, -1, 101, 10, -1, 121, 10, -1, + 21, 10, -1, 22, 10, -1, 23, 10, -1, 24, + 10, -1, 25, 10, -1, 68, 10, -1, 82, 10, + -1, 83, 10, -1, 109, 10, -1, 54, 10, -1, + 64, 10, -1, 55, 10, -1, 102, 10, -1, 48, + 10, -1, 49, 10, -1, 50, 10, -1, 51, 10, + -1, 113, 10, -1, 117, 10, -1, 118, 10, -1, + 114, 10, -1, 61, 10, -1, 26, 10, -1, 27, + 10, -1, 28, 10, -1, 98, 10, -1, 132, 10, + -1, 133, 10, -1, 29, 10, -1, 30, 10, -1, + 32, 10, -1, 33, 10, -1, 35, 10, -1, 36, + 10, -1, 34, 10, -1, 41, 10, -1, 42, 10, + -1, 43, 10, -1, 52, 10, -1, 71, 10, -1, + 119, 10, -1, 85, 10, -1, 78, 10, -1, 86, + 10, -1, 87, 10, -1, 115, 10, -1, 116, 10, + -1, 100, 10, -1, 47, 10, -1, 69, 10, -1, + 72, 10, 10, -1, 53, 10, -1, 56, 10, -1, + 105, 10, -1, 106, 10, -1, 70, 10, -1, 107, + 10, -1, 57, 10, -1, 58, 10, -1, 59, 10, + -1, 120, 10, -1, 108, 10, -1, 65, 10, -1, + 111, 10, -1, 112, 10, -1, 110, 10, -1, 62, + 10, -1, 63, 10, -1, 84, 10, -1, 73, 10, + 10, -1, 74, 10, -1, 97, 10, -1, 129, 10, + -1, 130, 10, -1, 131, 10, -1, 134, 10, -1, + 135, 10, -1, 37, 10, -1, 39, 10, -1, 40, + 10, -1, 128, 10, -1, 99, 10, -1, 37, 10, + -1, 45, 10, -1, 46, 10, -1, 127, 10, -1, + 88, -1, 275, 276, -1, -1, 277, -1, 279, -1, + 278, -1, 280, -1, 281, -1, 282, -1, 283, -1, + 89, 10, -1, 91, 10, -1, 90, 10, -1, 92, + 10, -1, 93, 10, -1, 94, 10, -1, 95, 10, + -1, 136, -1, 285, 286, -1, -1, 287, -1, 288, + -1, 289, -1, 290, -1, 291, -1, 292, -1, 293, + -1, 294, -1, 295, -1, 296, -1, 297, -1, 298, + -1, 137, 10, -1, 138, 10, -1, 139, 10, -1, + 140, 10, -1, 141, 10, -1, 142, 10, -1, 143, + 10, -1, 144, 10, -1, 145, 10, -1, 146, 10, + -1, 147, 10, -1, 148, 10, -1, 103, -1, 300, + 301, -1, -1, 302, -1, 104, 10, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 112, 112, 112, 113, 113, 114, 114, 115, 119, - 124, 125, 126, 126, 126, 127, 127, 128, 128, 128, - 129, 129, 129, 130, 130, 130, 131, 131, 132, 132, - 133, 133, 134, 134, 135, 135, 136, 136, 137, 137, - 138, 138, 139, 139, 139, 140, 140, 140, 141, 141, + 0, 121, 121, 121, 122, 122, 123, 123, 124, 124, + 128, 133, 134, 135, 135, 135, 136, 136, 137, 137, + 137, 138, 138, 138, 139, 139, 139, 140, 140, 141, 141, 142, 142, 143, 143, 144, 144, 145, 145, 146, - 146, 146, 147, 147, 148, 148, 149, 149, 149, 150, - 150, 151, 151, 152, 152, 153, 153, 153, 154, 154, - 155, 155, 156, 156, 157, 157, 158, 158, 159, 159, - 159, 160, 160, 161, 161, 161, 162, 162, 162, 163, - 163, 163, 164, 164, 164, 165, 165, 165, 166, 166, - 166, 167, 167, 167, 168, 168, 170, 182, 183, 184, - 184, 184, 184, 184, 186, 198, 199, 200, 200, 200, - 200, 202, 211, 220, 231, 240, 249, 258, 271, 286, + 146, 147, 147, 148, 148, 148, 149, 149, 149, 150, + 150, 150, 151, 151, 152, 152, 153, 153, 154, 154, + 155, 155, 155, 156, 156, 157, 157, 158, 158, 158, + 159, 159, 160, 160, 161, 161, 162, 162, 162, 163, + 163, 164, 164, 165, 165, 166, 166, 167, 167, 168, + 168, 168, 169, 169, 170, 170, 170, 171, 171, 171, + 172, 172, 172, 173, 173, 173, 174, 174, 174, 175, + 175, 175, 176, 176, 176, 177, 177, 179, 191, 192, + 193, 193, 193, 193, 193, 195, 207, 208, 209, 209, + 209, 209, 211, 220, 229, 240, 249, 258, 267, 280, 295, 304, 313, 322, 331, 340, 349, 358, 367, 376, - 385, 394, 401, 408, 417, 426, 440, 449, 458, 465, - 472, 479, 487, 494, 501, 508, 515, 523, 531, 539, - 546, 553, 562, 571, 578, 585, 593, 601, 611, 624, - 635, 643, 656, 665, 674, 683, 693, 701, 714, 723, - 731, 740, 748, 761, 768, 778, 788, 798, 808, 818, - 828, 838, 845, 852, 861, 870, 879, 886, 896, 913, - 920, 938, 951, 964, 973, 982, 991, 1001, 1011, 1020, - 1029, 1036, 1045, 1054, 1063, 1071, 1084, 1092, 1114, 1121, - 1136, 1146, 1156, 1163, 1170, 1179, 1189, 1196, 1203, 1212, - 1222, 1232, 1239, 1246, 1255, 1260, 1261, 1262, 1262, 1262, - 1263, 1263, 1263, 1264, 1266, 1276, 1285, 1292, 1299, 1306, - 1313, 1320, 1325, 1326, 1327, 1329 + 385, 394, 403, 410, 417, 426, 435, 449, 458, 467, + 474, 481, 488, 496, 503, 510, 517, 524, 532, 540, + 548, 555, 562, 571, 580, 587, 594, 602, 610, 620, + 633, 644, 652, 665, 674, 683, 692, 702, 710, 723, + 732, 740, 749, 757, 770, 777, 787, 797, 807, 817, + 827, 837, 847, 854, 861, 870, 879, 888, 895, 905, + 922, 929, 947, 960, 973, 982, 991, 1000, 1010, 1020, + 1029, 1038, 1045, 1054, 1063, 1072, 1080, 1093, 1101, 1123, + 1130, 1145, 1155, 1165, 1172, 1179, 1188, 1198, 1205, 1212, + 1221, 1231, 1241, 1248, 1255, 1264, 1269, 1270, 1271, 1271, + 1271, 1272, 1272, 1272, 1273, 1275, 1285, 1294, 1301, 1308, + 1315, 1322, 1329, 1334, 1335, 1336, 1336, 1337, 1337, 1338, + 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1346, 1354, 1361, + 1369, 1377, 1384, 1391, 1400, 1409, 1418, 1427, 1436, 1445, + 1450, 1451, 1452, 1454 }; #endif @@ -906,17 +946,25 @@ static const char *const yytname[] = "VAR_SSL_PORT", "VAR_FORWARD_FIRST", "VAR_STUB_FIRST", "VAR_MINIMAL_RESPONSES", "VAR_RRSET_ROUNDROBIN", "VAR_MAX_UDP_SIZE", "VAR_DELAY_CLOSE", "VAR_UNBLOCK_LAN_ZONES", "VAR_DNS64_PREFIX", - "VAR_DNS64_SYNTHALL", "$accept", "toplevelvars", "toplevelvar", - "serverstart", "contents_server", "content_server", "stubstart", - "contents_stub", "content_stub", "forwardstart", "contents_forward", - "content_forward", "server_num_threads", "server_verbosity", - "server_statistics_interval", "server_statistics_cumulative", - "server_extended_statistics", "server_port", "server_interface", - "server_outgoing_interface", "server_outgoing_range", - "server_outgoing_port_permit", "server_outgoing_port_avoid", - "server_outgoing_num_tcp", "server_incoming_num_tcp", - "server_interface_automatic", "server_do_ip4", "server_do_ip6", - "server_do_udp", "server_do_tcp", "server_tcp_upstream", + "VAR_DNS64_SYNTHALL", "VAR_DNSTAP", "VAR_DNSTAP_ENABLE", + "VAR_DNSTAP_SOCKET_PATH", "VAR_DNSTAP_SEND_IDENTITY", + "VAR_DNSTAP_SEND_VERSION", "VAR_DNSTAP_IDENTITY", "VAR_DNSTAP_VERSION", + "VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES", + "VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES", + "VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES", + "VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES", + "VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES", + "VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES", "$accept", "toplevelvars", + "toplevelvar", "serverstart", "contents_server", "content_server", + "stubstart", "contents_stub", "content_stub", "forwardstart", + "contents_forward", "content_forward", "server_num_threads", + "server_verbosity", "server_statistics_interval", + "server_statistics_cumulative", "server_extended_statistics", + "server_port", "server_interface", "server_outgoing_interface", + "server_outgoing_range", "server_outgoing_port_permit", + "server_outgoing_port_avoid", "server_outgoing_num_tcp", + "server_incoming_num_tcp", "server_interface_automatic", "server_do_ip4", + "server_do_ip6", "server_do_udp", "server_do_tcp", "server_tcp_upstream", "server_ssl_upstream", "server_ssl_service_key", "server_ssl_service_pem", "server_ssl_port", "server_do_daemonize", "server_use_syslog", "server_log_time_ascii", "server_log_queries", @@ -957,8 +1005,16 @@ static const char *const yytname[] = "forward_addr", "forward_first", "rcstart", "contents_rc", "content_rc", "rc_control_enable", "rc_control_port", "rc_control_interface", "rc_server_key_file", "rc_server_cert_file", "rc_control_key_file", - "rc_control_cert_file", "pythonstart", "contents_py", "content_py", - "py_script", YY_NULL + "rc_control_cert_file", "dtstart", "contents_dt", "content_dt", + "dt_dnstap_enable", "dt_dnstap_socket_path", "dt_dnstap_send_identity", + "dt_dnstap_send_version", "dt_dnstap_identity", "dt_dnstap_version", + "dt_dnstap_log_resolver_query_messages", + "dt_dnstap_log_resolver_response_messages", + "dt_dnstap_log_client_query_messages", + "dt_dnstap_log_client_response_messages", + "dt_dnstap_log_forwarder_query_messages", + "dt_dnstap_log_forwarder_response_messages", "pythonstart", + "contents_py", "content_py", "py_script", YY_NULL }; #endif @@ -980,47 +1036,51 @@ static const yytype_uint16 yytoknum[] = 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, 388, 389, 390 + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { - 0, 136, 137, 137, 138, 138, 138, 138, 138, 139, - 140, 140, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 142, 143, 143, 144, - 144, 144, 144, 144, 145, 146, 146, 147, 147, 147, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 262, 263, 263, 263, - 263, 263, 263, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 272, 273, 274 + 0, 149, 150, 150, 151, 151, 151, 151, 151, 151, + 152, 153, 153, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 155, 156, 156, + 157, 157, 157, 157, 157, 158, 159, 159, 160, 160, + 160, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 275, 276, 276, + 276, 276, 276, 276, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 285, 286, 286, 286, 286, 286, + 286, 286, 286, 286, 286, 286, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 300, 301, 302 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { - 0, 2, 0, 2, 2, 2, 2, 2, 2, 1, - 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, + 1, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -1030,22 +1090,25 @@ static const yytype_uint8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 2, 0, 1, - 1, 1, 1, 1, 1, 2, 0, 1, 1, 1, - 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, + 1, 1, 1, 1, 1, 1, 2, 0, 1, 1, + 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 1, 2, 0, 1, 1, 1, - 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, - 2, 1, 2, 0, 1, 2 + 2, 2, 2, 2, 2, 1, 2, 0, 1, 1, + 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, + 2, 2, 1, 2, 0, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, + 2, 0, 1, 2 }; /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. @@ -1053,9 +1116,9 @@ static const yytype_uint8 yyr2[] = means the default is an error. */ static const yytype_uint16 yydefact[] = { - 2, 0, 1, 9, 116, 124, 244, 261, 3, 11, - 118, 126, 246, 263, 4, 5, 6, 8, 7, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 1, 10, 117, 125, 245, 289, 262, 3, + 12, 119, 127, 247, 264, 291, 4, 5, 6, 8, + 9, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1065,117 +1128,129 @@ static const yytype_uint16 yydefact[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 10, 12, 13, 69, 72, 81, 14, - 20, 60, 15, 73, 74, 31, 53, 68, 16, 17, - 18, 19, 103, 104, 105, 106, 107, 70, 59, 85, - 102, 21, 22, 23, 24, 25, 61, 75, 76, 91, - 47, 57, 48, 86, 41, 42, 43, 44, 95, 99, - 111, 96, 54, 26, 27, 28, 83, 112, 113, 29, - 30, 32, 33, 35, 36, 34, 37, 38, 39, 45, - 64, 100, 78, 71, 79, 80, 97, 98, 84, 40, - 62, 65, 46, 49, 87, 88, 63, 89, 50, 51, - 52, 101, 90, 58, 92, 93, 94, 55, 56, 77, - 66, 67, 82, 108, 109, 110, 114, 115, 0, 0, - 0, 0, 0, 117, 119, 120, 121, 123, 122, 0, - 0, 0, 0, 125, 127, 128, 129, 130, 0, 0, - 0, 0, 0, 0, 0, 245, 247, 249, 248, 250, - 251, 252, 253, 0, 262, 264, 132, 131, 136, 139, - 137, 145, 146, 147, 148, 158, 159, 160, 161, 162, - 180, 181, 182, 186, 187, 142, 188, 189, 192, 190, - 191, 193, 194, 195, 206, 171, 172, 173, 174, 196, - 209, 167, 169, 210, 215, 216, 217, 143, 179, 224, - 225, 168, 220, 155, 138, 163, 207, 213, 197, 0, - 0, 228, 144, 133, 154, 200, 134, 140, 141, 164, - 165, 226, 199, 201, 202, 135, 229, 183, 205, 156, - 170, 211, 212, 214, 219, 166, 223, 221, 222, 175, - 178, 203, 204, 176, 177, 198, 218, 157, 149, 150, - 151, 152, 153, 230, 231, 232, 184, 185, 233, 234, - 235, 236, 237, 239, 238, 240, 241, 242, 243, 254, - 256, 255, 257, 258, 259, 260, 265, 208, 227 + 0, 0, 0, 0, 0, 0, 11, 13, 14, 70, + 73, 82, 15, 21, 61, 16, 74, 75, 32, 54, + 69, 17, 18, 19, 20, 104, 105, 106, 107, 108, + 71, 60, 86, 103, 22, 23, 24, 25, 26, 62, + 76, 77, 92, 48, 58, 49, 87, 42, 43, 44, + 45, 96, 100, 112, 97, 55, 27, 28, 29, 84, + 113, 114, 30, 31, 33, 34, 36, 37, 35, 38, + 39, 40, 46, 65, 101, 79, 72, 80, 81, 98, + 99, 85, 41, 63, 66, 47, 50, 88, 89, 64, + 90, 51, 52, 53, 102, 91, 59, 93, 94, 95, + 56, 57, 78, 67, 68, 83, 109, 110, 111, 115, + 116, 0, 0, 0, 0, 0, 118, 120, 121, 122, + 124, 123, 0, 0, 0, 0, 126, 128, 129, 130, + 131, 0, 0, 0, 0, 0, 0, 0, 246, 248, + 250, 249, 251, 252, 253, 254, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 263, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 0, 290, 292, 133, 132, 137, 140, 138, 146, + 147, 148, 149, 159, 160, 161, 162, 163, 181, 182, + 183, 187, 188, 143, 189, 190, 193, 191, 192, 194, + 195, 196, 207, 172, 173, 174, 175, 197, 210, 168, + 170, 211, 216, 217, 218, 144, 180, 225, 226, 169, + 221, 156, 139, 164, 208, 214, 198, 0, 0, 229, + 145, 134, 155, 201, 135, 141, 142, 165, 166, 227, + 200, 202, 203, 136, 230, 184, 206, 157, 171, 212, + 213, 215, 220, 167, 224, 222, 223, 176, 179, 204, + 205, 177, 178, 199, 219, 158, 150, 151, 152, 153, + 154, 231, 232, 233, 185, 186, 234, 235, 236, 237, + 238, 240, 239, 241, 242, 243, 244, 255, 257, 256, + 258, 259, 260, 261, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 293, 209, 228 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 1, 8, 9, 14, 123, 10, 15, 233, 11, - 16, 243, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 234, 235, 236, 237, - 238, 244, 245, 246, 247, 12, 17, 255, 256, 257, - 258, 259, 260, 261, 262, 13, 18, 264, 265 + -1, 1, 9, 10, 16, 126, 11, 17, 236, 12, + 18, 246, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 237, 238, 239, 240, + 241, 247, 248, 249, 250, 13, 19, 258, 259, 260, + 261, 262, 263, 264, 265, 14, 20, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 15, 21, 292, 293 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -80 +#define YYPACT_NINF -123 static const yytype_int16 yypact[] = { - -80, 115, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -12, 39, 46, 38, -79, 16, - 17, 18, 22, 23, 24, 67, 70, 71, 72, 77, - 106, 114, 124, 125, 126, 127, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 144, 145, 146, 147, 148, 150, 151, 152, 153, 154, - 155, 156, 158, 159, 160, 161, 162, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, 222, 223, - 224, 225, 226, -80, -80, -80, -80, -80, -80, 227, - 228, 229, 230, -80, -80, -80, -80, -80, 231, 232, - 233, 234, 235, 236, 237, -80, -80, -80, -80, -80, - -80, -80, -80, 238, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, 239, - 240, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80 + -123, 0, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, 92, -36, -32, -62, + -122, -102, -4, -3, -2, -1, 2, 24, 25, 26, + 27, 29, 30, 31, 32, 33, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 79, 80, + 81, 83, 84, 86, 87, 88, 89, 90, 91, 119, + 120, 121, 122, 127, 128, 170, 171, 172, 173, 174, + 175, 176, 177, 181, 185, 186, 209, 210, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, 236, 237, 238, 239, 240, -123, -123, -123, -123, + -123, -123, 241, 242, 243, 244, -123, -123, -123, -123, + -123, 245, 246, 247, 248, 249, 250, 251, -123, -123, + -123, -123, -123, -123, -123, -123, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, 264, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, 265, 266, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int8 yypgoto[] = { - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, - -80, -80, -80, -80, -80, -80, -80, -80, -80 + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, + -123, -123, -123, -123 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If @@ -1184,88 +1259,91 @@ static const yytype_int8 yypgoto[] = #define YYTABLE_NINF -1 static const yytype_uint16 yytable[] = { - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 263, 266, 267, 268, 44, - 45, 46, 269, 270, 271, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 228, 272, 229, 230, - 273, 274, 275, 239, 88, 89, 90, 276, 91, 92, - 93, 240, 241, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 2, 277, 116, 117, 118, - 119, 120, 121, 122, 278, 0, 3, 248, 249, 250, - 251, 252, 253, 254, 279, 280, 281, 282, 231, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 4, 297, 298, 299, 300, 301, 5, - 302, 303, 304, 305, 306, 307, 308, 232, 309, 310, - 311, 312, 313, 242, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, - 340, 341, 342, 6, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 7, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388 + 2, 231, 291, 232, 233, 242, 294, 295, 296, 297, + 0, 3, 298, 243, 244, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 251, 252, 253, + 254, 255, 256, 257, 299, 300, 301, 302, 4, 303, + 304, 305, 306, 307, 5, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 234, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 6, 350, + 351, 352, 235, 353, 354, 245, 355, 356, 357, 358, + 359, 360, 0, 7, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 361, + 362, 363, 364, 47, 48, 49, 8, 365, 366, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 367, 368, 369, 370, 371, 372, 373, 374, 91, 92, + 93, 375, 94, 95, 96, 376, 377, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 378, + 379, 119, 120, 121, 122, 123, 124, 125, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428 }; #define yypact_value_is_default(yystate) \ - ((yystate) == (-80)) + ((yystate) == (-123)) #define yytable_value_is_error(yytable_value) \ YYID (0) static const yytype_int16 yycheck[] = { - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 104, 10, 10, 10, 41, - 42, 43, 10, 10, 10, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 37, 10, 39, 40, - 10, 10, 10, 37, 96, 97, 98, 10, 100, 101, - 102, 45, 46, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 0, 10, 129, 130, 131, - 132, 133, 134, 135, 10, -1, 11, 89, 90, 91, - 92, 93, 94, 95, 10, 10, 10, 10, 99, 10, + 0, 37, 104, 39, 40, 37, 10, 10, 10, 10, + -1, 11, 10, 45, 46, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 89, 90, 91, + 92, 93, 94, 95, 10, 10, 10, 10, 38, 10, + 10, 10, 10, 10, 44, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, - 10, 10, 10, 38, 10, 10, 10, 10, 10, 44, - 10, 10, 10, 10, 10, 10, 10, 128, 10, 10, - 10, 10, 10, 127, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 99, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 88, 10, + 10, 10, 128, 10, 10, 127, 10, 10, 10, 10, + 10, 10, -1, 103, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 10, + 10, 10, 10, 41, 42, 43, 136, 10, 10, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 10, 10, 10, 10, 10, 10, 10, 10, 96, 97, + 98, 10, 100, 101, 102, 10, 10, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 10, + 10, 129, 130, 131, 132, 133, 134, 135, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, - 10, 10, 10, 88, 10, 10, 10, 10, 10, 10, - 10, 10, 10, 10, 10, 10, 10, 10, 103, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, - 10 + 10, 10, 10, 10, 10, 10, 10 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint16 yystos[] = { - 0, 137, 0, 11, 38, 44, 88, 103, 138, 139, - 142, 145, 261, 271, 140, 143, 146, 262, 272, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 41, 42, 43, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 96, 97, - 98, 100, 101, 102, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 129, 130, 131, 132, - 133, 134, 135, 141, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 0, 150, 0, 11, 38, 44, 88, 103, 136, 151, + 152, 155, 158, 274, 284, 299, 153, 156, 159, 275, + 285, 300, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 41, 42, 43, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 96, 97, 98, 100, 101, 102, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 129, + 130, 131, 132, 133, 134, 135, 154, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, @@ -1274,11 +1352,16 @@ static const yytype_uint16 yystos[] = 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 37, 39, - 40, 99, 128, 144, 252, 253, 254, 255, 256, 37, - 45, 46, 127, 147, 257, 258, 259, 260, 89, 90, - 91, 92, 93, 94, 95, 263, 264, 265, 266, 267, - 268, 269, 270, 104, 273, 274, 10, 10, 10, 10, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 37, 39, 40, 99, 128, 157, 265, 266, 267, + 268, 269, 37, 45, 46, 127, 160, 270, 271, 272, + 273, 89, 90, 91, 92, 93, 94, 95, 276, 277, + 278, 279, 280, 281, 282, 283, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 104, 301, 302, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, @@ -2113,17 +2196,17 @@ yyreduce: YY_REDUCE_PRINT (yyn); switch (yyn) { - case 9: + case 10: /* Line 1787 of yacc.c */ -#line 120 "./util/configparser.y" +#line 129 "./util/configparser.y" { OUTYY(("\nP(server:)\n")); } break; - case 116: + case 117: /* Line 1787 of yacc.c */ -#line 171 "./util/configparser.y" +#line 180 "./util/configparser.y" { struct config_stub* s; OUTYY(("\nP(stub_zone:)\n")); @@ -2136,9 +2219,9 @@ yyreduce: } break; - case 124: + case 125: /* Line 1787 of yacc.c */ -#line 187 "./util/configparser.y" +#line 196 "./util/configparser.y" { struct config_stub* s; OUTYY(("\nP(forward_zone:)\n")); @@ -2151,9 +2234,9 @@ yyreduce: } break; - case 131: + case 132: /* Line 1787 of yacc.c */ -#line 203 "./util/configparser.y" +#line 212 "./util/configparser.y" { OUTYY(("P(server_num_threads:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -2163,9 +2246,9 @@ yyreduce: } break; - case 132: + case 133: /* Line 1787 of yacc.c */ -#line 212 "./util/configparser.y" +#line 221 "./util/configparser.y" { OUTYY(("P(server_verbosity:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -2175,9 +2258,9 @@ yyreduce: } break; - case 133: + case 134: /* Line 1787 of yacc.c */ -#line 221 "./util/configparser.y" +#line 230 "./util/configparser.y" { OUTYY(("P(server_statistics_interval:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "") == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) @@ -2189,9 +2272,9 @@ yyreduce: } break; - case 134: + case 135: /* Line 1787 of yacc.c */ -#line 232 "./util/configparser.y" +#line 241 "./util/configparser.y" { OUTYY(("P(server_statistics_cumulative:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2201,9 +2284,9 @@ yyreduce: } break; - case 135: + case 136: /* Line 1787 of yacc.c */ -#line 241 "./util/configparser.y" +#line 250 "./util/configparser.y" { OUTYY(("P(server_extended_statistics:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2213,9 +2296,9 @@ yyreduce: } break; - case 136: + case 137: /* Line 1787 of yacc.c */ -#line 250 "./util/configparser.y" +#line 259 "./util/configparser.y" { OUTYY(("P(server_port:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2225,9 +2308,9 @@ yyreduce: } break; - case 137: + case 138: /* Line 1787 of yacc.c */ -#line 259 "./util/configparser.y" +#line 268 "./util/configparser.y" { OUTYY(("P(server_interface:%s)\n", (yyvsp[(2) - (2)].str))); if(cfg_parser->cfg->num_ifs == 0) @@ -2241,9 +2324,9 @@ yyreduce: } break; - case 138: + case 139: /* Line 1787 of yacc.c */ -#line 272 "./util/configparser.y" +#line 281 "./util/configparser.y" { OUTYY(("P(server_outgoing_interface:%s)\n", (yyvsp[(2) - (2)].str))); if(cfg_parser->cfg->num_out_ifs == 0) @@ -2259,9 +2342,9 @@ yyreduce: } break; - case 139: + case 140: /* Line 1787 of yacc.c */ -#line 287 "./util/configparser.y" +#line 296 "./util/configparser.y" { OUTYY(("P(server_outgoing_range:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2271,9 +2354,9 @@ yyreduce: } break; - case 140: + case 141: /* Line 1787 of yacc.c */ -#line 296 "./util/configparser.y" +#line 305 "./util/configparser.y" { OUTYY(("P(server_outgoing_port_permit:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_mark_ports((yyvsp[(2) - (2)].str), 1, @@ -2283,9 +2366,9 @@ yyreduce: } break; - case 141: + case 142: /* Line 1787 of yacc.c */ -#line 305 "./util/configparser.y" +#line 314 "./util/configparser.y" { OUTYY(("P(server_outgoing_port_avoid:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_mark_ports((yyvsp[(2) - (2)].str), 0, @@ -2295,9 +2378,9 @@ yyreduce: } break; - case 142: + case 143: /* Line 1787 of yacc.c */ -#line 314 "./util/configparser.y" +#line 323 "./util/configparser.y" { OUTYY(("P(server_outgoing_num_tcp:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -2307,9 +2390,9 @@ yyreduce: } break; - case 143: + case 144: /* Line 1787 of yacc.c */ -#line 323 "./util/configparser.y" +#line 332 "./util/configparser.y" { OUTYY(("P(server_incoming_num_tcp:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -2319,9 +2402,9 @@ yyreduce: } break; - case 144: + case 145: /* Line 1787 of yacc.c */ -#line 332 "./util/configparser.y" +#line 341 "./util/configparser.y" { OUTYY(("P(server_interface_automatic:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2331,9 +2414,9 @@ yyreduce: } break; - case 145: + case 146: /* Line 1787 of yacc.c */ -#line 341 "./util/configparser.y" +#line 350 "./util/configparser.y" { OUTYY(("P(server_do_ip4:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2343,9 +2426,9 @@ yyreduce: } break; - case 146: + case 147: /* Line 1787 of yacc.c */ -#line 350 "./util/configparser.y" +#line 359 "./util/configparser.y" { OUTYY(("P(server_do_ip6:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2355,9 +2438,9 @@ yyreduce: } break; - case 147: + case 148: /* Line 1787 of yacc.c */ -#line 359 "./util/configparser.y" +#line 368 "./util/configparser.y" { OUTYY(("P(server_do_udp:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2367,9 +2450,9 @@ yyreduce: } break; - case 148: + case 149: /* Line 1787 of yacc.c */ -#line 368 "./util/configparser.y" +#line 377 "./util/configparser.y" { OUTYY(("P(server_do_tcp:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2379,9 +2462,9 @@ yyreduce: } break; - case 149: + case 150: /* Line 1787 of yacc.c */ -#line 377 "./util/configparser.y" +#line 386 "./util/configparser.y" { OUTYY(("P(server_tcp_upstream:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2391,9 +2474,9 @@ yyreduce: } break; - case 150: + case 151: /* Line 1787 of yacc.c */ -#line 386 "./util/configparser.y" +#line 395 "./util/configparser.y" { OUTYY(("P(server_ssl_upstream:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2403,9 +2486,9 @@ yyreduce: } break; - case 151: + case 152: /* Line 1787 of yacc.c */ -#line 395 "./util/configparser.y" +#line 404 "./util/configparser.y" { OUTYY(("P(server_ssl_service_key:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->ssl_service_key); @@ -2413,9 +2496,9 @@ yyreduce: } break; - case 152: + case 153: /* Line 1787 of yacc.c */ -#line 402 "./util/configparser.y" +#line 411 "./util/configparser.y" { OUTYY(("P(server_ssl_service_pem:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->ssl_service_pem); @@ -2423,9 +2506,9 @@ yyreduce: } break; - case 153: + case 154: /* Line 1787 of yacc.c */ -#line 409 "./util/configparser.y" +#line 418 "./util/configparser.y" { OUTYY(("P(server_ssl_port:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2435,9 +2518,9 @@ yyreduce: } break; - case 154: + case 155: /* Line 1787 of yacc.c */ -#line 418 "./util/configparser.y" +#line 427 "./util/configparser.y" { OUTYY(("P(server_do_daemonize:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2447,9 +2530,9 @@ yyreduce: } break; - case 155: + case 156: /* Line 1787 of yacc.c */ -#line 427 "./util/configparser.y" +#line 436 "./util/configparser.y" { OUTYY(("P(server_use_syslog:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2464,9 +2547,9 @@ yyreduce: } break; - case 156: + case 157: /* Line 1787 of yacc.c */ -#line 441 "./util/configparser.y" +#line 450 "./util/configparser.y" { OUTYY(("P(server_log_time_ascii:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2476,9 +2559,9 @@ yyreduce: } break; - case 157: + case 158: /* Line 1787 of yacc.c */ -#line 450 "./util/configparser.y" +#line 459 "./util/configparser.y" { OUTYY(("P(server_log_queries:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2488,9 +2571,9 @@ yyreduce: } break; - case 158: + case 159: /* Line 1787 of yacc.c */ -#line 459 "./util/configparser.y" +#line 468 "./util/configparser.y" { OUTYY(("P(server_chroot:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->chrootdir); @@ -2498,9 +2581,9 @@ yyreduce: } break; - case 159: + case 160: /* Line 1787 of yacc.c */ -#line 466 "./util/configparser.y" +#line 475 "./util/configparser.y" { OUTYY(("P(server_username:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->username); @@ -2508,9 +2591,9 @@ yyreduce: } break; - case 160: + case 161: /* Line 1787 of yacc.c */ -#line 473 "./util/configparser.y" +#line 482 "./util/configparser.y" { OUTYY(("P(server_directory:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->directory); @@ -2518,9 +2601,9 @@ yyreduce: } break; - case 161: + case 162: /* Line 1787 of yacc.c */ -#line 480 "./util/configparser.y" +#line 489 "./util/configparser.y" { OUTYY(("P(server_logfile:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->logfile); @@ -2529,9 +2612,9 @@ yyreduce: } break; - case 162: + case 163: /* Line 1787 of yacc.c */ -#line 488 "./util/configparser.y" +#line 497 "./util/configparser.y" { OUTYY(("P(server_pidfile:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->pidfile); @@ -2539,9 +2622,9 @@ yyreduce: } break; - case 163: + case 164: /* Line 1787 of yacc.c */ -#line 495 "./util/configparser.y" +#line 504 "./util/configparser.y" { OUTYY(("P(server_root_hints:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->root_hints, (yyvsp[(2) - (2)].str))) @@ -2549,9 +2632,9 @@ yyreduce: } break; - case 164: + case 165: /* Line 1787 of yacc.c */ -#line 502 "./util/configparser.y" +#line 511 "./util/configparser.y" { OUTYY(("P(server_dlv_anchor_file:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->dlv_anchor_file); @@ -2559,9 +2642,9 @@ yyreduce: } break; - case 165: + case 166: /* Line 1787 of yacc.c */ -#line 509 "./util/configparser.y" +#line 518 "./util/configparser.y" { OUTYY(("P(server_dlv_anchor:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->dlv_anchor_list, (yyvsp[(2) - (2)].str))) @@ -2569,9 +2652,9 @@ yyreduce: } break; - case 166: + case 167: /* Line 1787 of yacc.c */ -#line 516 "./util/configparser.y" +#line 525 "./util/configparser.y" { OUTYY(("P(server_auto_trust_anchor_file:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg-> @@ -2580,9 +2663,9 @@ yyreduce: } break; - case 167: + case 168: /* Line 1787 of yacc.c */ -#line 524 "./util/configparser.y" +#line 533 "./util/configparser.y" { OUTYY(("P(server_trust_anchor_file:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg-> @@ -2591,9 +2674,9 @@ yyreduce: } break; - case 168: + case 169: /* Line 1787 of yacc.c */ -#line 532 "./util/configparser.y" +#line 541 "./util/configparser.y" { OUTYY(("P(server_trusted_keys_file:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg-> @@ -2602,9 +2685,9 @@ yyreduce: } break; - case 169: + case 170: /* Line 1787 of yacc.c */ -#line 540 "./util/configparser.y" +#line 549 "./util/configparser.y" { OUTYY(("P(server_trust_anchor:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->trust_anchor_list, (yyvsp[(2) - (2)].str))) @@ -2612,9 +2695,9 @@ yyreduce: } break; - case 170: + case 171: /* Line 1787 of yacc.c */ -#line 547 "./util/configparser.y" +#line 556 "./util/configparser.y" { OUTYY(("P(server_domain_insecure:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->domain_insecure, (yyvsp[(2) - (2)].str))) @@ -2622,9 +2705,9 @@ yyreduce: } break; - case 171: + case 172: /* Line 1787 of yacc.c */ -#line 554 "./util/configparser.y" +#line 563 "./util/configparser.y" { OUTYY(("P(server_hide_identity:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2634,9 +2717,9 @@ yyreduce: } break; - case 172: + case 173: /* Line 1787 of yacc.c */ -#line 563 "./util/configparser.y" +#line 572 "./util/configparser.y" { OUTYY(("P(server_hide_version:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2646,9 +2729,9 @@ yyreduce: } break; - case 173: + case 174: /* Line 1787 of yacc.c */ -#line 572 "./util/configparser.y" +#line 581 "./util/configparser.y" { OUTYY(("P(server_identity:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->identity); @@ -2656,9 +2739,9 @@ yyreduce: } break; - case 174: + case 175: /* Line 1787 of yacc.c */ -#line 579 "./util/configparser.y" +#line 588 "./util/configparser.y" { OUTYY(("P(server_version:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->version); @@ -2666,9 +2749,9 @@ yyreduce: } break; - case 175: + case 176: /* Line 1787 of yacc.c */ -#line 586 "./util/configparser.y" +#line 595 "./util/configparser.y" { OUTYY(("P(server_so_rcvbuf:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->so_rcvbuf)) @@ -2677,9 +2760,9 @@ yyreduce: } break; - case 176: + case 177: /* Line 1787 of yacc.c */ -#line 594 "./util/configparser.y" +#line 603 "./util/configparser.y" { OUTYY(("P(server_so_sndbuf:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->so_sndbuf)) @@ -2688,9 +2771,9 @@ yyreduce: } break; - case 177: + case 178: /* Line 1787 of yacc.c */ -#line 602 "./util/configparser.y" +#line 611 "./util/configparser.y" { OUTYY(("P(server_so_reuseport:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2701,9 +2784,9 @@ yyreduce: } break; - case 178: + case 179: /* Line 1787 of yacc.c */ -#line 612 "./util/configparser.y" +#line 621 "./util/configparser.y" { OUTYY(("P(server_edns_buffer_size:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2717,9 +2800,9 @@ yyreduce: } break; - case 179: + case 180: /* Line 1787 of yacc.c */ -#line 625 "./util/configparser.y" +#line 634 "./util/configparser.y" { OUTYY(("P(server_msg_buffer_size:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2731,9 +2814,9 @@ yyreduce: } break; - case 180: + case 181: /* Line 1787 of yacc.c */ -#line 636 "./util/configparser.y" +#line 645 "./util/configparser.y" { OUTYY(("P(server_msg_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->msg_cache_size)) @@ -2742,9 +2825,9 @@ yyreduce: } break; - case 181: + case 182: /* Line 1787 of yacc.c */ -#line 644 "./util/configparser.y" +#line 653 "./util/configparser.y" { OUTYY(("P(server_msg_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2758,9 +2841,9 @@ yyreduce: } break; - case 182: + case 183: /* Line 1787 of yacc.c */ -#line 657 "./util/configparser.y" +#line 666 "./util/configparser.y" { OUTYY(("P(server_num_queries_per_thread:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2770,9 +2853,9 @@ yyreduce: } break; - case 183: + case 184: /* Line 1787 of yacc.c */ -#line 666 "./util/configparser.y" +#line 675 "./util/configparser.y" { OUTYY(("P(server_jostle_timeout:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -2782,9 +2865,9 @@ yyreduce: } break; - case 184: + case 185: /* Line 1787 of yacc.c */ -#line 675 "./util/configparser.y" +#line 684 "./util/configparser.y" { OUTYY(("P(server_delay_close:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -2794,9 +2877,9 @@ yyreduce: } break; - case 185: + case 186: /* Line 1787 of yacc.c */ -#line 684 "./util/configparser.y" +#line 693 "./util/configparser.y" { OUTYY(("P(server_unblock_lan_zones:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2807,9 +2890,9 @@ yyreduce: } break; - case 186: + case 187: /* Line 1787 of yacc.c */ -#line 694 "./util/configparser.y" +#line 703 "./util/configparser.y" { OUTYY(("P(server_rrset_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->rrset_cache_size)) @@ -2818,9 +2901,9 @@ yyreduce: } break; - case 187: + case 188: /* Line 1787 of yacc.c */ -#line 702 "./util/configparser.y" +#line 711 "./util/configparser.y" { OUTYY(("P(server_rrset_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2834,9 +2917,9 @@ yyreduce: } break; - case 188: + case 189: /* Line 1787 of yacc.c */ -#line 715 "./util/configparser.y" +#line 724 "./util/configparser.y" { OUTYY(("P(server_infra_host_ttl:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -2846,9 +2929,9 @@ yyreduce: } break; - case 189: + case 190: /* Line 1787 of yacc.c */ -#line 724 "./util/configparser.y" +#line 733 "./util/configparser.y" { OUTYY(("P(server_infra_lame_ttl:%s)\n", (yyvsp[(2) - (2)].str))); verbose(VERB_DETAIL, "ignored infra-lame-ttl: %s (option " @@ -2857,9 +2940,9 @@ yyreduce: } break; - case 190: + case 191: /* Line 1787 of yacc.c */ -#line 732 "./util/configparser.y" +#line 741 "./util/configparser.y" { OUTYY(("P(server_infra_cache_numhosts:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2869,9 +2952,9 @@ yyreduce: } break; - case 191: + case 192: /* Line 1787 of yacc.c */ -#line 741 "./util/configparser.y" +#line 750 "./util/configparser.y" { OUTYY(("P(server_infra_cache_lame_size:%s)\n", (yyvsp[(2) - (2)].str))); verbose(VERB_DETAIL, "ignored infra-cache-lame-size: %s " @@ -2880,9 +2963,9 @@ yyreduce: } break; - case 192: + case 193: /* Line 1787 of yacc.c */ -#line 749 "./util/configparser.y" +#line 758 "./util/configparser.y" { OUTYY(("P(server_infra_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -2896,9 +2979,9 @@ yyreduce: } break; - case 193: + case 194: /* Line 1787 of yacc.c */ -#line 762 "./util/configparser.y" +#line 771 "./util/configparser.y" { OUTYY(("P(server_target_fetch_policy:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->target_fetch_policy); @@ -2906,9 +2989,9 @@ yyreduce: } break; - case 194: + case 195: /* Line 1787 of yacc.c */ -#line 769 "./util/configparser.y" +#line 778 "./util/configparser.y" { OUTYY(("P(server_harden_short_bufsize:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2919,9 +3002,9 @@ yyreduce: } break; - case 195: + case 196: /* Line 1787 of yacc.c */ -#line 779 "./util/configparser.y" +#line 788 "./util/configparser.y" { OUTYY(("P(server_harden_large_queries:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2932,9 +3015,9 @@ yyreduce: } break; - case 196: + case 197: /* Line 1787 of yacc.c */ -#line 789 "./util/configparser.y" +#line 798 "./util/configparser.y" { OUTYY(("P(server_harden_glue:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2945,9 +3028,9 @@ yyreduce: } break; - case 197: + case 198: /* Line 1787 of yacc.c */ -#line 799 "./util/configparser.y" +#line 808 "./util/configparser.y" { OUTYY(("P(server_harden_dnssec_stripped:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2958,9 +3041,9 @@ yyreduce: } break; - case 198: + case 199: /* Line 1787 of yacc.c */ -#line 809 "./util/configparser.y" +#line 818 "./util/configparser.y" { OUTYY(("P(server_harden_below_nxdomain:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2971,9 +3054,9 @@ yyreduce: } break; - case 199: + case 200: /* Line 1787 of yacc.c */ -#line 819 "./util/configparser.y" +#line 828 "./util/configparser.y" { OUTYY(("P(server_harden_referral_path:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2984,9 +3067,9 @@ yyreduce: } break; - case 200: + case 201: /* Line 1787 of yacc.c */ -#line 829 "./util/configparser.y" +#line 838 "./util/configparser.y" { OUTYY(("P(server_use_caps_for_id:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -2997,9 +3080,9 @@ yyreduce: } break; - case 201: + case 202: /* Line 1787 of yacc.c */ -#line 839 "./util/configparser.y" +#line 848 "./util/configparser.y" { OUTYY(("P(server_private_address:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->private_address, (yyvsp[(2) - (2)].str))) @@ -3007,9 +3090,9 @@ yyreduce: } break; - case 202: + case 203: /* Line 1787 of yacc.c */ -#line 846 "./util/configparser.y" +#line 855 "./util/configparser.y" { OUTYY(("P(server_private_domain:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->private_domain, (yyvsp[(2) - (2)].str))) @@ -3017,9 +3100,9 @@ yyreduce: } break; - case 203: + case 204: /* Line 1787 of yacc.c */ -#line 853 "./util/configparser.y" +#line 862 "./util/configparser.y" { OUTYY(("P(server_prefetch:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3029,9 +3112,9 @@ yyreduce: } break; - case 204: + case 205: /* Line 1787 of yacc.c */ -#line 862 "./util/configparser.y" +#line 871 "./util/configparser.y" { OUTYY(("P(server_prefetch_key:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3041,9 +3124,9 @@ yyreduce: } break; - case 205: + case 206: /* Line 1787 of yacc.c */ -#line 871 "./util/configparser.y" +#line 880 "./util/configparser.y" { OUTYY(("P(server_unwanted_reply_threshold:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3053,9 +3136,9 @@ yyreduce: } break; - case 206: + case 207: /* Line 1787 of yacc.c */ -#line 880 "./util/configparser.y" +#line 889 "./util/configparser.y" { OUTYY(("P(server_do_not_query_address:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->donotqueryaddrs, (yyvsp[(2) - (2)].str))) @@ -3063,9 +3146,9 @@ yyreduce: } break; - case 207: + case 208: /* Line 1787 of yacc.c */ -#line 887 "./util/configparser.y" +#line 896 "./util/configparser.y" { OUTYY(("P(server_do_not_query_localhost:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3076,9 +3159,9 @@ yyreduce: } break; - case 208: + case 209: /* Line 1787 of yacc.c */ -#line 897 "./util/configparser.y" +#line 906 "./util/configparser.y" { OUTYY(("P(server_access_control:%s %s)\n", (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str))); if(strcmp((yyvsp[(3) - (3)].str), "deny")!=0 && strcmp((yyvsp[(3) - (3)].str), "refuse")!=0 && @@ -3096,9 +3179,9 @@ yyreduce: } break; - case 209: + case 210: /* Line 1787 of yacc.c */ -#line 914 "./util/configparser.y" +#line 923 "./util/configparser.y" { OUTYY(("P(server_module_conf:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->module_conf); @@ -3106,9 +3189,9 @@ yyreduce: } break; - case 210: + case 211: /* Line 1787 of yacc.c */ -#line 921 "./util/configparser.y" +#line 930 "./util/configparser.y" { OUTYY(("P(server_val_override_date:%s)\n", (yyvsp[(2) - (2)].str))); if(strlen((yyvsp[(2) - (2)].str)) == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) { @@ -3127,9 +3210,9 @@ yyreduce: } break; - case 211: + case 212: /* Line 1787 of yacc.c */ -#line 939 "./util/configparser.y" +#line 948 "./util/configparser.y" { OUTYY(("P(server_val_sig_skew_min:%s)\n", (yyvsp[(2) - (2)].str))); if(strlen((yyvsp[(2) - (2)].str)) == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) { @@ -3143,9 +3226,9 @@ yyreduce: } break; - case 212: + case 213: /* Line 1787 of yacc.c */ -#line 952 "./util/configparser.y" +#line 961 "./util/configparser.y" { OUTYY(("P(server_val_sig_skew_max:%s)\n", (yyvsp[(2) - (2)].str))); if(strlen((yyvsp[(2) - (2)].str)) == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) { @@ -3159,9 +3242,9 @@ yyreduce: } break; - case 213: + case 214: /* Line 1787 of yacc.c */ -#line 965 "./util/configparser.y" +#line 974 "./util/configparser.y" { OUTYY(("P(server_cache_max_ttl:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3171,9 +3254,9 @@ yyreduce: } break; - case 214: + case 215: /* Line 1787 of yacc.c */ -#line 974 "./util/configparser.y" +#line 983 "./util/configparser.y" { OUTYY(("P(server_cache_min_ttl:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3183,9 +3266,9 @@ yyreduce: } break; - case 215: + case 216: /* Line 1787 of yacc.c */ -#line 983 "./util/configparser.y" +#line 992 "./util/configparser.y" { OUTYY(("P(server_bogus_ttl:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3195,9 +3278,9 @@ yyreduce: } break; - case 216: + case 217: /* Line 1787 of yacc.c */ -#line 992 "./util/configparser.y" +#line 1001 "./util/configparser.y" { OUTYY(("P(server_val_clean_additional:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3208,9 +3291,9 @@ yyreduce: } break; - case 217: + case 218: /* Line 1787 of yacc.c */ -#line 1002 "./util/configparser.y" +#line 1011 "./util/configparser.y" { OUTYY(("P(server_val_permissive_mode:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3221,9 +3304,9 @@ yyreduce: } break; - case 218: + case 219: /* Line 1787 of yacc.c */ -#line 1012 "./util/configparser.y" +#line 1021 "./util/configparser.y" { OUTYY(("P(server_ignore_cd_flag:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3233,9 +3316,9 @@ yyreduce: } break; - case 219: + case 220: /* Line 1787 of yacc.c */ -#line 1021 "./util/configparser.y" +#line 1030 "./util/configparser.y" { OUTYY(("P(server_val_log_level:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3245,9 +3328,9 @@ yyreduce: } break; - case 220: + case 221: /* Line 1787 of yacc.c */ -#line 1030 "./util/configparser.y" +#line 1039 "./util/configparser.y" { OUTYY(("P(server_val_nsec3_keysize_iterations:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->val_nsec3_key_iterations); @@ -3255,9 +3338,9 @@ yyreduce: } break; - case 221: + case 222: /* Line 1787 of yacc.c */ -#line 1037 "./util/configparser.y" +#line 1046 "./util/configparser.y" { OUTYY(("P(server_add_holddown:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3267,9 +3350,9 @@ yyreduce: } break; - case 222: + case 223: /* Line 1787 of yacc.c */ -#line 1046 "./util/configparser.y" +#line 1055 "./util/configparser.y" { OUTYY(("P(server_del_holddown:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3279,9 +3362,9 @@ yyreduce: } break; - case 223: + case 224: /* Line 1787 of yacc.c */ -#line 1055 "./util/configparser.y" +#line 1064 "./util/configparser.y" { OUTYY(("P(server_keep_missing:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) @@ -3291,9 +3374,9 @@ yyreduce: } break; - case 224: + case 225: /* Line 1787 of yacc.c */ -#line 1064 "./util/configparser.y" +#line 1073 "./util/configparser.y" { OUTYY(("P(server_key_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->key_cache_size)) @@ -3302,9 +3385,9 @@ yyreduce: } break; - case 225: + case 226: /* Line 1787 of yacc.c */ -#line 1072 "./util/configparser.y" +#line 1081 "./util/configparser.y" { OUTYY(("P(server_key_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -3318,9 +3401,9 @@ yyreduce: } break; - case 226: + case 227: /* Line 1787 of yacc.c */ -#line 1085 "./util/configparser.y" +#line 1094 "./util/configparser.y" { OUTYY(("P(server_neg_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->neg_cache_size)) @@ -3329,9 +3412,9 @@ yyreduce: } break; - case 227: + case 228: /* Line 1787 of yacc.c */ -#line 1093 "./util/configparser.y" +#line 1102 "./util/configparser.y" { OUTYY(("P(server_local_zone:%s %s)\n", (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str))); if(strcmp((yyvsp[(3) - (3)].str), "static")!=0 && strcmp((yyvsp[(3) - (3)].str), "deny")!=0 && @@ -3354,9 +3437,9 @@ yyreduce: } break; - case 228: + case 229: /* Line 1787 of yacc.c */ -#line 1115 "./util/configparser.y" +#line 1124 "./util/configparser.y" { OUTYY(("P(server_local_data:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->local_data, (yyvsp[(2) - (2)].str))) @@ -3364,9 +3447,9 @@ yyreduce: } break; - case 229: + case 230: /* Line 1787 of yacc.c */ -#line 1122 "./util/configparser.y" +#line 1131 "./util/configparser.y" { char* ptr; OUTYY(("P(server_local_data_ptr:%s)\n", (yyvsp[(2) - (2)].str))); @@ -3382,9 +3465,9 @@ yyreduce: } break; - case 230: + case 231: /* Line 1787 of yacc.c */ -#line 1137 "./util/configparser.y" +#line 1146 "./util/configparser.y" { OUTYY(("P(server_minimal_responses:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3395,9 +3478,9 @@ yyreduce: } break; - case 231: + case 232: /* Line 1787 of yacc.c */ -#line 1147 "./util/configparser.y" +#line 1156 "./util/configparser.y" { OUTYY(("P(server_rrset_roundrobin:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3408,9 +3491,9 @@ yyreduce: } break; - case 232: + case 233: /* Line 1787 of yacc.c */ -#line 1157 "./util/configparser.y" +#line 1166 "./util/configparser.y" { OUTYY(("P(server_max_udp_size:%s)\n", (yyvsp[(2) - (2)].str))); cfg_parser->cfg->max_udp_size = atoi((yyvsp[(2) - (2)].str)); @@ -3418,9 +3501,9 @@ yyreduce: } break; - case 233: + case 234: /* Line 1787 of yacc.c */ -#line 1164 "./util/configparser.y" +#line 1173 "./util/configparser.y" { OUTYY(("P(dns64_prefix:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->dns64_prefix); @@ -3428,9 +3511,9 @@ yyreduce: } break; - case 234: + case 235: /* Line 1787 of yacc.c */ -#line 1171 "./util/configparser.y" +#line 1180 "./util/configparser.y" { OUTYY(("P(server_dns64_synthall:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3440,9 +3523,9 @@ yyreduce: } break; - case 235: + case 236: /* Line 1787 of yacc.c */ -#line 1180 "./util/configparser.y" +#line 1189 "./util/configparser.y" { OUTYY(("P(name:%s)\n", (yyvsp[(2) - (2)].str))); if(cfg_parser->cfg->stubs->name) @@ -3453,9 +3536,9 @@ yyreduce: } break; - case 236: + case 237: /* Line 1787 of yacc.c */ -#line 1190 "./util/configparser.y" +#line 1199 "./util/configparser.y" { OUTYY(("P(stub-host:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->stubs->hosts, (yyvsp[(2) - (2)].str))) @@ -3463,9 +3546,9 @@ yyreduce: } break; - case 237: + case 238: /* Line 1787 of yacc.c */ -#line 1197 "./util/configparser.y" +#line 1206 "./util/configparser.y" { OUTYY(("P(stub-addr:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->stubs->addrs, (yyvsp[(2) - (2)].str))) @@ -3473,9 +3556,9 @@ yyreduce: } break; - case 238: + case 239: /* Line 1787 of yacc.c */ -#line 1204 "./util/configparser.y" +#line 1213 "./util/configparser.y" { OUTYY(("P(stub-first:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3485,9 +3568,9 @@ yyreduce: } break; - case 239: + case 240: /* Line 1787 of yacc.c */ -#line 1213 "./util/configparser.y" +#line 1222 "./util/configparser.y" { OUTYY(("P(stub-prime:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3498,9 +3581,9 @@ yyreduce: } break; - case 240: + case 241: /* Line 1787 of yacc.c */ -#line 1223 "./util/configparser.y" +#line 1232 "./util/configparser.y" { OUTYY(("P(name:%s)\n", (yyvsp[(2) - (2)].str))); if(cfg_parser->cfg->forwards->name) @@ -3511,9 +3594,9 @@ yyreduce: } break; - case 241: + case 242: /* Line 1787 of yacc.c */ -#line 1233 "./util/configparser.y" +#line 1242 "./util/configparser.y" { OUTYY(("P(forward-host:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->forwards->hosts, (yyvsp[(2) - (2)].str))) @@ -3521,9 +3604,9 @@ yyreduce: } break; - case 242: + case 243: /* Line 1787 of yacc.c */ -#line 1240 "./util/configparser.y" +#line 1249 "./util/configparser.y" { OUTYY(("P(forward-addr:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->forwards->addrs, (yyvsp[(2) - (2)].str))) @@ -3531,9 +3614,9 @@ yyreduce: } break; - case 243: + case 244: /* Line 1787 of yacc.c */ -#line 1247 "./util/configparser.y" +#line 1256 "./util/configparser.y" { OUTYY(("P(forward-first:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3543,17 +3626,17 @@ yyreduce: } break; - case 244: + case 245: /* Line 1787 of yacc.c */ -#line 1256 "./util/configparser.y" +#line 1265 "./util/configparser.y" { OUTYY(("\nP(remote-control:)\n")); } break; - case 254: + case 255: /* Line 1787 of yacc.c */ -#line 1267 "./util/configparser.y" +#line 1276 "./util/configparser.y" { OUTYY(("P(control_enable:%s)\n", (yyvsp[(2) - (2)].str))); if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) @@ -3564,9 +3647,9 @@ yyreduce: } break; - case 255: + case 256: /* Line 1787 of yacc.c */ -#line 1277 "./util/configparser.y" +#line 1286 "./util/configparser.y" { OUTYY(("P(control_port:%s)\n", (yyvsp[(2) - (2)].str))); if(atoi((yyvsp[(2) - (2)].str)) == 0) @@ -3576,9 +3659,9 @@ yyreduce: } break; - case 256: + case 257: /* Line 1787 of yacc.c */ -#line 1286 "./util/configparser.y" +#line 1295 "./util/configparser.y" { OUTYY(("P(control_interface:%s)\n", (yyvsp[(2) - (2)].str))); if(!cfg_strlist_insert(&cfg_parser->cfg->control_ifs, (yyvsp[(2) - (2)].str))) @@ -3586,9 +3669,9 @@ yyreduce: } break; - case 257: + case 258: /* Line 1787 of yacc.c */ -#line 1293 "./util/configparser.y" +#line 1302 "./util/configparser.y" { OUTYY(("P(rc_server_key_file:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->server_key_file); @@ -3596,9 +3679,9 @@ yyreduce: } break; - case 258: + case 259: /* Line 1787 of yacc.c */ -#line 1300 "./util/configparser.y" +#line 1309 "./util/configparser.y" { OUTYY(("P(rc_server_cert_file:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->server_cert_file); @@ -3606,9 +3689,9 @@ yyreduce: } break; - case 259: + case 260: /* Line 1787 of yacc.c */ -#line 1307 "./util/configparser.y" +#line 1316 "./util/configparser.y" { OUTYY(("P(rc_control_key_file:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->control_key_file); @@ -3616,9 +3699,9 @@ yyreduce: } break; - case 260: + case 261: /* Line 1787 of yacc.c */ -#line 1314 "./util/configparser.y" +#line 1323 "./util/configparser.y" { OUTYY(("P(rc_control_cert_file:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->control_cert_file); @@ -3626,17 +3709,160 @@ yyreduce: } break; - case 261: + case 262: +/* Line 1787 of yacc.c */ +#line 1330 "./util/configparser.y" + { + OUTYY(("\nP(dnstap:)\n")); + } + break; + + case 277: +/* Line 1787 of yacc.c */ +#line 1347 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_enable:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 278: +/* Line 1787 of yacc.c */ +#line 1355 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_socket_path:%s)\n", (yyvsp[(2) - (2)].str))); + free(cfg_parser->cfg->dnstap_socket_path); + cfg_parser->cfg->dnstap_socket_path = (yyvsp[(2) - (2)].str); + } + break; + + case 279: +/* Line 1787 of yacc.c */ +#line 1362 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_send_identity:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_send_identity = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 280: +/* Line 1787 of yacc.c */ +#line 1370 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_send_version:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_send_version = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 281: +/* Line 1787 of yacc.c */ +#line 1378 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_identity:%s)\n", (yyvsp[(2) - (2)].str))); + free(cfg_parser->cfg->dnstap_identity); + cfg_parser->cfg->dnstap_identity = (yyvsp[(2) - (2)].str); + } + break; + + case 282: +/* Line 1787 of yacc.c */ +#line 1385 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_version:%s)\n", (yyvsp[(2) - (2)].str))); + free(cfg_parser->cfg->dnstap_version); + cfg_parser->cfg->dnstap_version = (yyvsp[(2) - (2)].str); + } + break; + + case 283: +/* Line 1787 of yacc.c */ +#line 1392 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_log_resolver_query_messages:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_resolver_query_messages = + (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 284: /* Line 1787 of yacc.c */ -#line 1321 "./util/configparser.y" +#line 1401 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_log_resolver_response_messages:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_resolver_response_messages = + (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 285: +/* Line 1787 of yacc.c */ +#line 1410 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_log_client_query_messages:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_client_query_messages = + (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 286: +/* Line 1787 of yacc.c */ +#line 1419 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_log_client_response_messages:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_client_response_messages = + (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 287: +/* Line 1787 of yacc.c */ +#line 1428 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_log_forwarder_query_messages:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_forwarder_query_messages = + (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 288: +/* Line 1787 of yacc.c */ +#line 1437 "./util/configparser.y" + { + OUTYY(("P(dt_dnstap_log_forwarder_response_messages:%s)\n", (yyvsp[(2) - (2)].str))); + if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_forwarder_response_messages = + (strcmp((yyvsp[(2) - (2)].str), "yes")==0); + } + break; + + case 289: +/* Line 1787 of yacc.c */ +#line 1446 "./util/configparser.y" { OUTYY(("\nP(python:)\n")); } break; - case 265: + case 293: /* Line 1787 of yacc.c */ -#line 1330 "./util/configparser.y" +#line 1455 "./util/configparser.y" { OUTYY(("P(python-script:%s)\n", (yyvsp[(2) - (2)].str))); free(cfg_parser->cfg->python_script); @@ -3646,7 +3872,7 @@ yyreduce: /* Line 1787 of yacc.c */ -#line 3650 "util/configparser.c" +#line 3876 "util/configparser.c" default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -3876,7 +4102,7 @@ yyreturn: /* Line 2048 of yacc.c */ -#line 1335 "./util/configparser.y" +#line 1460 "./util/configparser.y" /* parse helper routines could be here */ diff --git a/util/configparser.h b/util/configparser.h index 83dc1d549..b0e07227b 100644 --- a/util/configparser.h +++ b/util/configparser.h @@ -178,7 +178,20 @@ extern int yydebug; VAR_DELAY_CLOSE = 387, VAR_UNBLOCK_LAN_ZONES = 388, VAR_DNS64_PREFIX = 389, - VAR_DNS64_SYNTHALL = 390 + VAR_DNS64_SYNTHALL = 390, + VAR_DNSTAP = 391, + VAR_DNSTAP_ENABLE = 392, + VAR_DNSTAP_SOCKET_PATH = 393, + VAR_DNSTAP_SEND_IDENTITY = 394, + VAR_DNSTAP_SEND_VERSION = 395, + VAR_DNSTAP_IDENTITY = 396, + VAR_DNSTAP_VERSION = 397, + VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES = 398, + VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES = 399, + VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES = 400, + VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES = 401, + VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES = 402, + VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES = 403 }; #endif /* Tokens. */ @@ -315,6 +328,19 @@ extern int yydebug; #define VAR_UNBLOCK_LAN_ZONES 388 #define VAR_DNS64_PREFIX 389 #define VAR_DNS64_SYNTHALL 390 +#define VAR_DNSTAP 391 +#define VAR_DNSTAP_ENABLE 392 +#define VAR_DNSTAP_SOCKET_PATH 393 +#define VAR_DNSTAP_SEND_IDENTITY 394 +#define VAR_DNSTAP_SEND_VERSION 395 +#define VAR_DNSTAP_IDENTITY 396 +#define VAR_DNSTAP_VERSION 397 +#define VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES 398 +#define VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES 399 +#define VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES 400 +#define VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES 401 +#define VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES 402 +#define VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES 403 @@ -328,7 +354,7 @@ typedef union YYSTYPE /* Line 2049 of yacc.c */ -#line 332 "util/configparser.h" +#line 358 "util/configparser.h" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ diff --git a/util/configparser.y b/util/configparser.y index c44f2c019..7a92d9ee7 100644 --- a/util/configparser.y +++ b/util/configparser.y @@ -107,12 +107,21 @@ extern struct config_parser_state* cfg_parser; %token VAR_STUB_FIRST VAR_MINIMAL_RESPONSES VAR_RRSET_ROUNDROBIN %token VAR_MAX_UDP_SIZE VAR_DELAY_CLOSE VAR_UNBLOCK_LAN_ZONES %token VAR_DNS64_PREFIX VAR_DNS64_SYNTHALL +%token VAR_DNSTAP VAR_DNSTAP_ENABLE VAR_DNSTAP_SOCKET_PATH +%token VAR_DNSTAP_SEND_IDENTITY VAR_DNSTAP_SEND_VERSION +%token VAR_DNSTAP_IDENTITY VAR_DNSTAP_VERSION +%token VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES +%token VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES +%token VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES +%token VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES +%token VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES +%token VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES %% toplevelvars: /* empty */ | toplevelvars toplevelvar ; toplevelvar: serverstart contents_server | stubstart contents_stub | forwardstart contents_forward | pythonstart contents_py | - rcstart contents_rc + rcstart contents_rc | dtstart contents_dt ; /* server: declaration */ @@ -1317,6 +1326,122 @@ rc_control_cert_file: VAR_CONTROL_CERT_FILE STRING_ARG cfg_parser->cfg->control_cert_file = $2; } ; +dtstart: VAR_DNSTAP + { + OUTYY(("\nP(dnstap:)\n")); + } + ; +contents_dt: contents_dt content_dt + | ; +content_dt: dt_dnstap_enable | dt_dnstap_socket_path | + dt_dnstap_send_identity | dt_dnstap_send_version | + dt_dnstap_identity | dt_dnstap_version | + dt_dnstap_log_resolver_query_messages | + dt_dnstap_log_resolver_response_messages | + dt_dnstap_log_client_query_messages | + dt_dnstap_log_client_response_messages | + dt_dnstap_log_forwarder_query_messages | + dt_dnstap_log_forwarder_response_messages + ; +dt_dnstap_enable: VAR_DNSTAP_ENABLE STRING_ARG + { + OUTYY(("P(dt_dnstap_enable:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap = (strcmp($2, "yes")==0); + } + ; +dt_dnstap_socket_path: VAR_DNSTAP_SOCKET_PATH STRING_ARG + { + OUTYY(("P(dt_dnstap_socket_path:%s)\n", $2)); + free(cfg_parser->cfg->dnstap_socket_path); + cfg_parser->cfg->dnstap_socket_path = $2; + } + ; +dt_dnstap_send_identity: VAR_DNSTAP_SEND_IDENTITY STRING_ARG + { + OUTYY(("P(dt_dnstap_send_identity:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_send_identity = (strcmp($2, "yes")==0); + } + ; +dt_dnstap_send_version: VAR_DNSTAP_SEND_VERSION STRING_ARG + { + OUTYY(("P(dt_dnstap_send_version:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_send_version = (strcmp($2, "yes")==0); + } + ; +dt_dnstap_identity: VAR_DNSTAP_IDENTITY STRING_ARG + { + OUTYY(("P(dt_dnstap_identity:%s)\n", $2)); + free(cfg_parser->cfg->dnstap_identity); + cfg_parser->cfg->dnstap_identity = $2; + } + ; +dt_dnstap_version: VAR_DNSTAP_VERSION STRING_ARG + { + OUTYY(("P(dt_dnstap_version:%s)\n", $2)); + free(cfg_parser->cfg->dnstap_version); + cfg_parser->cfg->dnstap_version = $2; + } + ; +dt_dnstap_log_resolver_query_messages: VAR_DNSTAP_LOG_RESOLVER_QUERY_MESSAGES STRING_ARG + { + OUTYY(("P(dt_dnstap_log_resolver_query_messages:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_resolver_query_messages = + (strcmp($2, "yes")==0); + } + ; +dt_dnstap_log_resolver_response_messages: VAR_DNSTAP_LOG_RESOLVER_RESPONSE_MESSAGES STRING_ARG + { + OUTYY(("P(dt_dnstap_log_resolver_response_messages:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_resolver_response_messages = + (strcmp($2, "yes")==0); + } + ; +dt_dnstap_log_client_query_messages: VAR_DNSTAP_LOG_CLIENT_QUERY_MESSAGES STRING_ARG + { + OUTYY(("P(dt_dnstap_log_client_query_messages:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_client_query_messages = + (strcmp($2, "yes")==0); + } + ; +dt_dnstap_log_client_response_messages: VAR_DNSTAP_LOG_CLIENT_RESPONSE_MESSAGES STRING_ARG + { + OUTYY(("P(dt_dnstap_log_client_response_messages:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_client_response_messages = + (strcmp($2, "yes")==0); + } + ; +dt_dnstap_log_forwarder_query_messages: VAR_DNSTAP_LOG_FORWARDER_QUERY_MESSAGES STRING_ARG + { + OUTYY(("P(dt_dnstap_log_forwarder_query_messages:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_forwarder_query_messages = + (strcmp($2, "yes")==0); + } + ; +dt_dnstap_log_forwarder_response_messages: VAR_DNSTAP_LOG_FORWARDER_RESPONSE_MESSAGES STRING_ARG + { + OUTYY(("P(dt_dnstap_log_forwarder_response_messages:%s)\n", $2)); + if(strcmp($2, "yes") != 0 && strcmp($2, "no") != 0) + yyerror("expected yes or no."); + else cfg_parser->cfg->dnstap_log_forwarder_response_messages = + (strcmp($2, "yes")==0); + } + ; pythonstart: VAR_PYTHON { OUTYY(("\nP(python:)\n")); diff --git a/util/netevent.c b/util/netevent.c index 421d1a1bd..c7ed30e6c 100644 --- a/util/netevent.c +++ b/util/netevent.c @@ -45,6 +45,7 @@ #include "util/fptr_wlist.h" #include "ldns/pkthdr.h" #include "ldns/sbuffer.h" +#include "dnstap/dnstap.h" #ifdef HAVE_OPENSSL_SSL_H #include #endif @@ -1940,7 +1941,19 @@ comm_point_send_reply(struct comm_reply *repinfo) else comm_point_send_udp_msg(repinfo->c, repinfo->c->buffer, (struct sockaddr*)&repinfo->addr, repinfo->addrlen); +#ifdef USE_DNSTAP + if(repinfo->c->dtenv != NULL && + repinfo->c->dtenv->log_client_response_messages) + dt_msg_send_client_response(repinfo->c->dtenv, + &repinfo->addr, repinfo->c->type, repinfo->c->buffer); +#endif } else { +#ifdef USE_DNSTAP + if(repinfo->c->tcp_parent->dtenv != NULL && + repinfo->c->tcp_parent->dtenv->log_client_response_messages) + dt_msg_send_client_response(repinfo->c->tcp_parent->dtenv, + &repinfo->addr, repinfo->c->type, repinfo->c->buffer); +#endif comm_point_start_listening(repinfo->c, -1, TCP_QUERY_TIMEOUT); } } diff --git a/util/netevent.h b/util/netevent.h index fe28ca5dd..37322ab93 100644 --- a/util/netevent.h +++ b/util/netevent.h @@ -188,6 +188,10 @@ struct comm_point { comm_ssl_shake_hs_write } ssl_shake_state; + /* -------- dnstap ------- */ + /** the dnstap environment */ + struct dt_env* dtenv; + /** is this a UDP, TCP-accept or TCP socket. */ enum comm_point_type { /** UDP socket - handle datagrams. */