#

# Keepalived OpenSource project.

#

# Configuration template file for keepalived.

# autoconf will generate & check deps for proper compilation

#

# Copyright (C) 2001-2018 Alexandre Cassen, <acassen@linux-vs.org>

AC_DEFUN([add_to_var], [$1="$$1 $2"])

AC_DEFUN([add_to_var_ind], [eval $1=\"\$$1 $2\"]) dnl "

AC_DEFUN([add_to_var_ind_unique],

  ADD_NEW=

  [ eval var=\$$1

    for item in $2; do

      echo " $var " | $GREP -q " $item "

      if test $? -ne 0; then

	add_to_var([ADD_NEW], [$item])

      fi

    done

    add_to_var_ind([$1], [$ADD_NEW])

  ])

AC_DEFUN([add_pkg_config],

  [ if test -n "$2"; then

      KA_PKG_PFX=$2

    else

      KA_PKG_PFX=KA

    fi

    add_to_var_ind_unique([${KA_PKG_PFX}_CPPFLAGS], [`$PKG_CONFIG --cflags-only-I $1`])

    add_to_var_ind_unique([${KA_PKG_PFX}_CFLAGS], [`$PKG_CONFIG --cflags-only-other $1`])

    if test .$3 = .remove-requires; then

      REQUIRES=`$PKG_CONFIG --print-requires $1`

      var=`$PKG_CONFIG --libs-only-l $1`

      for r in $REQUIRES; do

	REQ_LIBS=`$PKG_CONFIG --libs-only-l $r`

	for l in $REQ_LIBS; do

	  var=`echo " $var " | sed -e "s: $l : :g"`

	done

      done

      var=`echo $var | sed -e "s:^ *::" -e "s:  *$::"`

      eval ${KA_PKG_PFX}_LIBS="\"$var\""

      var=`echo $var | sed -e "s/-l//g"`

      eval ${KA_PKG_PFX}_LIB_NAMES="\"$var\""

    else

      add_to_var_ind_unique([${KA_PKG_PFX}_LIBS], [`$PKG_CONFIG --libs $1`])

    fi

  ])

AC_DEFUN([add_pkg_config_without_libs],

  [ if test -n "$2"; then

      KA_PKG_PFX=$2

    else

      KA_PKG_PFX=KA

    fi

    add_to_var_ind_unique([${KA_PKG_PFX}_CPPFLAGS], [$($PKG_CONFIG --cflags-only-I $1)])

    add_to_var_ind_unique([${KA_PKG_PFX}_CFLAGS], [$($PKG_CONFIG --cflags-only-other $1)])

  ])

AC_DEFUN([add_config_opt], [add_to_var([CONFIG_OPTIONS], [$1])])

AC_DEFUN([add_system_opt], [add_to_var([SYSTEM_OPTIONS], [$1])])

AC_DEFUN([get_lib_name],

  [

    if test $LDD = :; then

      AC_MSG_ERROR([ldd is required for dynamic run-time linking support])

    fi

    SAV_LIBS="$LIBS"

    LIBS="$LIBS -l$1"

    AC_LINK_IFELSE([AC_LANG_SOURCE([[

      extern void $2(void);

      int main(void)

      {

	$2();

	return 0;

      }

    ]])], [

      LIB_DETAILS=`$LDD ./conftest$EXEEXT | grep $1.so | sed -e "s/^[[ \t]]*//"`

      LIB_NAME=`echo $LIB_DETAILS | sed -e "s/ .*//"`

    ],[

    ])

    LIBS="$SAV_LIBS"

  ])

# AS_VAR_COPY was introduced in autoconf 2.63b.

# Remove the following definition once require autoconf >= 2.64.

m4_ifndef([AS_VAR_COPY],

[m4_define([AS_VAR_COPY],

[AS_LITERAL_IF([$1[]$2], [$1=$$2], [eval $1=\$$2])])])

dnl ----[ Process this file with autoconf to produce a configure script ]----

AC_PREREQ([2.63])

AC_INIT([Keepalived], [2.1.5], [keepalived-users@groups.io], [], [http://www.keepalived.org/])

AC_CONFIG_AUX_DIR([build-aux])

AC_CONFIG_MACRO_DIR([m4])

AM_INIT_AUTOMAKE([-Wall -Werror -Woverride foreign])

AC_CONFIG_SRCDIR([keepalived/core/main.c])

AC_CONFIG_HEADERS([lib/config.h lib/config_warnings.h])

AH_TOP(

  [

#ifndef _CONFIG_H

#define _CONFIG_H

  ])

AH_BOTTOM(

  [

#include "config_warnings.h"

#ifndef _GNU_SOURCE

#define _GNU_SOURCE

#endif

#endif])

AC_CONFIG_FILES([Makefile keepalived/Makefile lib/Makefile keepalived/core/Makefile keepalived.spec \

		 genhash/Makefile keepalived/check/Makefile keepalived/vrrp/Makefile \

		 keepalived/bfd/Makefile doc/Makefile bin_install/Makefile keepalived/dbus/Makefile \

		 keepalived/etc/Makefile keepalived/etc/init/Makefile keepalived/etc/init.d/Makefile \

		 keepalived/trackers/Makefile \

		 doc/man/man8/Makefile])

MAINTAINERCLEANFILES="*~ *.orig *.rej core core.*"

AC_SUBST(MAINTAINERCLEANFILES)

CONFIG_OPTIONS=

SYSTEM_OPTIONS=

AM_SILENT_RULES([yes])

PKG_PROG_PKG_CONFIG

dnl ----[ Keepalived specific configure options ]----

AC_ARG_ENABLE(lvs-syncd,

  [AS_HELP_STRING([--disable-lvs-syncd], [do not use LVS synchronization daemon])])

AC_ARG_ENABLE(lvs,

  [AS_HELP_STRING([--disable-lvs], [do not use the LVS framework])])

AC_ARG_ENABLE(lvs-64bit-stats,

  [AS_HELP_STRING([--disable-lvs-64bit-stats], [do not use the LVS 64-bit stats])])

AC_ARG_ENABLE(vrrp,

  [AS_HELP_STRING([--disable-vrrp], [do not use the VRRP framework])])

AC_ARG_ENABLE(bfd,

  [AS_HELP_STRING([--enable-bfd], [use the BFD framework])])

AC_ARG_WITH(kernel-dir,

  [AS_HELP_STRING([--with-kernel-dir=DIR], [path to linux kernel source directory])],

  [AS_HELP_STRING([kernel_src_path="$withval"],], [[kernel_src_path=""])])

AC_ARG_ENABLE(fwmark,

  [AS_HELP_STRING([--disable-fwmark], [compile without SO_MARK support])])

AC_ARG_ENABLE(snmp,

  [AS_HELP_STRING([--enable-snmp], [compile with SNMP support])])

AC_ARG_ENABLE(snmp-vrrp,

  [AS_HELP_STRING([--enable-snmp-vrrp], [compile with SNMP vrrp support])])

AC_ARG_ENABLE(snmp-keepalived,

  [AS_HELP_STRING([--enable-snmp-keepalived], [obsolete - use --enable-snmp-vrrp])])

AC_ARG_ENABLE(snmp-checker,

  [AS_HELP_STRING([--enable-snmp-checker], [compile with SNMP checker support])])

AC_ARG_ENABLE(snmp-rfc,

  [AS_HELP_STRING([--enable-snmp-rfc], [compile with SNMP RFC2787 (VRRPv2) and SNMP RFC6527 (VRRPv3) support])])

AC_ARG_ENABLE(snmp-rfcv2,

  [AS_HELP_STRING([--enable-snmp-rfcv2], [compile with SNMP RFC2787 (VRRPv2) support])])

AC_ARG_ENABLE(snmp-rfcv3,

  [AS_HELP_STRING([--enable-snmp-rfcv3], [compile with SNMP RFC6527 (VRRPv3) support])])

AC_ARG_ENABLE(snmp-reply-v3-for-v2,

  [AS_HELP_STRING([--disable-snmp-reply-v3-for-v2], [disable RFC6527 responses for VRRPv2 instances])])

AC_ARG_ENABLE(dbus,

  [AS_HELP_STRING([--enable-dbus], [compile with dbus support])])

AC_ARG_ENABLE(dbus-create-instance,

  [AS_HELP_STRING([--enable-dbus-create-instance], [compile with dbus support for creating instances])])

AC_ARG_ENABLE(sha1,

  [AS_HELP_STRING([--enable-sha1], [compile with SHA1 support])])

AC_ARG_ENABLE(regex,

  [AS_HELP_STRING([--enable-regex], [build with HTTP_GET regex checking])])

AC_ARG_ENABLE(vmac,

  [AS_HELP_STRING([--disable-vmac], [build without VMAC support])])

AC_ARG_ENABLE(regex-timers,

  [AS_HELP_STRING([--enable-regex-timers], [build with HTTP_GET regex timers])])

AC_ARG_ENABLE(json,

  [AS_HELP_STRING([--enable-json], [compile with signal to dump configuration and stats as json])])

AC_ARG_WITH(init,

  [AS_HELP_STRING([--with-init=(upstart|systemd|SYSV|SUSE|openrc)], [specify init type])],

  [init_type="$withval"], [init_type=""])

AC_ARG_ENABLE(vrrp-auth,

  [AS_HELP_STRING([--disable-vrrp-auth], [compile without VRRP authentication])])

AC_ARG_ENABLE(checksum_compat,

  [AS_HELP_STRING([--disable-checksum-compat], [compile without v1.3.6 and earlier VRRPv3 unicast checksum compatibility])])

AC_ARG_ENABLE(routes,

  [AS_HELP_STRING([--disable-routes], [compile without ip rules/routes])])

AC_ARG_ENABLE(linkbeat,

  [AS_HELP_STRING([--disable-linkbeat], [build without linkbeat support])])

AC_ARG_ENABLE(gnu-std-paths,

  [AS_HELP_STRING([--enable-gnu-std-paths], [use GNU standard paths for pid files etc])])

AC_ARG_ENABLE(dynamic-linking,

  [AS_HELP_STRING([--enable-dynamic-linking], [compile with/without dynamically linked libiptc/libipset/libnl])])

AC_ARG_ENABLE(iptables,

  [AS_HELP_STRING([--disable-iptables], [compile without iptables support])],

  [], [IPTABLES_SILENT=Yes])

AC_ARG_ENABLE(libiptc-dynamic,

  [AS_HELP_STRING([--enable-libiptc-dynamic], [compile with libiptc dynamically linked])])

AC_ARG_ENABLE(libipset-dynamic,

  [AS_HELP_STRING([--disable-libipset-dynamic], [compile with libipset statically linked])])

AC_ARG_ENABLE(libnl-dynamic,

  [AS_HELP_STRING([--enable-libnl-dynamic], [compile with libnl dynamically linked])])

AC_ARG_ENABLE(libipset,

  [AS_HELP_STRING([--disable-libipset], [compile without libipset])])

AC_ARG_ENABLE(nftables,

  [AS_HELP_STRING([--disable-nftables], [build without nftables support])],

  [], [NFTABLES_SILENT=Yes])

AC_ARG_ENABLE(libnl,

  [AS_HELP_STRING([--disable-libnl], [compile without libnl])])

AC_ARG_ENABLE(track-process,

  [AS_HELP_STRING([--disable-track-process], [build without track-process functionality])])

AC_ARG_WITH(run-dir,

  [AS_HELP_STRING([--with-run-dir=PATH_TO_RUN], [specify directory where /run is located])],

  [RUN_DIR_SPECIFIED=Y], [RUN_DIR_SPECIFIED=N])

AC_ARG_ENABLE(strict-config-checks,

  [AS_HELP_STRING([--enable-strict-config-checks], [build with strict configuration checking])])

AC_ARG_ENABLE(hardening,

  [AS_HELP_STRING([--disable-hardening], [do not build with security hardening])])

AC_ARG_ENABLE(optimise,

  [AS_HELP_STRING([--enable-optimise], [compiler optimisation level])], [], [enable_optimise=not-specified])

AC_ARG_ENABLE(warnings,

  [AS_HELP_STRING([--enable-warnings[[=WARNINGS]]], [additional compiler warnings, disable for reduced set])], [], [enable_warnings=yes])

AC_ARG_ENABLE(extra-warnings,

  [AS_HELP_STRING([--enable-extra-warnings], [extra compiler warnings that will probably produce many warnings])])

AC_ARG_ENABLE(mem-check,

  [AS_HELP_STRING([--enable-mem-check], [compile with memory alloc checking])])

AC_ARG_ENABLE(mem-check-log,

  [AS_HELP_STRING([--enable-mem-check-log], [compile with memory alloc checking writing to syslog])])

AC_ARG_ENABLE(timer-check,

  [AS_HELP_STRING([--enable-timer-check], [compile with set time logging])])

AC_ARG_ENABLE(debug,

  [AS_HELP_STRING([--enable-debug], [compile with most debugging options])])

AC_ARG_ENABLE(netlink-timers,

  [AS_HELP_STRING([--enable-netlink-timers], [compile with netlink command timers])])

AC_ARG_ENABLE(smtp-alert-debug,

  [AS_HELP_STRING([--enable-smtp-alert-debug], [compile with smtp-alert debugging])])

AC_ARG_ENABLE(stacktrace,

  [AS_HELP_STRING([--enable-stacktrace], [compile with stacktrace support])])

AC_ARG_ENABLE(perf,

  [AS_HELP_STRING([--enable-perf], [compile with perf performance data recording support for vrrp process])])

AC_ARG_ENABLE(log-file,

  [AS_HELP_STRING([--enable-log-file], [enable logging to file (-g)])])

AC_ARG_ENABLE(dump-threads,

  [AS_HELP_STRING([--enable-dump-threads], [compile with thread dumping support])])

AC_ARG_ENABLE(epoll-debug,

  [AS_HELP_STRING([--enable-epoll-debug], [compile with epoll_wait() debugging support])])

AC_ARG_ENABLE(epoll-thread-dump,

  [AS_HELP_STRING([--enable-epoll-thread-dump], [compile with epoll thread dumping support])])

AC_ARG_ENABLE(regex-debug,

  [AS_HELP_STRING([--enable-regex-debug], [compile with regex debugging support])])

AC_ARG_ENABLE(tsm-debug,

  [AS_HELP_STRING([--enable-tsm-debug], [compile with TSM debugging support])])

AC_ARG_ENABLE(vrrp-fd-debug,

  [AS_HELP_STRING([--enable-vrrp-fd-debug], [compile with vrrp fd debugging support])])

AC_ARG_ENABLE(eintr-debug,

  [AS_HELP_STRING([--enable-eintr-debug], [compile with EINTR debugging support, set to check/not check for EINTR])])

AC_ARG_ENABLE(track-process-debug,

  [AS_HELP_STRING([--enable-track-process-debug], [compile with track process debugging support, set to log all process connector events])])

AC_ARG_ENABLE(parser-debug,

  [AS_HELP_STRING([--enable-parser-debug], [compile with parser debugging support])])

AC_ARG_ENABLE(checksum-debug,

  [AS_HELP_STRING([--enable-checksum-debug], [compile with checksum debugging support])])

AC_ARG_ENABLE(genhash-debug,

  [AS_HELP_STRING([--enable-genhash-debug], [compile with genhash debugging support])])

AC_ARG_ENABLE(checker-debug,

  [AS_HELP_STRING([--enable-checker-debug], [compile with checker debugging support])])

AC_ARG_ENABLE(smtp-connect-debug,

  [AS_HELP_STRING([--enable-smtp-connect-debug], [compile with smtp connect debugging support])])

AC_ARG_ENABLE(mem-err-debug,

  [AS_HELP_STRING([--enable-mem-err-debug], [compile with MALLOC/FREE error debugging support])])

AC_ARG_ENABLE(script-debug,

  [AS_HELP_STRING([--enable-script-debug], [compile with script termination debugging support])])

AC_ARG_ENABLE(one-process-debug,

  [AS_HELP_STRING([--enable-one-process-debug], [compile with all functionality running in a single process])])

AC_ARG_ENABLE(dump-keywords,

  [AS_HELP_STRING([--enable-dump-keywords], [compile with keyword dumping support])])

AC_ARG_ENABLE(network-timestamp,

  [AS_HELP_STRING([--enable-network-timestamp], [compile with network timestamp debugging support])])

AC_ARG_ENABLE(asserts,

  [AS_HELP_STRING([--enable-asserts], [compile with assert() enabled])])

AC_ARG_WITH(fixed-if-type,

  [AS_HELP_STRING([--with-fixed-if-type=TYPE], [treat interface type TYPE as unchangeable])])

AC_ARG_WITH(default-config-file,

  AS_HELP_STRING([--with-default-config-file=FILE], [Default configuration file]),

  [default_config_file="$withval"], [default_config_file=""])

AC_ARG_ENABLE(profile,

  [AS_HELP_STRING([--enable-profile], [compile with profiling flags])])

AC_ARG_ENABLE(conversion-checks,

  [AS_HELP_STRING([--enable-conversion-checks], [compile with conversion warnings if sensible])])

AC_ARG_ENABLE(force-conversion-checks,

  [AS_HELP_STRING([--enable-force-conversion-checks], [compile with conversion warnings])])

AC_ARG_ENABLE(Werror,

  [AS_HELP_STRING([--enable-Werror], [compile with warnings being errors])])

AC_ARG_WITH([systemdsystemunitdir],

	AS_HELP_STRING([--with-systemdsystemunitdir=DIR], [Directory for systemd service files])])

# Set the kernel headers path

if test -n "$kernel_src_path"; then

  if test ! -d $kernel_src_path/include; then

    AC_MSG_ERROR([kernel source path $kernel_src_path/include does not exist])

  fi

  if test ! -d $kernel_src_path/include/linux; then

    AC_MSG_ERROR([kernel source path $kernel_src_path/include does not appear to include linux header files])

  fi

  if test -d $kernel_src_path/include/uapi/linux; then

    AC_MSG_ERROR([kernel source path $kernel_src_path appears to be an unprocessed kernel source tree])

  fi

  kernelinc="-isystem $kernel_src_path/include"

elif test ! -d /usr/include/linux -a \

	    -d /usr/src/linux/include; then

  kernelinc="-isystem /usr/src/linux/include"

else

  kernelinc=

fi

CPPFLAGS="$kernelinc $CPPFLAGS"

# Checks for programs.

AC_PROG_CC

AC_PROG_MAKE_SET

AC_PROG_INSTALL

AC_PROG_RANLIB

AC_PROG_GREP

AC_PROG_LN_S

AC_PROG_SED

AC_CHECK_TOOL(STRIP,strip)

AC_CHECK_TOOL(LDD,ldd)

m4_ifdef([AM_PROG_AR], [AM_PROG_AR])

ARFLAGS=cr

AC_SUBST(ARFLAGS)

# Default settings

ENABLE_LOG_FILE_APPEND=No

# AC_PROG_LIBTOOL

#

# save the configure arguments

#

args=`echo $ac_configure_args | $SED -e "s/'//g"`

AC_DEFINE_UNQUOTED(KEEPALIVED_CONFIGURE_OPTIONS,"$args", [configure options specified])

# Save the CPPFLAGS, CFLAGS, LDFLAGS and LDLIBS settings for make time

KA_CPPFLAGS="$kernelinc -D_GNU_SOURCE $CPPFLAGS"

KA_CFLAGS="-g $CFLAGS"

KA_LDFLAGS=$LDFLAGS

KA_LIBS=$LDLIBS

NEED_LIBDL=No

#KA_LIBTOOLFLAGS =

# Set up the compiler warnings we want

dnl -- Unused warnings - traditional

MAX_FRAME_SIZE=5120

WARNINGS_BASIC="all extra unused strict-prototypes"

WARNINGS_STD="absolute-value address-of-packed-member alloca alloc-zero array-bounds=2 attribute-alias bad-function-cast cast-align cast-qual chkp date-time disabled-optimization double-promotion duplicated-branches duplicated-cond float-conversion float-equal format-overflow format-security format-signedness format-truncation frame-larger-than=$MAX_FRAME_SIZE implicit-fallthrough=3 init-self inline jump-misses-init logical-op missing-declarations missing-field-initializers missing-prototypes nested-externs normalized null-dereference old-style-definition overlength-strings pointer-arith redundant-decls shadow shift-overflow=2 stack-protector strict-overflow=4 strict-prototypes stringop-overflow=2 suggest-attribute=cold suggest-attribute=const suggest-attribute=format suggest-attribute=malloc suggest-attribute=noreturn suggest-attribute=pure sync-nand trampolines undef uninitialized unknown-pragmas unsuffixed-float-constants unused-const-variable=2 unused-macros variadic-macros write-strings"

WARNINGS_EXTRA="aggregate-return cast-align= strict conversion format-nonliteral format-overflow=2 format-truncation=2 padded pedantic sign-conversion stack-usage=$MAX_FRAME_SIZE strict-overflow=5 stringop-overflow=3 stringop-overflow=4 switch-enum system-headers traditional-conversion"

# We want _GNU_SOURCE defined always

add_to_var([CPPFLAGS], [-D_GNU_SOURCE])

# fpclassify() needs -lm

add_to_var([KA_LIBS], [-lm])

# Some sanity checks on configure options

AS_IF([test .$enable_vrrp = .no],

    AS_IF([test .$IPTABLES_SILENT == .Yes], [enable_iptables=no])

    AS_IF([test .$NFTABLES_SILENT == .Yes], [enable_nftables=no])

    AS_IF([test .$enable_perf != .], [AC_MSG_ERROR([enable-perf requires vrrp])])

    AS_IF([test $with_fixed_if_type], [AC_MSG_ERROR([with-fixed-if-type requires vrrp])])

    AS_IF([test .$enable_vrrp_fd_debug != .], [AC_MSG_ERROR([enable-vrrp-fd-debug requires vrrp])])

    AS_IF([test .$enable_tsm_debug != .], [AC_MSG_ERROR([enable-tsm-debug requires vrrp])])

    AS_IF([test .$enable_json != .], [AC_MSG_ERROR([enable-json requires vrrp])])

    AS_IF([test .$enable_snmp_vrrp != .], [AC_MSG_ERROR([enable-snmp-vrrp requires vrrp])])

    AS_IF([test .$enable_snmp_keepalived != .], [AC_MSG_ERROR([enable-snmp-keepalived requires vrrp])])

    AS_IF([test .$enable_snmp_rfc != .], [AC_MSG_ERROR([enable-snmp-rfc requires vrrp])])

    AS_IF([test .$enable_snmp_rfcv2 != .], [AC_MSG_ERROR([enable-snmp-rfcv2 requires vrrp])])

    AS_IF([test .$enable_snmp_rfcv3 != .], [AC_MSG_ERROR([enable-snmp-rfcv3 requires vrrp])])

    AS_IF([test .$enable_dbus != .], [AC_MSG_ERROR([enable-dbus requires vrrp])])

    AS_IF([test .$enable_vrrp_auth != .], [AC_MSG_ERROR([disable-vrrp-auth requires vrrp])])

    AS_IF([test .$enable_checksum_compat != .], [AC_MSG_ERROR([disable-checksum-compat requires vrrp])])

    AS_IF([test .$enable_routes != .], [AC_MSG_ERROR([disable-routes requires vrrp])])

    AS_IF([test .$enable_linkbeat != .], [AC_MSG_ERROR([disable-linkbeat requires vrrp])])

    AS_IF([test .$enable_bfd != .], [AC_MSG_ERROR([enable-bfd requires vrrp])])

    AS_IF([test .$enable_iptables != .no], [AC_MSG_ERROR([enable-iptables requires vrrp])])

    AS_IF([test .$enable_nftables != .no], [AC_MSG_ERROR([enable-nftables requires vrrp])])

    AS_IF([test .$enable_track_process != .], [AC_MSG_ERROR([enable-track-process requires vrrp])])

    AS_IF([test .$enable_network_timestamp != .], [AC_MSG_ERROR([enable-network-timestamp requires vrrp])])

    AS_IF([test .$enable_netlink_timers != .], [AC_MSG_ERROR([enable-netlink-timers requires vrrp])])

  )

AS_IF([test .$enable_iptables = .no],

    AS_IF([test .$enable_libipset != .], [AC_MSG_ERROR([disable-libipset requires vrrp and iptables])])

  )

AS_IF([test .$enable_libipset = .no],

    AS_IF([test .$enable_libipset_dynamic != .], [AC_MSG_ERROR([disable-libipset-dynamic requires ipsets])])

  )

AS_IF([test .$enable_snmp_rfc != .yes -a .$enable_snmp_rfcv3 != yes],

    AS_IF([test .$enable_snmp_reply_v3_for_v2 != .], [AC_MSG_ERROR([enable-snmp-reply-v3-for-v2 requires enable-snmp-rfcv3 or enable-snmp-rfc])])

  )

AS_IF([test .$enable_dbus != .yes],

    AS_IF([test .$enable_dbus_create_instance != .], [AC_MSG_ERROR([enable-dbus-create-instance requires enable-dbus])])

  )

AS_IF([test .$enable_lvs = .no],

    AS_IF([test .$enable_regex != .], [AC_MSG_ERROR([enable-regex requires lvs])])

    AS_IF([test .$enable_libnl != .], [AC_MSG_ERROR([disable-libnl requires lvs])])

    AS_IF([test .$enable_lvs_syncd != .], [AC_MSG_ERROR([disable-lvs-syncd requires lvs])])

    AS_IF([test .$enable_lvs_64bit_stats != .], [AC_MSG_ERROR([disable-lvs-64bit-stats requires lvs])])

    AS_IF([test .$enable_fwmark != .], [AC_MSG_ERROR([enable-fwmark requires lvs])])

    AS_IF([test .$enable_checker_debug != .], [AC_MSG_ERROR([enable-checker-debug requires lvs])])

  )

AS_IF([test .$enable_libnl = .no],

    AS_IF([test .$enable_libnl_dynamic != .], [AC_MSG_ERROR([enable-libnl-dynamic requires lvs and libnl])])

  )

AS_IF([test .$enable_regex != .yes],

    AS_IF([test .$enable_regex_timers != .], [AC_MSG_ERROR([enable-regex-timers requires enable-regex])])

    AS_IF([test .$enable_regex_debug != .], [AC_MSG_ERROR([enable-regex-debug requires enable-regex])])

  )

AS_IF([test .$enable_track_process = .no],

    AS_IF([test .$enable_track_process_debug != .], [AC_MSG_ERROR([enable-track-process-debug incompatible with disable-track-process])])

  )

AS_IF([test .$enable_mem_check != .yes],

    AS_IF([test .$enable_mem_err_debug != .], [AC_MSG_ERROR([enable-mem-err-debug requires --enable-mem-check])])

  )

# --enable-debug enables most debugging if not explicitly disabled, but NOT one-process-debug or genhash-debug

AS_IF([test .$enable_debug = .yes],

  [

    # If we are debugging, we want to be able to write logs to files

    AS_IF([test .$enable_log_file = .], [enable_log_file=yes])

    AS_IF([test .$enable_asserts = .], [enable_asserts=yes])

    AS_IF([test .$enable_epoll_debug = .], [enable_epoll_debug=yes])

    AS_IF([test .$enable_epoll_thread_dump = .], [enable_epoll_thread_dump=yes])

    AS_IF([test .$enable_eintr_debug = .], [enable_eintr_debug=yes])

    AS_IF([test .$enable_parser_debug = .], [enable_parser_debug=yes])

    AS_IF([test .$enable_timer_check = .], [enable_timer_check=yes])

    AS_IF([test .$enable_smtp_alert_debug = .], [enable_smtp_alert_debug=yes])

    AS_IF([test .$enable_smtp_connect_debug = .], [enable_smtp_connect_debug=yes])

    AS_IF([test .$enable_dump_keywords = .], [enable_dump_keywords=yes])

    AS_IF([test .$enable_script_debug = .], [enable_script_debug=yes])

    AS_IF([test .$enable_vrrp != .no],

      [

	AS_IF([test .$enable_vrrp_fd_debug = .], [enable_vrrp_fd_debug=yes])

	AS_IF([test .$enable_tsm_debug = .], [enable_tsm_debug=yes])

	AS_IF([test .$enable_track_process_debug = .], [enable_track_process_debug=yes])

	AS_IF([test .$enable_checksum_debug = .], [enable_checksum_debug=yes])

	AS_IF([test .$enable_netlink_timers = .], [enable_netlink_timers=yes])

	AS_IF([test .$enable_network_timestamp = .], [enable_network_timestamp=yes])

      ])

    AS_IF([test .$enable_lvs != .no],

      [

	AS_IF([test .$enable_checker_debug = .], [enable_checker_debug=yes])

	AS_IF([test .$enable_regex = .yes],

	  [

	    AS_IF([test .$enable_regex_timers = .], [enable_regex_timers=yes])

	    AS_IF([test .$enable_regex_debug = .], [enable_regex_debug=yes])

	  ])

      ])

    AS_IF([test .$enable_mem_check = .yes],

      [

	AS_IF([test .$enable_mem_err_debug = .], [enable_mem_err_debug=yes])

      ])

  ])

dnl -- ulibc/glibc differences

AC_MSG_CHECKING([msghdr.msg_controllen is size_t])

SAV_CFLAGS=$CFLAGS

CFLAGS="$CFLAGS -Werror"

AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

  #include <sys/socket.h>

  #include <stdio.h>

  int main(int argc, char**argv)

  {

    struct msghdr msgh = { .msg_controllen = 0 };

    printf("%zu", msgh.msg_controllen);

  }

  ]])],

  [

    AC_MSG_RESULT([yes])

    AC_DEFINE([PRI_MSG_CONTROLLEN], [ "zu" ], [Define to zu if msghdr.msg_controllen is size_t, else u])

  ],

  [

    AC_MSG_RESULT([no])

    AC_DEFINE([PRI_MSG_CONTROLLEN], [ "u" ], [Define to zu if msghdr.msg_controllen is size_t, else u])

  ])

