#!/usr/bin/env python

# this is a base set of waf rules that everything else pulls in first

import os, sys
from waflib import Configure, Logs, Options, Utils, Context, Errors
import wafsamba
from samba_utils import symlink
from optparse import SUPPRESS_HELP

phs = os.environ.get("PYTHONHASHSEED", None)
if phs != "1":
    raise Errors.WafError('''PYTHONHASHSEED=1 missing! Don't use waf directly, use ./configure and make!''')

# this forces configure to be re-run if any of the configure
# sections of the build scripts change. We have to check
# for this in sys.argv as options have not yet been parsed when
# we need to set this. This is off by default until some issues
# are resolved related to WAFCACHE. It will need a lot of testing
# before it is enabled by default.
if '--enable-auto-reconfigure' in sys.argv:
    Configure.autoconfig = 'clobber'

def default_value(option, default=''):
    if option in Options.options.__dict__:
        return Options.options.__dict__[option]
    return default

def options(opt):
    opt.load('compiler_cc')

    opt.load('gnu_dirs')

    gr = opt.option_group('library handling options')

    gr.add_option('--bundled-libraries',
                   help=(f'''comma separated list of bundled libraries.

{Context.g_module.APPNAME} includes copies of externally maintained
system libraries (such as popt, cmokca) as well as Samba-maintained
libraries that can be found on the system already (such as talloc,
tdb).

This option, most useful for packagers, controls if each library
should be forced to be obtained from inside Samba (bundled), forced to
be obtained from the system (bundling disabled, ensuing that
dependency errors are not silently missed) or if that choice should be
automatic (best for end users).

May include !LIBNAME to disable bundling a library.

Can be 'NONE' or 'ALL' [auto]'''),
                   action="store", dest='BUNDLED_LIBS', default='')

    gr.add_option('--private-libraries',
                   help=(f'''comma separated list of normally public libraries to build instead as private libraries.

By default {Context.g_module.APPNAME} will publish a number of public
libraries for use by other software.  For Samba this would include
libwbclient, libsmbclient and others.

This allows that to be disabled, to ensure that other software does
not use these libraries and they are placed in a private filesystem
prefix.

May include !LIBNAME to disable making a library private in order to
limit the effect of 'ALL' '''),
                   action="store", dest='PRIVATE_LIBS', default='')

    extension_default = default_value('PRIVATE_EXTENSION_DEFAULT')
    gr.add_option('--private-library-extension',
                   help=("name extension for private libraries [%s]" % extension_default),
                   action="store", dest='PRIVATE_EXTENSION', default=extension_default)

    extension_exception = default_value('PRIVATE_EXTENSION_EXCEPTION')
    gr.add_option('--private-extension-exception',
                   help=("comma separated list of libraries to not apply extension to [%s]" % extension_exception),
                   action="store", dest='PRIVATE_EXTENSION_EXCEPTION', default=extension_exception)

    builtin_default = default_value('BUILTIN_LIBRARIES_DEFAULT')
    gr.add_option('--builtin-libraries', help=(
f'''comma separated list of libraries to build directly into binaries.

By default {Context.g_module.APPNAME} will build a large number of
shared libraries, to reduce binary size.  This overrides this
behaviour and essentially statically links the specified libraries into
each binary [{builtin_default}]'''),
                  action="store",
                  dest='BUILTIN_LIBRARIES', default=builtin_default)

    gr.add_option('--minimum-library-version',
                   help=(
f'''list of minimum system library versions for otherwise bundled
libraries.

{Context.g_module.APPNAME} by default requires that, in order to match
what is tested in our continuous integration (CI) test-suite, that the
versions of libraries that we include match that found on the system,
before we will select not to 'bundle'.

This option, possibly useful for packagers, allows that specified
version to be overridden (say, if it is absolutely known that a the
newer version included in this tarball has no relevant changes).

Use this with extreme care

(LIBNAME1:version,LIBNAME2:version)'''),
                   action="store", dest='MINIMUM_LIBRARY_VERSION', default='')

    gr.add_option('--disable-rpath',
                   help=("Disable use of rpath for build binaries"),
                   action="store_true", dest='disable_rpath_build', default=False)
    gr.add_option('--disable-rpath-install',
                   help=("Disable use of rpath for library path in installed files"),
                   action="store_true", dest='disable_rpath_install', default=False)
    gr.add_option('--disable-rpath-private-install',
                   help=("Disable use of rpath for private library path in installed files"),
                   action="store_true", dest='disable_rpath_private_install', default=False)
    gr.add_option('--nonshared-binary',
                   help=(
f'''Disable use of shared libaries internal to {Context.g_module.APPNAME} for the listed binaries.

The resulting binaries are 'statically linked' with regard to components provided by
{Context.g_module.APPNAME}, but remain dynamically linked to (eg) libc.so and libgnutls.so

Currently the only tested value is 'smbtorture,smbd/smbd' for Samba'''),
                   action="store", dest='NONSHARED_BINARIES', default='')
    gr.add_option('--disable-symbol-versions',
                   help=("Disable use of the --version-script linker option"),
                   action="store_true", dest='disable_symbol_versions', default=False)

    opt.add_option('--with-modulesdir',
                   help=("modules directory [PREFIX/modules]"),
                   action="store", dest='MODULESDIR', default='${PREFIX}/modules')

    opt.add_option('--with-privatelibdir',
                   help=("private library directory [PREFIX/lib/%s]" % Context.g_module.APPNAME),
                   action="store", dest='PRIVATELIBDIR', default=None)

    opt.add_option('--with-libiconv',
                   help='additional directory to search for libiconv',
                   action='store', dest='iconv_open', default='/usr/local',
                   match = ['Checking for library iconv', 'Checking for iconv_open', 'Checking for header iconv.h'])
    opt.add_option('--without-gettext',
                   help=("Disable use of gettext"),
                   action="store_true", dest='disable_gettext', default=False)

    gr = opt.option_group('developer options')

    gr.add_option('-C',
                   help='enable configure caching',
                   action='store_true', dest='enable_configure_cache')
    gr.add_option('--enable-auto-reconfigure',
                   help='enable automatic reconfigure on build',
                   action='store_true', dest='enable_auto_reconfigure')
    gr.add_option('--enable-debug',
                   help=("Turn on debugging symbols"),
                   action="store_true", dest='debug', default=False)
    gr.add_option('--enable-developer',
                   help=("Turn on developer warnings and debugging"),
                   action="store_true", dest='developer', default=False)
    gr.add_option('--pidl-developer',
                   help=("annotate PIDL-generated code for developers"),
                   action="store_true", dest='pidl_developer', default=False)
    gr.add_option('--disable-warnings-as-errors',
                   help=("Do not treat all warnings as errors (disable -Werror)"),
                   action="store_true", dest='disable_warnings_as_errors', default=False)
    opt.add_option('--enable-coverage',
                   help=("enable options necessary for code coverage "
                         "reporting on selftest (default=no)"),
                   action="store_true", dest='enable_coverage', default=False)
    gr.add_option('--fatal-errors',
                   help=("Stop compilation on first error (enable -Wfatal-errors)"),
                   action="store_true", dest='fatal_errors', default=False)
    gr.add_option('--enable-gccdeps',
                   help=("Enable use of gcc -MD dependency module"),
                   action="store_true", dest='enable_gccdeps', default=True)
    gr.add_option('--pedantic',
		   help=("Enable even more compiler warnings"),
		   action='store_true', dest='pedantic', default=False)
    gr.add_option('--git-local-changes',
		   help=("mark version with + if local git changes"),
		   action='store_true', dest='GIT_LOCAL_CHANGES', default=False)
    gr.add_option('--address-sanitizer',
                   help=("Enable address sanitizer compile and linker flags"),
                   action="store_true", dest='address_sanitizer', default=False)
    gr.add_option('--undefined-sanitizer',
        help=("Enable undefined behaviour sanitizer compile and linker flags"),
        action="store_true",
        dest='undefined_sanitizer',
        default=False)
    gr.add_option('--enable-libfuzzer',
                  help=("Build fuzzing binaries (use ADDITIONAL_CFLAGS to specify compiler options for libFuzzer or use CC=honggfuzz/hfuzz-cc)"),
                  action="store_true", dest='enable_libfuzzer', default=False)
    gr.add_option('--enable-afl-fuzzer',
                  help=("Build fuzzing binaries AFL-style (typically use with CC=afl-gcc)"),
                  action="store_true", dest='enable_afl_fuzzer', default=False)

    # Fuzz targets may need additional LDFLAGS that we can't use on
    # internal binaries like asn1_compile

    gr.add_option('--fuzz-target-ldflags',
                  help=("Linker flags to be used when building fuzz targets"),
                  action="store", dest='FUZZ_TARGET_LDFLAGS', default='')

    gr.add_option('--abi-check',
		   help=("Check ABI signatures for libraries"),
		   action='store_true', dest='ABI_CHECK', default=False)
    gr.add_option('--abi-check-disable',
		   help=("Disable ABI checking (used with --enable-developer)"),
		   action='store_true', dest='ABI_CHECK_DISABLE', default=False)
    gr.add_option('--abi-update',
		   help=("Update ABI signature files for libraries"),
		   action='store_true', dest='ABI_UPDATE', default=False)

    gr.add_option('--show-deps',
		   help=("Show dependency tree for the given target"),
		   dest='SHOWDEPS', default='')

    gr.add_option('--symbol-check',
                  help=("check symbols in object files against project rules"),
                  action='store_true', dest='SYMBOLCHECK', default=False)

    gr.add_option('--dup-symbol-check',
                  help=("check for duplicate symbols in object files and system libs (must be configured with --enable-developer)"),
                  action='store_true', dest='DUP_SYMBOLCHECK', default=False)

    gr.add_option('--why-needed',
                  help=("TARGET:DEPENDENCY check why TARGET needs DEPENDENCY"),
                  action='store', type='str', dest='WHYNEEDED', default=None)

    gr.add_option('--show-duplicates',
                  help=("Show objects which are included in multiple binaries or libraries"),
                  action='store_true', dest='SHOW_DUPLICATES', default=False)

    gr = opt.add_option_group('cross compilation options')

    gr.add_option('--cross-compile',
		   help=("configure for cross-compilation"),
		   action='store_true', dest='CROSS_COMPILE', default=False)
    gr.add_option('--cross-execute',
		   help=("command prefix to use for cross-execution in configure"),
		   action='store', dest='CROSS_EXECUTE', default='')
    gr.add_option('--cross-answers',
		   help=("answers to cross-compilation configuration (auto modified)"),
		   action='store', dest='CROSS_ANSWERS', default='')
    gr.add_option('--hostcc',
		   help=("set host compiler when cross compiling"),
		   action='store', dest='HOSTCC', default=False)

    # we use SUPPRESS_HELP for these, as they are ignored, and are there only
    # to allow existing RPM spec files to work
    opt.add_option('--build',
		   help=SUPPRESS_HELP,
		   action='store', dest='AUTOCONF_BUILD', default='')
    opt.add_option('--host',
		   help=SUPPRESS_HELP,
		   action='store', dest='AUTOCONF_HOST', default='')
    opt.add_option('--target',
		   help=SUPPRESS_HELP,
		   action='store', dest='AUTOCONF_TARGET', default='')
    opt.add_option('--program-prefix',
		   help=SUPPRESS_HELP,
		   action='store', dest='AUTOCONF_PROGRAM_PREFIX', default='')
    opt.add_option('--disable-dependency-tracking',
		   help=SUPPRESS_HELP,
		   action='store_true', dest='AUTOCONF_DISABLE_DEPENDENCY_TRACKING', default=False)
    opt.add_option('--disable-silent-rules',
		   help=SUPPRESS_HELP,
		   action='store_true', dest='AUTOCONF_DISABLE_SILENT_RULES', default=False)

    gr = opt.option_group('dist options')
    gr.add_option('--sign-release',
                   help='sign the release tarball created by waf dist',
                   action='store_true', dest='SIGN_RELEASE')
    gr.add_option('--tag',
                   help='tag release in git at the same time',
                   type='string', action='store', dest='TAG_RELEASE')

    opt.add_option('--disable-python',
                    help='do not generate python modules',
                    action='store_true', dest='disable_python', default=False)