CFLAGS=$SAV_CFLAGS

dnl -- Check for diagnostic pragmas in functions - GCC 4.6.0

AC_MSG_CHECKING([diagnostic pragmas in functions])

AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

  int main(int argc, char**argv)

  {

_Pragma("GCC diagnostic warning \"-Wall\"")

  }

  ]])],

  [

    AC_MSG_RESULT([yes])

    AC_DEFINE([_HAVE_FUNCTION_DIAGNOSTIC_PRAGMAS_], [ 1 ], [Define to 1 if can have _Pragma GCC diagnostic in functions])

  ],

  [

    AC_MSG_RESULT([no])

  ])

AM_CONDITIONAL([DEBUG], [test .$enable_debug = .yes])

dnl -- Check for diagnostic push/pop pragmas - GCC 4.6.0

AC_MSG_CHECKING([diagnostic push/pop pragmas])

AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

  int main(int argc, char**argv)

  {

_Pragma("GCC diagnostic push")

  }

  ]])],

  [

    AC_MSG_RESULT([yes])

    AC_DEFINE([_HAVE_DIAGNOSTIC_PUSH_POP_PRAGMAS_], [ 1 ], [Define to 1 if can have _Pragma GCC diagnostic push/pop])

  ],

  [

    AC_MSG_RESULT([no])

  ])

dnl - Set up warnings list

AS_IF([test ".$enable_warnings" = .no],

      [WARNINGS_ENABLED=$WARNINGS_BASIC],

      [WARNINGS_ENABLED="$WARNINGS_BASIC $WARNINGS_STD"

       AS_IF([test ".$enable_warnings" != .yes],

	     [WARN_LIST=`echo $enable_warnings | sed -e "s/-W//g"`

	      add_to_var([WARNINGS_ENABLED], ["$WARN_LIST"])

	     ])

      ]

     )

AS_IF([test .$enable_extra_warnings = .yes],

      [add_to_var([WARNINGS_ENABLED], ["$WARNINGS_EXTRA"])])

if test "$enable_conversion_checks" = yes; then

  # Check if we can sensibly enable -Wconversion

  AC_MSG_CHECKING([for usable -Wconversion])

  SAV_CFLAGS="$CFLAGS"

  CFLAGS="$CFLAGS -Wconversion -O2 -Wp,-D_FORTIFY_SOURCE=2 -Werror"

  AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

    #include <sys/types.h>

    #include <sys/select.h>

    #include <stdint.h>

    #include <stdbool.h>

    #include <sys/socket.h>

    #include <linux/rtnetlink.h>

    #define VAL	255

    static void

    fun(uint8_t val)

    {

    }

    int main(int argc, char**argv)

    {

      fd_set set;

      uint8_t	val = 42;

      unsigned u;

      bool b;

      size_t size = 17;

      char c[2];

      char *c_ptr = c;

      struct rtattr rta;

      struct rtattr *rta_p = &rta;

      FD_SET(argc+1, &set);

      fun(argc == VAL ? VAL : val);

      //      vrrp->lower_prio_no_advert = vrrp->strict_mode ? true : global_data->vrrp_lower_prio_no_advert;

      u = u ? true : b;

      size = RTA_LENGTH(size);

      c_ptr = RTA_DATA(c_ptr);

      rta_p = RTA_NEXT(rta_p, size);

      val = (u < 256 ) ? u & 0xff : 0;

    }

    ]])],

    [

      AC_MSG_RESULT([yes])

      add_to_var([WARNINGS_ENABLED], [conversion])

    ],

    [

      AC_MSG_RESULT([no])

      AC_MSG_WARN([-Wconversion is not sensible with this compiler. Use --enable-force-conversion-checks to override.])

    ])

  CFLAGS="$SAV_CFLAGS"