@Utils.run_once
def configure(conf):
    conf.env.hlist = []
    conf.env.srcdir = conf.srcnode.abspath()

    conf.define('SRCDIR', conf.env['srcdir'])

    conf.SETUP_CONFIGURE_CACHE(Options.options.enable_configure_cache)

    # load our local waf extensions
    conf.load('gnu_dirs')
    conf.load('wafsamba')

    conf.CHECK_CC_ENV()

    conf.load('compiler_c')

    conf.CHECK_STANDARD_LIBPATH()

    # we need git for 'waf dist'
    conf.find_program('git', var='GIT')

    # older gcc versions (< 4.4) does not work with gccdeps, so we have to see if the .d file is generated
    if Options.options.enable_gccdeps:
        # stale file removal - the configuration may pick up the old .pyc file
        p = os.path.join(conf.env.srcdir, 'buildtools/wafsamba/gccdeps.pyc')
        if os.path.exists(p):
            os.remove(p)
        conf.load('gccdeps')

    # make the install paths available in environment
    conf.env.LIBDIR = Options.options.LIBDIR or '${PREFIX}/lib'
    conf.env.BINDIR = Options.options.BINDIR or '${PREFIX}/bin'
    conf.env.SBINDIR = Options.options.SBINDIR or '${PREFIX}/sbin'
    conf.env.MODULESDIR = Options.options.MODULESDIR
    conf.env.PRIVATELIBDIR = Options.options.PRIVATELIBDIR
    conf.env.BUNDLED_LIBS = Options.options.BUNDLED_LIBS.split(',')
    conf.env.SYSTEM_LIBS = ()
    conf.env.PRIVATE_LIBS = Options.options.PRIVATE_LIBS.split(',')
    conf.env.BUILTIN_LIBRARIES = Options.options.BUILTIN_LIBRARIES.split(',')
    conf.env.NONSHARED_BINARIES = Options.options.NONSHARED_BINARIES.split(',')

    conf.env.PRIVATE_EXTENSION = Options.options.PRIVATE_EXTENSION
    conf.env.PRIVATE_EXTENSION_EXCEPTION = Options.options.PRIVATE_EXTENSION_EXCEPTION.split(',')
    conf.env.PRIVATE_VERSION = "%s_%s_%s" % (Context.g_module.APPNAME,
        Context.g_module.VERSION, conf.env.PRIVATE_EXTENSION)

    conf.env.CROSS_COMPILE = Options.options.CROSS_COMPILE
    conf.env.CROSS_EXECUTE = Options.options.CROSS_EXECUTE
    conf.env.CROSS_ANSWERS = Options.options.CROSS_ANSWERS
    conf.env.HOSTCC        = Options.options.HOSTCC

    conf.env.AUTOCONF_BUILD = Options.options.AUTOCONF_BUILD
    conf.env.AUTOCONF_HOST  = Options.options.AUTOCONF_HOST
    conf.env.AUTOCONF_PROGRAM_PREFIX = Options.options.AUTOCONF_PROGRAM_PREFIX

    conf.env.disable_python = Options.options.disable_python

    if (conf.env.AUTOCONF_HOST and
        conf.env.AUTOCONF_BUILD and
        conf.env.AUTOCONF_BUILD != conf.env.AUTOCONF_HOST):
        Logs.error('ERROR: Mismatch between --build and --host. Please use --cross-compile instead')
        sys.exit(1)
    if conf.env.AUTOCONF_PROGRAM_PREFIX:
        Logs.error('ERROR: --program-prefix not supported')
        sys.exit(1)

    # enable ABI checking for developers
    conf.env.ABI_CHECK = Options.options.ABI_CHECK or Options.options.developer
    if Options.options.ABI_CHECK_DISABLE:
        conf.env.ABI_CHECK = False
    try:
        conf.find_program('gdb', mandatory=True)
    except:
        conf.env.ABI_CHECK = False

    conf.env.enable_coverage = Options.options.enable_coverage
    if conf.env.enable_coverage:
        conf.ADD_LDFLAGS('-lgcov', testflags=True)
        conf.ADD_CFLAGS('--coverage', testflags=True)
        # disable abi check for coverage, otherwise ld will fail
        conf.env.ABI_CHECK = False

    conf.env.GIT_LOCAL_CHANGES = Options.options.GIT_LOCAL_CHANGES

    conf.CHECK_UNAME()

    # see if we can compile and run a simple C program
    conf.CHECK_CODE('printf("hello world")',
                    define='HAVE_SIMPLE_C_PROG',
                    mandatory=True,
                    execute=False,
                    headers='stdio.h',
                    msg='Checking simple C program')

    # Try to find the right extra flags for -Werror behaviour
    for f in ["-Werror",       # GCC
              "-errwarn=%all", # Sun Studio
              "-qhalt=w",     # IBM xlc
              "-w2",           # Tru64
             ]:
        if conf.CHECK_CFLAGS([f]):
            if not 'WERROR_CFLAGS' in conf.env:
                conf.env['WERROR_CFLAGS'] = []
            conf.env['WERROR_CFLAGS'].extend([f])
            break

    # check which compiler/linker flags are needed for rpath support
    if conf.CHECK_LDFLAGS(['-Wl,-rpath,.']):
        conf.env['RPATH_ST'] = '-Wl,-rpath,%s'
    elif conf.CHECK_LDFLAGS(['-Wl,-R,.']):
        conf.env['RPATH_ST'] = '-Wl,-R,%s'

    # check for rpath
    if conf.CHECK_LIBRARY_SUPPORT(rpath=True):
        support_rpath = True
        conf.env.RPATH_ON_BUILD   = not Options.options.disable_rpath_build
        conf.env.RPATH_ON_INSTALL = (conf.env.RPATH_ON_BUILD and
                                     not Options.options.disable_rpath_install)
        if not conf.env.PRIVATELIBDIR:
            conf.env.PRIVATELIBDIR = '%s/%s' % (conf.env.LIBDIR, Context.g_module.APPNAME)
        conf.env.RPATH_ON_INSTALL_PRIVATE = (
            not Options.options.disable_rpath_private_install)
    else:
        support_rpath = False
        conf.env.RPATH_ON_INSTALL = False
        conf.env.RPATH_ON_BUILD   = False
        conf.env.RPATH_ON_INSTALL_PRIVATE = False
        if not conf.env.PRIVATELIBDIR:
            # rpath is not possible so there is no sense in having a
            # private library directory by default.
            # the user can of course always override it.
            conf.env.PRIVATELIBDIR = conf.env.LIBDIR

    if (not Options.options.disable_symbol_versions and
        conf.CHECK_LIBRARY_SUPPORT(rpath=support_rpath,
                                   version_script=True,
                                   msg='-Wl,--version-script support')):
        conf.env.HAVE_LD_VERSION_SCRIPT = True
    else:
        conf.env.HAVE_LD_VERSION_SCRIPT = False

    if conf.CHECK_CFLAGS(['-fvisibility=hidden']):
        conf.env.VISIBILITY_CFLAGS = '-fvisibility=hidden'
        conf.CHECK_CODE('''int main(void) { return 0; }
                           __attribute__((visibility("default"))) void vis_foo2(void) {}\n''',
                        cflags=conf.env.VISIBILITY_CFLAGS,
                        strict=True,
                        define='HAVE_VISIBILITY_ATTR', addmain=False)

    # check HAVE_CONSTRUCTOR_ATTRIBUTE
    conf.CHECK_CODE('''
            void test_constructor_attribute(void) __attribute__ ((constructor));

            void test_constructor_attribute(void)
            {
                return;
            }

            int main(void) {
                return 0;
            }
            ''',
            'HAVE_CONSTRUCTOR_ATTRIBUTE',
            addmain=False,
            strict=True,
            msg='Checking for library constructor support')

    # check HAVE_PRAGMA_INIT alternatively
    if not conf.env.HAVE_CONSTRUCTOR_ATTRIBUTE:
	    conf.CHECK_CODE('''
                #pragma init (test_init)

                void test_init(void)
                {
                    return;
                }

                int main(void) {
                    return 0;
                }
                ''',
                'HAVE_PRAGMA_INIT',
                addmain=False,
                strict=True,
                msg='Checking for pragma init support')

    # check HAVE_DESTRUCTOR_ATTRIBUTE
    conf.CHECK_CODE('''
            void test_destructor_attribute(void) __attribute__ ((destructor));

            void test_destructor_attribute(void)
            {
                return;
            }

            int main(void) {
                return 0;
            }
            ''',
            'HAVE_DESTRUCTOR_ATTRIBUTE',
            addmain=False,
            strict=True,
            msg='Checking for library destructor support')

    # check HAVE_PRAGMA_FINI alternatively
    if not conf.env.HAVE_DESTRUCTOR_ATTRIBUTE:
	    conf.CHECK_CODE('''
                #pragma fini (test_fini)

                void test_fini(void)
                {
                    return;
                }

                int main(void) {
                    return 0;
                }
                ''',
                'HAVE_PRAGMA_FINI',
                addmain=False,
                strict=True,
                msg='Checking for pragma fini support')

    conf.CHECK_CODE('''
            void test_attribute(void) __attribute__ (());

            void test_attribute(void)
            {
                return;
            }

            int main(void) {
                return 0;
            }
            ''',
            'HAVE___ATTRIBUTE__',
            addmain=False,
            strict=True,
            msg='Checking for __attribute__')

    # Solaris by defauls uses draft versions of some functions unless you set _POSIX_PTHREAD_SEMANTICS
    if sys.platform.startswith('sunos'):
        conf.DEFINE('_POSIX_PTHREAD_SEMANTICS', 1)

    if sys.platform.startswith('aix'):
        conf.DEFINE('_ALL_SOURCE', 1, add_to_cflags=True)
        # Might not be needed if ALL_SOURCE is defined
        # conf.DEFINE('_XOPEN_SOURCE', 600, add_to_cflags=True)

    # we should use the PIC options in waf instead
    # Some compilo didn't support -fPIC but just print a warning
    if conf.env['COMPILER_CC'] == "suncc":
        conf.ADD_CFLAGS('-KPIC', testflags=True)
        # we really want define here as we need to have this
        # define even during the tests otherwise detection of
        # boolean is broken
        conf.DEFINE('_STDC_C99', 1, add_to_cflags=True)
        conf.DEFINE('_XPG6', 1, add_to_cflags=True)
    else:
        conf.ADD_CFLAGS('-fPIC', testflags=True)

    # On Solaris 8 with suncc (at least) the flags for the linker to define the name of the
    # library are not always working (if the command line is very very long and with a lot
    # files)

    if conf.env['COMPILER_CC'] == "suncc":
        save = conf.env['SONAME_ST']
        conf.env['SONAME_ST'] = '-Wl,-h,%s'
        if not conf.CHECK_SHLIB_INTRASINC_NAME_FLAGS("Checking if flags %s are ok" % conf.env['SONAME_ST']):
            conf.env['SONAME_ST'] = save

    conf.CHECK_INLINE()

    # check for pkgconfig
    conf.CHECK_CFG(atleast_pkgconfig_version='0.0.0')

    conf.DEFINE('_GNU_SOURCE', 1, add_to_cflags=True)
    conf.DEFINE('_XOPEN_SOURCE_EXTENDED', 1, add_to_cflags=True)

    #
    # Needs to be defined before std*.h and string*.h are included
    # As Python.h already brings string.h we need it in CFLAGS.
    # See memset_s() details here:
    # https://en.cppreference.com/w/c/string/byte/memset
    #
    if conf.CHECK_CFLAGS(['-D__STDC_WANT_LIB_EXT1__=1']):
        conf.ADD_CFLAGS('-D__STDC_WANT_LIB_EXT1__=1')

    # on Tru64 certain features are only available with _OSF_SOURCE set to 1
    # and _XOPEN_SOURCE set to 600
    if conf.env['SYSTEM_UNAME_SYSNAME'] == 'OSF1':
        conf.DEFINE('_OSF_SOURCE', 1, add_to_cflags=True)
        conf.DEFINE('_XOPEN_SOURCE', 600, add_to_cflags=True)

    # SCM_RIGHTS is only avail if _XOPEN_SOURCE iѕ defined on IRIX
    if conf.env['SYSTEM_UNAME_SYSNAME'] == 'IRIX':
        conf.DEFINE('_XOPEN_SOURCE', 600, add_to_cflags=True)
        conf.DEFINE('_BSD_TYPES', 1, add_to_cflags=True)

    # Try to find the right extra flags for C99 initialisers
    for f in ["", "-AC99", "-qlanglvl=extc99", "-qlanglvl=stdc99", "-c99"]:
        if conf.CHECK_CFLAGS([f], '''
struct foo {int x;char y;};
struct foo bar = { .y = 'X', .x = 1 };
'''):
            if f != "":
                conf.ADD_CFLAGS(f)
            break

    # get the base headers we'll use for the rest of the tests
    conf.CHECK_HEADERS('stdio.h sys/types.h sys/stat.h stdlib.h stddef.h memory.h string.h',
                       add_headers=True)
    conf.CHECK_HEADERS('strings.h inttypes.h stdint.h unistd.h minix/config.h', add_headers=True)
    conf.CHECK_HEADERS('ctype.h', add_headers=True)

    if sys.platform == 'darwin':
        conf.DEFINE('_DARWIN_C_SOURCE', 1, add_to_cflags=True)
        conf.DEFINE('_DARWIN_UNLIMITED_GETGROUPS', 1, add_to_cflags=True)
    else:
        conf.CHECK_HEADERS('standards.h', add_headers=True)

    conf.CHECK_HEADERS('stdbool.h stdint.h stdarg.h vararg.h', add_headers=True)
    conf.CHECK_HEADERS('limits.h assert.h')

    # see if we need special largefile flags
    if not conf.CHECK_LARGEFILE():
        raise Errors.WafError('Samba requires large file support support, but not available on this platform: sizeof(off_t) < 8')

    if conf.env.HAVE_STDDEF_H and conf.env.HAVE_STDLIB_H:
        conf.DEFINE('STDC_HEADERS', 1)

    conf.CHECK_HEADERS('sys/time.h time.h', together=True)

    if conf.env.HAVE_SYS_TIME_H and conf.env.HAVE_TIME_H:
        conf.DEFINE('TIME_WITH_SYS_TIME', 1)

    # cope with different extensions for libraries
    (root, ext) = os.path.splitext(conf.env.cshlib_PATTERN)
    if ext[0] == '.':
        conf.define('SHLIBEXT', ext[1:], quote=True)
    else:
        conf.define('SHLIBEXT', "so", quote=True)

    # First try a header check for cross-compile friendlyness
    conf.CHECK_CODE(code = """#ifdef __BYTE_ORDER
                        #define B __BYTE_ORDER
                        #elif defined(BYTE_ORDER)
                        #define B BYTE_ORDER
                        #endif

                        #ifdef __LITTLE_ENDIAN
                        #define LITTLE __LITTLE_ENDIAN
                        #elif defined(LITTLE_ENDIAN)
                        #define LITTLE LITTLE_ENDIAN
                        #endif

                        #if !defined(LITTLE) || !defined(B) || LITTLE != B
                        #error Not little endian.
                        #endif
                        int main(void) { return 0; }\n""",
                            addmain=False,
                            headers="endian.h sys/endian.h",
                            define="HAVE_LITTLE_ENDIAN")
    conf.CHECK_CODE(code = """#ifdef __BYTE_ORDER
                        #define B __BYTE_ORDER
                        #elif defined(BYTE_ORDER)
                        #define B BYTE_ORDER
                        #endif

                        #ifdef __BIG_ENDIAN
                        #define BIG __BIG_ENDIAN
                        #elif defined(BIG_ENDIAN)
                        #define BIG BIG_ENDIAN
                        #endif

                        #if !defined(BIG) || !defined(B) || BIG != B
                        #error Not big endian.
                        #endif
                        int main(void) { return 0; }\n""",
                            addmain=False,
                            headers="endian.h sys/endian.h",
                            define="HAVE_BIG_ENDIAN")

    if not conf.CONFIG_SET("HAVE_BIG_ENDIAN") and not conf.CONFIG_SET("HAVE_LITTLE_ENDIAN"):
        # That didn't work!  Do runtime test.
        conf.CHECK_CODE("""union { int i; char c[sizeof(int)]; } u;
            u.i = 0x01020304;
            return u.c[0] == 0x04 && u.c[1] == 0x03 && u.c[2] == 0x02 && u.c[3] == 0x01 ? 0 : 1;""",
                          addmain=True, execute=True,
                          define='HAVE_LITTLE_ENDIAN',
                          msg="Checking for HAVE_LITTLE_ENDIAN - runtime")
        conf.CHECK_CODE("""union { int i; char c[sizeof(int)]; } u;
            u.i = 0x01020304;
            return u.c[0] == 0x01 && u.c[1] == 0x02 && u.c[2] == 0x03 && u.c[3] == 0x04 ? 0 : 1;""",
                          addmain=True, execute=True,
                          define='HAVE_BIG_ENDIAN',
                          msg="Checking for HAVE_BIG_ENDIAN - runtime")

    # Extra sanity check.
    if conf.CONFIG_SET("HAVE_BIG_ENDIAN") == conf.CONFIG_SET("HAVE_LITTLE_ENDIAN"):
        Logs.error("Failed endian determination.  The PDP-11 is back?")
        sys.exit(1)
    else:
        if conf.CONFIG_SET("HAVE_BIG_ENDIAN"):
            conf.DEFINE('WORDS_BIGENDIAN', 1)

    # check if signal() takes a void function
    if conf.CHECK_CODE('return *(signal (0, 0)) (0) == 1',
                       define='RETSIGTYPE_INT',
                       execute=False,
                       headers='signal.h',
                       msg='Checking if signal handlers return int'):
        conf.DEFINE('RETSIGTYPE', 'int')
    else:
        conf.DEFINE('RETSIGTYPE', 'void')

    conf.CHECK_VARIABLE('__FUNCTION__', define='HAVE_FUNCTION_MACRO')

    conf.CHECK_CODE('va_list ap1,ap2; va_copy(ap1,ap2)',
                    define="HAVE_VA_COPY",
                    msg="Checking for va_copy")

    conf.CHECK_CODE('''
                    #define eprintf(...) fprintf(stderr, __VA_ARGS__)
                    eprintf("bla", "bar")
                    ''', define='HAVE__VA_ARGS__MACRO')

    conf.env.enable_fuzzing = False

    conf.env.enable_libfuzzer = Options.options.enable_libfuzzer
    conf.env.enable_afl_fuzzer = Options.options.enable_afl_fuzzer
    if conf.env.enable_libfuzzer or conf.env.enable_afl_fuzzer:
        conf.env.enable_fuzzing = True
        conf.DEFINE('FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION', 1)
        conf.env.FUZZ_TARGET_LDFLAGS = Options.options.FUZZ_TARGET_LDFLAGS

    # Create a symlink of the compile db for clangd
    symlink(os.path.join(conf.bldnode.abspath(), 'default/compile_commands.json'),
            os.path.join(conf.srcnode.abspath(), 'compile_commands.json'),
            force=True)

    conf.SAMBA_BUILD_ENV()


def build(bld):
    # give a more useful message if the source directory has moved
    curdir = bld.path.abspath()
    srcdir = bld.srcnode.abspath()
    relpath = os.path.relpath(curdir, srcdir)
    if relpath.find('../') != -1:
        Logs.error('bld.path %s is not a child of %s' % (curdir, srcdir))
        raise Errors.WafError('''The top source directory has moved. Please run distclean and reconfigure''')

    bld.SETUP_BUILD_GROUPS()
    bld.ENFORCE_GROUP_ORDERING()
    bld.CHECK_PROJECT_RULES()