elif test "$enable_force_conversion_checks" = yes; then

  add_to_var([WARNINGS_ENABLED], [conversion])

fi

if test "$enable_Werror" = yes; then

  add_to_var([WARNINGS_ENABLED], [error])

fi

CONFIG_WARNINGS=lib/config_warnings.h.in

# Save (or restore) lib/config_warnings.h.in

AS_IF([test ! -f ${CONFIG_WARNINGS}.sav],

      [cp -p ${CONFIG_WARNINGS} ${CONFIG_WARNINGS}.sav],

      [cp -p ${CONFIG_WARNINGS}.sav ${CONFIG_WARNINGS}])

SAV_CFLAGS="$CFLAGS"

for WARN in $WARNINGS_ENABLED

do

  AC_MSG_CHECKING([for -W$WARN])

  CFLAGS="$SAV_CFLAGS -W$WARN"

  WARN_VAR=_HAVE_WARNING_`echo $WARN | tr "a-z=-" "A-Z__"`_

  LOCAL_WARN_VAR=HAVE_WARNING_`echo $WARN | sed -e "s/=.*//" | tr "a-z-" "A-Z_"`

  grep -q "^#undef $WARN_VAR$" $CONFIG_WARNINGS

  AS_IF([test $? -ne 0],

	[echo -e "\n/* Define to 1 if -W$WARN in use */\n#undef $WARN_VAR" >>$CONFIG_WARNINGS]

       )

  test `echo $WARN | grep "=[[0-9]][[0-9]]*$"`

  AS_IF([test $? -eq 0],

	[ WARN_SHORT=`echo $WARN | sed -e 's/=[[0-9]][[0-9]]*$//'`

	  WARN_VAR_SHORT=_HAVE_WARNING_`echo $WARN_SHORT | tr "a-z=-" "A-Z__"`_

	  grep -q "^#undef $WARN_VAR_SHORT$" $CONFIG_WARNINGS

	  AS_IF([test $? -ne 0],

		[echo -e "\n/* Define to 1 if -W$WARN_SHORT in use */\n#undef $WARN_VAR_SHORT" >>$CONFIG_WARNINGS]

	       )

	],

	[ unset WARN_VAR_SHORT ]

       )

  AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

    int main(int argc, char**argv)

    {

    }

    ]])],

    [

      # gcc 9 removed -Wchkp and doesn't error if it is specified,

      # but rather outputs:

      #  warning: switch '-Wchkp' is no longer supported

      # so check for the warning.

      touch conftest.err

      grep -q "is no longer supported" conftest.err

      AS_IF([test $? -ne 0],

       [

	AC_MSG_RESULT([yes])

	eval $LOCAL_WARN_VAR=yes

	add_to_var([KA_CFLAGS], [-W$WARN])

	AC_DEFINE_UNQUOTED([$WARN_VAR], [ 1 ])

	AS_IF([test -z "$WARN_VAR_SHORT"], [],

	      [AC_DEFINE_UNQUOTED([$WARN_VAR_SHORT], [ 1 ])]

	     )

       ],

       [

	AC_MSG_RESULT([no])

	eval $LOCAL_WARN_VAR=no

       ])

    ],

    [

      AC_MSG_RESULT([no])

      eval $LOCAL_WARN_VAR=no

    ])

done

AS_IF([test .$HAVE_WARNING_STRICT_OVERFLOW = .yes],

      [

	# The following is not supported in gcc 5.4.0

	CFLAGS="$CFLAGS -Werror"

	AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

	  _Pragma("GCC diagnostic warning \"-Wstrict-overflow=1\"")

	  int main(int argc, char**argv)

	  {

	  }

	  ]])],

	  [AC_DEFINE([_HAVE_PRAGMA_WARN_STRICT_OVERFLOW_1_], [ 1 ], [Define to 1 if _Pragma("GCC diagnostic warning \"-Wstrict-overflow=1\"") supported])

	  ])

      ]

     )

CFLAGS="$SAV_CFLAGS"

dnl ---- [ Do we want stricter configuration checking? ] ----

STRICT_CONFIG=No

if test "$enable_strict_config_checks" = yes; then

  AC_DEFINE([_STRICT_CONFIG_], [ 1 ], [Define to 1 if want stricter configuration checking])

  STRICT_CONFIG=Yes

  add_config_opt([STRICT_CONFIG])

fi

AM_CONDITIONAL([WITH_STRICT_CONFIG_CHECKS], [test $STRICT_CONFIG = Yes])

if test "$enable_hardening" != no; then

  AC_MSG_CHECKING([for PIE support])

  SAV_CFLAGS="$CFLAGS"

  SAV_LDFLAGS="$LDFLAGS"

  CFLAGS="$CFLAGS -fPIE"

  if test "${enable_profile}" = yes; then

    # RHEL 7 and others have a problem with profiling with PIE

    CFLAGS="$CFLAGS -pg"

  fi

  LDFLAGS="$LDFLAGS -pie"

  AC_LINK_IFELSE([AC_LANG_SOURCE([[

    int main(int argc, char **argv)

    {

      int i = 0;

    }

    ]])],

    AC_MSG_RESULT([yes])

      add_to_var([KA_CFLAGS], [-fPIE])

      add_to_var([KA_LDFLAGS], [-pie]),

    AC_MSG_RESULT([no]))

  CFLAGS=$SAV_CFLAGS

  LDFLAGS=$SAV_LDFLAGS

  for FLAG in \

	  "-Wformat -Werror=format-security" \

	  "-Wp,-D_FORTIFY_SOURCE=2" \

	  "-fexceptions" \

	  "-fstack-protector-strong" \

	  "--param=ssp-buffer-size=4" \

	  "-grecord-gcc-switches"

  do

    AC_MSG_CHECKING([for $FLAG support])

    CFLAGS="$CFLAGS $FLAG"

    AC_COMPILE_IFELSE(

      [AC_LANG_SOURCE([[ ]])],

      [AC_MSG_RESULT([yes])]

	add_to_var([KA_CFLAGS], [$FLAG]),

      [AC_MSG_RESULT([no])])

    CFLAGS=$SAV_CFLAGS

  done

  WL_FLAGS=

  for FLAG in \

	  "-z,relro" \

	  "-z,now"

  do

    AC_MSG_CHECKING([for -Wl,$FLAG support])

    LDFLAGS="$LDFLAGS -Wl,$FLAG"

    AC_LINK_IFELSE(

      [AC_LANG_SOURCE([[

      int main(int argc, char **argv)

      {

	int i = 0;

      }

      ]])],

      [

	AC_MSG_RESULT([yes])

	WL_FLAGS="$WL_FLAGS -Wl,$FLAG"

      ],

      [AC_MSG_RESULT([no])]

    )

    CFLAGS=$SAV_CFLAGS

    LDFLAGS=$SAV_LDFLAGS

  done

  if test -n "$WL_FLAGS"; then

    add_to_var([KA_LDFLAGS], [$WL_FLAGS])

  fi

fi

# enable-optimise

AS_IF([test "$enable_optimise" = yes -o "$enable_optimise" = not-specified], [optimise_level=2], [optimise_level=$enable_optimise])

AS_IF([test "$enable_optimise" = no], [optimise_level=0])

AS_IF([test "$optimise_level" -eq 0],

  [

    echo $KA_CFLAGS | $GREP -q -- "-D_FORTIFY_SOURCE=[[^0]]"

    AS_IF([test $? -eq 0], [AC_MSG_WARN([--disable-optimise requires --disable-hardening])])

  ])

FLAG="-O$optimise_level"

AC_MSG_CHECKING([for $FLAG support])

SAV_CFLAGS=$CFLAGS

CFLAGS="$CFLAGS $FLAG"

AC_COMPILE_IFELSE(

  [AC_LANG_SOURCE([[ ]])],

  [AC_MSG_RESULT([yes])]

    add_to_var([KA_CFLAGS], [$FLAG]),

  [

    AC_MSG_RESULT([no])

    AS_IF([test "$enable_optimise" != not-specified], [AC_MSG_ERROR([Invalid optimisation level specified])])

  ])

CFLAGS=$SAV_CFLAGS

AC_SUBST(KA_CPPFLAGS)

AC_SUBST(KA_CFLAGS)

AC_SUBST(KA_LDFLAGS)

AC_SUBST(KA_LIBS)

# AC_SUBST(KA_LIBTOOLFLAGS)

# Check if unaligned memory access is supported (for ARM not supported prior to ARMv6 processors)

AC_MSG_CHECKING([for unaligned memory access])

AC_RUN_IFELSE(

  [

    AC_LANG_PROGRAM(

      [[

	#include <limits.h>

	#include <endian.h>

	#if __BYTE_ORDER == __BIG_ENDIAN

	#if ULONG_MAX == 0xffffffffffffffffUL

	#define CHK_VAL       0x1234567890abcdefUL

	#elif ULONG_MAX == 0xffffffffUL

	#define CHK_VAL       0x12345678UL

	#else

	#define CHK_VAL       0x1234UL

	#endif

	#elif __BYTE_ORDER == __LITTLE_ENDIAN

	#if ULONG_MAX == 0xffffffffffffffffUL

	#define CHK_VAL       0xefcdab9078563412UL

	#elif ULONG_MAX == 0xffffffffUL

	#define CHK_VAL       0x78563412UL

	#else

	#define CHK_VAL       0x3412UL

	#endif

	#else

	#error Neither big nor little endian - unsupported

	#endif

      ]],

      [[

	unsigned long arr[2] = { 0, 0 };

	unsigned char *p = (unsigned char *)arr + 1;

	unsigned i;

	*(unsigned long *)p = CHK_VAL;

	return !!(arr[0] == CHK_VAL || p[0] != 0x12 || p[1] != 0x34 || p[2] != 0x56);

      ]]

    )

  ],

  [AC_MSG_RESULT([yes])],

  [

    AC_MSG_RESULT([no])

    AC_DEFINE([_NO_UNALIGNED_ACCESS_], [ 1 ], [Define to 1 if unaligned memory access not supported])

  ],

  [

    AC_MSG_RESULT([unknown])

    AC_MSG_WARN([Cannot determine if unaligned access supported. Assuming yes.])

  ]

 )

# Checks for libraries.

dnl clock_gettime() required -lt before glibc 2.17

AC_MSG_CHECKING([for clock_gettime() requires -lrt])

AC_LINK_IFELSE([AC_LANG_SOURCE([[

  #include <time.h>

  int main(int argc, char **argv)

  {

    int i;

    struct timespec ts;

    i = clock_gettime(CLOCK_MONOTONIC, &ts);

  }

  ]])],

  [AC_MSG_RESULT([no])],

  [

    SAV_LIBS="$LIBS"

    LIBS="$LIBS -lrt"

    AC_LINK_IFELSE([AC_LANG_SOURCE([[

      #include <time.h>

      int main(int argc, char **argv)

      {

	int i;

	struct timespec ts;

	i = clock_gettime(CLOCK_MONOTONIC, &ts);

      }

      ]])],

      [AC_MSG_RESULT([yes])]

	add_to_var([KA_LIBS], [-lrt]),

      [AC_MSG_ERROR([clock_gettime() not supported])])

    LIBS=$SAV_LIBS

  ])

# Checks for header files.