meson.build

project(
    'netatalk',
    version: '4.6.0dev',
    license: 'GPLv2',
    default_options: ['warning_level=3', 'c_std=c11', 'b_ndebug=if-release'],
    meson_version: '>=0.62.0',
)

####################
# Global variables #
####################

cdata = configuration_data()
fs = import('fs')
netatalk_version = meson.project_version()
cpu = host_machine.cpu_family()
host_os = host_machine.system()
target_os = target_machine.system()
build_type = get_option('buildtype')

linux_distro = ''

if host_os == 'linux' and fs.exists('/etc/os-release')
    os_release = fs.read('/etc/os-release').strip()
    if os_release.contains('alpine')
        linux_distro = 'alpine'
    elif os_release.contains('arch')
        linux_distro = 'arch'
    elif os_release.contains('centos')
        linux_distro = 'centos'
    elif os_release.contains('gentoo')
        linux_distro = 'gentoo'
    elif os_release.contains('suse')
        linux_distro = 'suse'
    elif os_release.contains('fedora')
        linux_distro = 'fedora'
    elif os_release.contains('rhel')
        linux_distro = 'rhel'
    elif os_release.contains('ubuntu')
        linux_distro = 'ubuntu'
    elif os_release.contains('debian')
        linux_distro = 'debian'
    endif
    message('Linux distro detected: ' + linux_distro)
endif

uname = find_program('uname', required: false)
uname_stdout = run_command(uname, '-a', check: false).stdout().strip()

#########
# Paths #
#########

prefix = get_option('prefix')
exec_prefix = get_option('prefix')
bindir = prefix / get_option('bindir')
datadir = prefix / get_option('datadir')
includedir = prefix / get_option('includedir')
libdir = prefix / get_option('libdir')
libexecdir = prefix / get_option('libexecdir')
mandir = prefix / get_option('mandir')
sbindir = prefix / get_option('sbindir')
sysconfdir = prefix / get_option('sysconfdir')

pkgconfdir = get_option('with-pkgconfdir-path')
if pkgconfdir == ''
    pkgconfdir = sysconfdir
endif

# TODO: This breaks FHS. Should be /var/lib or the platform-specific equivalent.
# Meson's built-in option is called sharedstatedir.
# Will keep the non-standard location for now to avoid breaking existing setups.
# Ref: https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch05s08.html
localstatedir = prefix / get_option('localstatedir')

statedir_override = get_option('with-statedir-path')
if statedir_override != ''
    localstatedir = statedir_override
endif

if host_os == 'darwin'
    homedir = '/Users'
elif host_os == 'sunos'
    homedir = '/export/home'
else
    homedir = '/home'
endif

docs_install_path = datadir / 'doc' / meson.project_name()

if get_option('with-docs-install-path') != ''
    docs_install_path = get_option('with-docs-install-path')
endif

with_docs_only = get_option('with-docs-only')
docs_options = get_option('with-docs')

if with_docs_only and docs_options == []
    error('with-docs-only requires at least one documentation type in with-docs')
endif

#
# Check for Perl
#

perl_path = get_option('with-perl-path')

if perl_path == ''
    perl = find_program('perl', required: false)
else
    perl = find_program(perl_path / 'perl', required: false)
endif

#########################
# Prepare documentation #
#########################

cmark = find_program('cmark', required: false)
cmarkgfm = find_program('cmark-gfm', required: false)
pandoc = find_program('pandoc', required: false)
doxygen = find_program('doxygen', required: false)

build_man_docs = false
build_html_docs = false
build_readme_docs = false
build_dev_docs = false

if 'readmes' in docs_options
    build_readme_docs = true

    readmes_md = [
        'CODE_OF_CONDUCT',
        'CONTAINERS',
        'CONTRIBUTING',
        'CONTRIBUTORS',
        'INSTALL',
        'NEWS',
        'README',
        'SECURITY',
    ]

    if get_option('with-website') and perl.found()
        make_compile_doc = find_program('contrib/scripts/make_compile_docs.pl', required: true)
        run_command(
            make_compile_doc,
            '.github/workflows/build.yml',
            '.github/workflows/spectest-macos.yml',
            '.github/workflows/spectest-vms.yml',
            'COMPILATION.md',
            check: true,
        )
        readmes_md += ['COMPILATION']
    endif

    foreach file : readmes_md
        if get_option('with-website')
            install_data(file + '.md', install_dir: docs_install_path / 'manual')
        else
            if pandoc.found()
                custom_target(
                    'readmes_' + file,
                    input: file + '.md',
                    output: file + '.txt',
                    command: [
                        pandoc,
                        '--from', 'gfm+pipe_tables',
                        '--to', 'plain',
                        '@INPUT@',
                    ],
                    capture: true,
                    install: true,
                    install_dir: datadir / 'doc/netatalk',
                    install_tag: 'doc',
                )
            elif cmarkgfm.found()
                custom_target(
                    'readmes_' + file,
                    input: file + '.md',
                    output: file + '.txt',
                    command: [
                        cmarkgfm,
                        '--extension', 'table',
                        '--width', '80',
                        '--to', 'plaintext',
                        '@INPUT@',
                    ],
                    capture: true,
                    install: true,
                    install_dir: datadir / 'doc/netatalk',
                    install_tag: 'doc',
                )
            else
                install_data(
                    file + '.md',
                    install_dir: datadir / 'doc/netatalk',
                    install_tag: 'doc',
                )
            endif
        endif
    endforeach
endif

if 'man' in docs_options
    if cmark.found() or cmarkgfm.found() or pandoc.found()
        build_man_docs = true
    else
        warning('cmark, cmark-gfm, or pandoc is required to build man pages')
    endif
endif

if 'html_manual' in docs_options
    if cmark.found() or cmarkgfm.found() or pandoc.found()
        build_html_docs = true
    else
        warning('cmark, cmark-gfm or pandoc is required to build the html manual')
    endif
endif

if 'developer' in docs_options
    if doxygen.found()
        build_dev_docs = true
    else
        warning('doxygen is required to build developer documentation')
    endif
endif

if with_docs_only
    use_dbd_backend = 'dbd' in get_option('with-cnid-backends')
    have_appletalk = get_option('with-appletalk')

    if docs_options != []
        subdir('doc')
    endif

    summary(
        {'Netatalk version': netatalk_version},
        section: 'Configuration Summary:',
    )
    summary(
        {'Documentation-only build': true},
        bool_yn: true,
        section: '  Options:',
    )
    summary(
        {
            '  developer': build_dev_docs,
            '  html manual': build_html_docs,
            '  man pages': build_man_docs,
            '  readmes': build_readme_docs,
        },
        bool_yn: true,
        section: '  Documentation:',
    )
    subdir_done()
endif

add_languages('c', native: false)
cc = meson.get_compiler('c')

if not cc.compiles('int func() { return 0; }')
    error('The C compiler cannot compile code. Please check the logs.')
endif

##################
# Compiler flags #
##################

# Global

netatalk_common_flags = [
    '-DHAVE_CONFIG_H',
    '-Wno-pedantic',
    '-Wno-extra',
    '-Wno-all',
    '-Wno-deprecated-declarations',
]

netatalk_c_flags = cc.get_supported_arguments('-Werror=implicit-function-declaration')

if host_os == 'linux'
    netatalk_common_flags += '-D_GNU_SOURCE'
elif host_os == 'sunos'
    netatalk_common_flags += [
        '-D__EXTENSIONS__',
        '-D_ISOC9X_SOURCE',
        '-D_XOPEN_SOURCE=600',
    ]
endif

if build_type == 'debug'
    netatalk_common_flags += '-DDEBUG'
endif

add_global_arguments(netatalk_common_flags, language: 'c')
add_global_arguments(netatalk_c_flags, language: 'c')

netatalk_common_link_args = []

if 'xapian' in get_option('with-spotlight-backends')
    cpp_found = add_languages('cpp', native: false, required: false)
    if cpp_found
        add_global_arguments(netatalk_common_flags, language: 'cpp')
    endif
else
    cpp_found = false
endif

# Per target

afpd = '-D_PATH_AFPD="' + sbindir + '/afpd"'
afpdpwfile = '-D_PATH_AFPDPWFILE="' + pkgconfdir + '/afppasswd"'
afpdsrppwfile = '-D_PATH_AFPDSRPPWFILE="' + pkgconfdir + '/afppasswd.srp"'
cnid_dbd = '-D_PATH_CNID_DBD="' + sbindir + '/cnid_dbd"'
cnid_metad = '-D_PATH_CNID_METAD="' + sbindir + '/cnid_metad"'
confdir = '-D_PATH_CONFDIR="' + pkgconfdir + '/"'
dversion = '-DVERSION="' + netatalk_version + '"'
messagedir = '-DSERVERTEXT="' + localstatedir + '/netatalk/msg/"'
naddir = '-D_PATH_NAD="' + bindir + '/nad"'
statedir = '-D_PATH_STATEDIR="' + localstatedir + '/netatalk/"'
uamdir = '-D_PATH_AFPDUAMPATH="' + libdir + '/netatalk/"'

############
# Includes #
############

include_dirs = [
    '.',
    'include',
    'sys',
    'etc/afpd',
]

if host_os in ['dragonfly', 'freebsd', 'openbsd']
    include_dirs += ['/usr/local/include']
elif host_os == 'netbsd'
    include_dirs += ['/usr/pkg/include']
elif uname.found() and uname_stdout.to_lower().contains('omnios')
    include_dirs += ['/opt/local/include']
endif

# note: the brew app is not visible from within the brew build wrapper iteslf,
# so rather than checking for brew we apply a blanket prefix
brew_prefix = ''
if get_option('with-homebrew') == true
    if host_os == 'darwin'
        if cpu == 'aarch64' and fs.is_dir('/opt/homebrew')
            brew_prefix = '/opt/homebrew'
            if fs.is_dir(brew_prefix + '/include')
                include_dirs += brew_prefix + '/include'
            endif
        elif cpu == 'x86_64'
            brew_prefix = '/usr/local'
        endif
    elif host_os == 'linux' and fs.is_dir('/opt/linuxbrew/.linuxbrew')
        brew_prefix = '/home/linuxbrew/.linuxbrew'
        if fs.is_dir(brew_prefix + '/include')
            include_dirs += brew_prefix + '/include'
        endif
    endif
endif

#############
# Libraries #
#############

libsearch_dirs = []

if host_os in ['dragonfly', 'freebsd', 'openbsd']
    libsearch_dirs += '/usr/local/lib'
elif host_os == 'netbsd'
    libsearch_dirs += '/usr/pkg/lib'
elif uname.found() and uname_stdout.to_lower().contains('omnios')
    libsearch_dirs += '/opt/local/lib'
endif

if brew_prefix != ''
    libsearch_dirs += brew_prefix + '/lib'
endif

socket = cc.find_library('socket', required: false)
if socket.found()
    netatalk_common_link_args += '-lsocket'
endif

sendfile = cc.find_library('sendfile', required: false)
if sendfile.found()
    netatalk_common_link_args += '-lsendfile'
endif

nsl = cc.find_library('nsl', required: false)
if nsl.found()
    netatalk_common_link_args += '-lnsl'
endif

dl = cc.find_library('dl', required: false)
if dl.found()
    netatalk_common_link_args += '-ldl'
endif

math = cc.find_library('m', required: true)
if math.found()
    netatalk_common_link_args += '-lm'
endif

# Check if GCC atomic builtins need explicit libatomic linkage.
# On some platforms (e.g. 32-bit ARM, MIPS) 64-bit atomics are not inlined
# by the compiler and require an explicit -latomic link flag.
atomic_test_code = '''
#include <stdint.h>
int main(void) {
    uint64_t x = 0;
    __atomic_fetch_add(&x, 1, __ATOMIC_SEQ_CST);
    __atomic_load_n(&x, __ATOMIC_SEQ_CST);
    uint64_t y = __atomic_exchange_n(&x, 1, __ATOMIC_SEQ_CST);
    (void)y;
    return 0;
}
'''
if not cc.links(atomic_test_code, name: 'atomic builtins without -latomic')
    # Find the library: system paths, platform paths
    atomic = cc.find_library('atomic', required: false)
    foreach d : libsearch_dirs
        if not atomic.found()
            atomic = cc.find_library('atomic', dirs: d, required: false)
            if atomic.found()
                netatalk_common_link_args += ['-L' + d]
            endif
        endif
    endforeach
    if atomic.found()
        netatalk_common_link_args += '-latomic'
    endif
    have_atomic = atomic.found()
    if not have_atomic
        error('libatomic is required! Please install it.')
    endif
endif

add_global_link_arguments(netatalk_common_link_args, language: 'c')
if cpp_found
    add_global_link_arguments(netatalk_common_link_args, language: 'cpp')
endif

if host_machine.endian() == 'big'
    cdata.set('WORDS_BIGENDIAN', 1)
endif

#################
# Header checks #
#################

header_dir = []
if host_os in ['dragonfly', 'freebsd', 'openbsd']
    header_dir += '/usr/local/include'
endif

check_headers = [
    'acl/libacl.h',
    'attr/xattr.h',
    'crypt.h',
    'dlfcn.h',
    'iniparser/iniparser.h',
    'langinfo.h',
    'linux/dqblk/xfs.h',
    'linux/xqm.h',
    'locale.h',
    'mntent.h',
    'pam/pam_appl.h',
    'security/pam_appl.h',
    'sgtty.h',
    'sys/attr.h',
    'sys/ea.h',
    'sys/extattr.h',
    'sys/mnttab.h',
    'sys/mount.h',
    'sys/sysinfo.h',
    'sys/vfs.h',
    'sys/xattr.h',
    'ufs/quota.h',
    'xfs/xqm.h',
]

foreach h : check_headers
    if cc.has_header(h, include_directories: include_directories(header_dir))
        cdata.set('HAVE_' + h.underscorify().to_upper(), 1)
    endif
endforeach

###################
# Function checks #
###################

check_functions = [
    'asprintf',
    'backtrace_symbols',
    'dirfd',
    'explicit_bzero',
    'getpwnam_shadow',
    'memset_explicit',
    'pread',
    'pselect',
    'pwrite',
    'rresvport',
    'splice',
    'strlcat',
    'strlcpy',
    'strnlen',
    'vasprintf',
]

foreach f : check_functions
    if cc.has_function(f)
        cdata.set('HAVE_' + f.underscorify().to_upper(), 1)
    endif
endforeach

if cc.has_function('mempcpy', prefix: '#include <string.h>')
    cdata.set('HAVE_MEMPCPY', 1)
endif

if cc.has_function('getifaddrs', dependencies: socket)
    cdata.set('HAVE_GETIFADDRS', 1)
endif

at_functions = [
    'openat',
    'renameat',
    'fstatat',
    'unlinkat',
]

foreach f : at_functions
    if not cc.has_function(f)
        error('Standard C library function @0@ is required'.format(f))
    endif
endforeach

##########################
# Type and member checks #
##########################

if cc.has_type('fshare_t', prefix: '#include <fcntl.h>')
    cdata.set('HAVE_FSHARE_T', 1)
endif
if cc.has_member('struct stat', 'st_birthtimespec', prefix: '#include <sys/stat.h>')
    cdata.set('HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC', 1)
endif
if cc.has_member('struct stat', 'st_mtim', prefix: '#include <sys/stat.h>')
    cdata.set('HAVE_STRUCT_STAT_ST_MTIM', 1)
endif
if cc.has_member('struct stat', 'st_atim', prefix: '#include <sys/stat.h>')
    cdata.set('HAVE_STRUCT_STAT_ST_ATIM', 1)
endif
if cc.has_member('struct stat', 'st_mtimespec', prefix: '#include <sys/stat.h>')
    cdata.set('HAVE_STRUCT_STAT_ST_MTIMESPEC', 1)
endif
if cc.has_member('struct stat', 'st_atimespec', prefix: '#include <sys/stat.h>')
    cdata.set('HAVE_STRUCT_STAT_ST_ATIMESPEC', 1)
endif

#################
# Configuration #
#################

#
# Check for 64-bit libraries
#

compiler_64_bit_mode = false
file = find_program('file', required: false)
if file.found()
    run_command(
        cc,
        '-c', meson.project_source_root() / 'libatalk/dummy.c',
        '-o', meson.global_build_root() / 'dummy.o',
        check: false,
    )

    compiler_64_bit_mode = run_command(
        file,
        meson.global_build_root() / 'dummy.o',
        check: true,
    ).stdout().strip().contains('ELF 64')
endif

#
# Check whether to enable rpath (the default on Solaris and NetBSD)
#

rpath_libdir = ''

if host_os == 'sunos' or host_os == 'netbsd' or get_option('with-rpath')
    rpath_libdir = libdir
endif

#
# Check which CNID backends to compile
#

cnid_backends = ''

#
# Check for the Berkeley DB library for the Database Daemon CNID backend
#

use_dbd_backend = false
have_bdb = false
grep = find_program('grep', required: false)

if 'dbd' in get_option('with-cnid-backends')
    bdb_path = get_option('with-bdb-path')
    bdb_include_path_override = get_option('with-bdb-include-path')
    bdb_req_version = get_option('with-bdb-version')

    bdb_header = ''
    bdb_includes = []
    bdb_libdir = ''
    bdb_major_version = ''
    bdb_minor_version = ''
    bdb_version = ''
    bdb_dirs = []

    if bdb_path != ''
        bdb_dirs += [bdb_path]
    else
        if brew_prefix != ''
            bdb_dirs += [
                brew_prefix / 'opt/berkeley-db@5',
                brew_prefix / 'opt/berkeley-db@4',
                brew_prefix / 'opt/berkeley-db',
            ]
        endif

        bdb_dirs += [
            '/usr/local',
            '/usr/pkg',
            '/opt/local',
            '/usr',
        ]
    endif

    bdb_subdirs = [
        'db62',
        'db6.2',
        'db61',
        'db6.1',
        'db5',
        'db53',
        'db5.3',
        'db52',
        'db5.2',
        'db51',
        'db5.1',
        'db50',
        'db5.0',
        'db4',
        'db48',
        'db4.8',
        'db47',
        'db4.7',
        'db46',
        'db4.6',
        '',
    ]

    if bdb_req_version != ''
        if not bdb_req_version.version_compare('>=4.6')
            error('Berkeley DB library version is below supported 4.6')
        endif
        message('Searching for Berkeley DB library version', bdb_req_version)
    endif

    foreach dir : bdb_dirs
        foreach subdir : bdb_subdirs
            if bdb_include_path_override != ''
                bdb_include_path = bdb_include_path_override
            else
                bdb_include_path = dir / 'include' / subdir
            endif
            bdb_header = bdb_include_path / 'db.h'
            if fs.exists(bdb_header)
                bdb_includes = include_directories(bdb_include_path)

                grep_result = run_command(
                    'grep',
                    'DB_VERSION_MAJOR',
                    bdb_header,
                    check: false,
                )
                if grep_result.returncode() != 0
                    warning(
                        'Unable to determine Berkeley DB major version from header',
                        bdb_header,
                    )
                    continue
                endif
                bdb_major_version = grep_result.stdout().strip().substring(25)

                grep_result = run_command(
                    'grep',
                    'DB_VERSION_MINOR',
                    bdb_header,
                    check: false,
                )
                if grep_result.returncode() != 0
                    warning(
                        'Unable to determine Berkeley DB minor version from header',
                        bdb_header,
                    )
                    continue
                endif
                bdb_minor_version = grep_result.stdout().strip().substring(25)

                bdb_version = bdb_major_version + '.' + bdb_minor_version

                if not bdb_version.version_compare('>=4.6')
                    continue
                endif

                if bdb_req_version != '' and not bdb_version.version_compare('~' + bdb_req_version)
                    continue
                endif

                message('Berkeley DB header found at', bdb_header)

                # Now find lib file matching header
                if target_os == 'sunos' and compiler_64_bit_mode and fs.exists(dir / 'lib/64')
                    bdb_libdir = dir / 'lib/64'
                else
                    bdb_libdir = dir / 'lib'
                endif

                # Guess lib name starting from more specific ones
                bdb_libnames = [
                    'db-' + bdb_major_version + '.' + bdb_minor_version,
                    'db' + bdb_major_version + '.' + bdb_minor_version,
                    'db' + bdb_major_version + bdb_minor_version,
                    'db-' + bdb_major_version,
                    'db' + bdb_major_version,
                    'db',
                ]

                foreach name : bdb_libnames
                    libdb = cc.find_library(name, dirs: bdb_libdir, required: false)
                    if not libdb.found()
                        libdb = cc.find_library(name, dirs: bdb_libdir / subdir, required: false)
                    endif

                    if libdb.found()
                        have_bdb = true
                        break
                    endif
                endforeach

                if have_bdb
                    break
                endif
            endif
        endforeach

        if have_bdb
            break
        endif
    endforeach

    if have_bdb
        use_dbd_backend = true
        cnid_backends += 'dbd'
        cdata.set('CNID_BACKEND_DBD', 1)
    else
        if bdb_req_version != ''
            msg = 'Berkeley DB library version ' + bdb_req_version + ' requested via -Dwith-bdb-version= not found!'
        else
            msg = 'Berkeley DB library not found, bdb CNID backend will not be built!'
        endif
        message(
            msg,
            'If you want dbd CNID backend support, define the Berkeley DB path using the -Dwith-bdb-path= configure option (must include lib and include dirs)',
        )
    endif
endif

# Check for mysql CNID backend

mysqlclient = dependency('mysqlclient', required: false)
mariadb = dependency('libmariadb', required: false)

use_mysql_backend = false

if 'mysql' in get_option('with-cnid-backends')
    if mysqlclient.found()
        mysql_deps = mysqlclient
    else
        mysql_deps = mariadb
    endif
    if mysql_deps.found()
        use_mysql_backend = (
            fs.exists(
                mysql_deps.get_variable(pkgconfig: 'includedir') / 'mysql.h',
            )
        )
    endif
    if use_mysql_backend
        if cnid_backends != ''
            cnid_backends += ' | '
        endif
        cnid_backends += 'mysql'
        cdata.set('CNID_BACKEND_MYSQL', 1)
        # Check for mysql_get_socket() function (added in MySQL 5.7.9 / MariaDB 10.0)
        if cc.has_function('mysql_get_socket', dependencies: mysql_deps)
            cdata.set('HAVE_MYSQL_GET_SOCKET', 1)
        endif
    endif
endif

# Check for sqlite CNID backend

sqlite_deps = dependency('sqlite3', required: false)

use_sqlite_backend = false

if 'sqlite' in get_option('with-cnid-backends') and sqlite_deps.found()
    use_sqlite_backend = true
    if cnid_backends != ''
        cnid_backends += ' | '
    endif
    cnid_backends += 'sqlite'
    cdata.set('CNID_BACKEND_SQLITE', 1)
endif

compiled_backends = '"' + cnid_backends + '"'
cdata.set('compiled_backends', compiled_backends)

summary_backends = cnid_backends

# Determine default CNID backend

if use_sqlite_backend
    default_backend = 'sqlite'
elif use_mysql_backend
    default_backend = 'mysql'
elif use_dbd_backend
    default_backend = 'dbd'
else
    error('No CNID backends selected for compilation')
endif

cdata.set('DEFAULT_CNID_SCHEME', '"' + default_backend + '"')

#
# Check for Better String Library
#

bgets_test_code = '''
#include <stdio.h>
#include <libgen.h>
int main() {
    char buffer[256];
    char delim = '\n';
    FILE *fp = stdin;
    char *result = bgets(buffer, sizeof(buffer), fp, &delim);
    return 0;
}
'''

has_bgets = cc.compiles(bgets_test_code, name: 'bgets defined in standard C library')
cdata.set('HAVE_BGETS', has_bgets)
bstring = dependency('bstring', required: false)

if not bstring.found() or get_option('with-subprojects')
    bstring_proj = subproject('bstring')
    bstring = bstring_proj.get_variable('bstring_dep')
endif

#
# Check for iniparser
#

iniparser_path = get_option('with-iniparser-path')

if iniparser_path != ''
    iniparser = cc.find_library(
        'iniparser',
        dirs: iniparser_path / 'lib',
        required: false,
    )
    include_dirs += [iniparser_path / 'include']
else
    iniparser = dependency('iniparser', required: false)

    if not iniparser.found()
        iniparser = cc.find_library('iniparser', dirs: libsearch_dirs, required: false)
    endif
endif

if not iniparser.found()
    error('iniparser library required but not found!')
endif

iniparser_const_test_code = '''
#include <iniparser.h>
int main() {
    const dictionary *d = 0;
    iniparser_getboolean(d, "", 0);
    return 0;
}
'''

if cdata.has('HAVE_INIPARSER_INIPARSER_H')
    iniparser_const_test_code = '''
#include <iniparser/iniparser.h>
int main() {
    const dictionary *d = 0;
    iniparser_getboolean(d, "", 0);
    return 0;
}
'''
endif

have_iniparser_const = cc.compiles(
    iniparser_const_test_code,
    dependencies: iniparser,
    name: 'iniparser functions accept const dictionary',
)

if have_iniparser_const
    cdata.set('HAVE_INIPARSER_CONST_DICTIONARY', 1)
endif

#
# Check for POSIX threads
#

threads = dependency('threads', required: true)

if cc.has_function(
    'pthread_condattr_setclock',
    dependencies: threads,
    prefix: '#include <pthread.h>',
)
    cdata.set('HAVE_PTHREAD_CONDATTR_SETCLOCK', 1)
endif

#
# Check for libevent or libev
#

eventloop_opt = get_option('with-eventloop')
have_libevent = false
have_libev = false

if eventloop_opt in ['auto', 'libevent']
    libevent = dependency('libevent', required: eventloop_opt == 'libevent')
    have_libevent = libevent.found()
endif

if have_libevent
    event_lib = libevent
elif eventloop_opt in ['auto', 'libev']
    # Try pkg-config / cmake first
    libev = dependency('libev', required: false)

    # Fall back to manual library + header search
    if not libev.found()
        # Find the library: system paths, platform paths, then ev/ subdirs
        # (e.g. NetBSD pkgsrc installs to /usr/pkg/lib/ev/)
        libev_lib = cc.find_library('ev', required: false)
        foreach d : libsearch_dirs
            if not libev_lib.found()
                libev_lib = cc.find_library('ev', dirs: d, required: false)
            endif
            if not libev_lib.found()
                libev_lib = cc.find_library('ev', dirs: d / 'ev', required: false)
            endif
        endforeach

        # Find the header: standard include paths, then ev/ subdirs
        # (e.g. NetBSD pkgsrc installs to /usr/pkg/include/ev/)
        if libev_lib.found()
            libev_incdirs = include_dirs
            if not cc.has_header(
                'ev.h',
                include_directories: include_directories(libev_incdirs),
            )
                foreach d : libsearch_dirs
                    libev_hdir = d.replace('/lib', '/include') / 'ev'
                    if fs.is_dir(libev_hdir)
                        libev_incdirs += libev_hdir
                    endif
                endforeach
            endif
            if cc.has_header(
                'ev.h',
                include_directories: include_directories(libev_incdirs),
            )
                libev = declare_dependency(
                    dependencies: libev_lib,
                    include_directories: include_directories(libev_incdirs),
                )
            endif
        endif
    endif

    have_libev = libev.found()
    if have_libev
        cdata.set('WITH_LIBEV', 1)
        event_lib = libev
    endif
endif

if not have_libevent and not have_libev
    error('Either libevent or libev is required! Please install one of them.')
endif

#
# Check for libgcrypt
#

libgcrypt_path = get_option('with-libgcrypt-path')

libgcrypt_link_args = []

if libgcrypt_path != ''
    libgcrypt_link_args += ['-L' + libgcrypt_path / 'lib', '-lgcrypt']
    libgcrypt = declare_dependency(
        link_args: libgcrypt_link_args,
        include_directories: include_directories(libgcrypt_path / 'include'),
    )
else
    libgcrypt = dependency('libgcrypt', version: '>=1.2.3', required: false)
    if not libgcrypt.found()
        libgcrypt = cc.find_library(
            'libgcrypt',
            dirs: libsearch_dirs,
            required: false,
        )
    endif
endif

have_libgcrypt = libgcrypt.found()

if not have_libgcrypt
    error(
        'Libgcrypt library required for encrypted user auth! Please install version 1.2.3 or later',
    )
endif

#
# Check whether Kerberos V UAM should be compiled
#

enable_krb5_uam = get_option('with-krbV-uam')

if not enable_krb5_uam
    have_krb5_uam = false
    have_gssapi = false
    have_kerberos = false
else
    #
    # Check for GSSAPI
    #

    enable_gssapi = get_option('with-gssapi')
    gssapi_path = get_option('with-gssapi-path')

    gss_libs = []
    gssapi_includes = []
    gssapi_headers = [
        'gssapi.h',
        'gssapi/gssapi.h',
    ]

    foreach header : gssapi_headers
        if cc.has_header(
            header,
            include_directories: include_directories(
                [gssapi_path / 'include', header_dir],
            ),
        )
            cdata.set('HAVE_' + header.underscorify().to_upper(), 1)
        endif
    endforeach

    if not enable_gssapi
        have_gssapi = false
    elif gssapi_path != ''
        have_gssapi = true
        gss = cc.find_library(
            'gssapi',
            dirs: gssapi_path / 'lib',
            required: false,
        )
        gssapi_includes += include_directories(gssapi_path / 'include')
    else
        gss = cc.find_library('gss', dirs: libsearch_dirs, required: false)
        if not gss.found()
            gss = cc.find_library('gssapi', dirs: libsearch_dirs, required: false)
            if not gss.found()
                gss = cc.find_library(
                    'gssapi_krb5',
                    dirs: libsearch_dirs,
                    required: false,
                )
                if not gss.found()
                    have_gssapi = false
                endif
            endif
        endif
        have_gssapi = gss.found() and cc.has_function('gss_acquire_cred', dependencies: gss)
        if have_gssapi
            gss_libs += gss
            cdata.set('HAVE_GSSAPI', 1)
        else
            have_gssapi = false
            warning('GSSAPI support requested but gssapi libraries not found')
        endif
    endif

    #
    # Check for Kerberos V
    #

    enable_kerberos = get_option('with-kerberos')
    kerberos_path = get_option('with-kerberos-path')

    kerberos_includes = []
    kerberos_c_args = []
    kerberos_headers = [
        'krb5.h',
        'krb5/krb5.h',
    ]

    if kerberos_path != ''
        kerberos = cc.find_library(
            'krb5',
            dirs: kerberos_path / 'lib',
            required: false,
        )
        kerberos_includes += include_directories(kerberos_path / 'include')

        krb5_config = find_program(
            'krb5-config',
            dirs: kerberos_path / 'bin',
            required: false,
        )
    else
        kerberos = cc.find_library('krb5', dirs: libsearch_dirs, required: false)
        krb5_config = find_program('krb5-config', required: false)
    endif

    foreach header : kerberos_headers
        if cc.has_header(
            header,
            include_directories: include_directories(
                [kerberos_path / 'include', header_dir],
            ),
        )
            cdata.set('HAVE_' + header.underscorify().to_upper(), 1)
            break
        endif
    endforeach

    if not enable_kerberos
        have_kerberos = false
    else
        have_kerberos = kerberos.found()
        if have_kerberos
            gss_libs += kerberos
            cdata.set('HAVE_KERBEROS', 1)
            if host_os == 'sunos'
                kerberos_c_args += run_command(
                    krb5_config,
                    '--cflags',
                    check: true,
                ).stdout().strip()
            endif
            kerberos_functions = [
                'krb5_free_unparsed_name',
                'krb5_free_error_message',
                'krb5_free_keytab_entry_contents',
                'krb5_kt_free_entry',
            ]
            foreach function : kerberos_functions
                if cc.has_function(function, dependencies: kerberos)
                    cdata.set('HAVE_' + function.underscorify().to_upper(), 1)
                endif
            endforeach
        else
            have_kerberos = false
            warning('Kerberos API support requested but libkrb5 not found')
        endif
    endif
    if have_gssapi and have_kerberos
        have_krb5_uam = true
    else
        have_krb5_uam = false
    endif
    if enable_krb5_uam and not have_gssapi
        warning('Need GSSAPI support to build Kerberos V UAM')
    endif
endif

#
# Check for optional Zeroconf support
#

enable_zeroconf = get_option('with-zeroconf')

have_zeroconf = false

zeroconf_provider = ''

avahi = dependency('avahi-client', required: false)

dns_sd_libs = []

dns_sd = cc.find_library('dns_sd', required: false)
if dns_sd.found()
    dns_sd_libs += dns_sd
endif

system = cc.find_library('system', required: false)
if dns_sd.found()
    dns_sd_libs += system
endif

have_dns = (
    (dns_sd.found() or system.found())
    and cc.has_header('dns_sd.h')
    and cc.has_function(
        'DNSServiceRegister',
        dependencies: dns_sd_libs,
    )
)

if enable_zeroconf
    if host_os == 'darwin'
        # On Darwin/macOS, prefer mDNS over Avahi
        if have_dns
            have_zeroconf = true
            cdata.set('USE_ZEROCONF', 1)
            cdata.set('HAVE_MDNS', 1)
            cdata.set('freebsd_zeroconf', 'mdnsd')
            zeroconf_provider += 'mDNS'
        elif avahi.found()
            have_zeroconf = true
            cdata.set('USE_ZEROCONF', 1)
            cdata.set('HAVE_AVAHI', 1)
            cdata.set('freebsd_zeroconf', 'avahi_daemon')
            zeroconf_provider += 'Avahi'
        endif
    else
        # On non-Darwin platforms, use original priority
        if avahi.found()
            have_zeroconf = true
            cdata.set('USE_ZEROCONF', 1)
            cdata.set('HAVE_AVAHI', 1)
            cdata.set('freebsd_zeroconf', 'avahi_daemon')
            zeroconf_provider += 'Avahi'
        elif have_dns
            have_zeroconf = true
            cdata.set('USE_ZEROCONF', 1)
            cdata.set('HAVE_MDNS', 1)
            cdata.set('freebsd_zeroconf', 'mdnsd')
            zeroconf_provider += 'mDNS'
        endif
    endif
endif

if enable_zeroconf and not have_zeroconf
    warning(
        'Zeroconf support requested but required libraries not found',
        'Please install Avahi or mDNS',
    )
endif

#
# Check for Spotlight search backend support
#

have_spotlight = false
use_spotlight_cnid = false
use_spotlight_localsearch = false
use_spotlight_xapian = false
spotlight_backends = ''
dbus_daemonpath = get_option('with-dbus-daemon-path')

if get_option('with-spotlight')
    talloc = dependency('talloc', required: false)

    if talloc.found()
        if 'cnid' in get_option('with-spotlight-backends')
            use_spotlight_cnid = true
            spotlight_backends = 'cnid'
            cdata.set('SPOTLIGHT_BACKEND_CNID', 1)
        endif

        if 'localsearch' in get_option('with-spotlight-backends')
            if host_os == 'darwin'
                if brew_prefix != ''
                    bison = find_program(brew_prefix / 'opt/bison/bin/bison', required: false)
                else
                    bison = find_program('/opt/local/bin/bison', required: false)
                endif
            else
                bison = find_program('bison', required: false)
            endif

            flex = find_program('flex', required: false)

            # Check for SPARQL

            sparql_found = false
            tinysparql = dependency('tinysparql-3.0', required: false)
            tracker_sparql = dependency('tracker-sparql-3.0', required: false)

            if tinysparql.found()
                sparql_found = true
                sparql = tinysparql
            elif tracker_sparql.found()
                sparql_found = true
                sparql = tracker_sparql
                cdata.set('HAVE_TRACKER3', 1)
            endif

            # GLib's main loop drives the TinySPARQL/LocalSearch async
            # query pipeline.
            glib = dependency('glib-2.0', required: false)

            # Check for indexer

            indexer_found = false
            localsearch = find_program('localsearch', required: false)
            tracker3 = find_program('tracker3', required: false)
            gsettings = find_program('gsettings', required: false)
            dconf = find_program('dconf', required: false)

            # The localsearch backend launches a private dbus-daemon to
            # host an isolated session bus that afpd and the indexer
            # communicate over.
            dbus = dependency('dbus-1', required: false)

            if dbus_daemonpath == '' and fs.exists(bindir / 'dbus-daemon')
                dbus_daemonpath += bindir / 'dbus-daemon'
            elif dbus_daemonpath == '' and dbus.found()
                dbus_daemonpath += '/bin/dbus-daemon'
            endif

            if dbus_daemonpath != ''
                cdata.set('DBUS_DAEMON_PATH', '"' + dbus_daemonpath + '"')
            endif

            localsearch3_schema_found = false
            tracker3_schema_found = false
            if gsettings.found()
                localsearch3_schema_check = run_command(
                    gsettings,
                    'list-keys',
                    'org.freedesktop.LocalSearch3.Miner.Files',
                    check: false,
                )
                tracker3_schema_check = run_command(
                    gsettings,
                    'list-keys',
                    'org.freedesktop.Tracker3.Miner.Files',
                    check: false,
                )
                localsearch3_schema_found = localsearch3_schema_check.returncode() == 0
                tracker3_schema_found = tracker3_schema_check.returncode() == 0
            endif

            indexer = disabler()
            if localsearch.found()
                indexer = localsearch
            elif tracker3.found()
                indexer = tracker3
            endif

            if indexer.found() and localsearch3_schema_found
                indexer_found = true
                cdata.set('INDEXER_DBUS_NAME', '"org.freedesktop.LocalSearch3"')
                cdata.set(
                    'INDEXER_DCONF_PATH',
                    '"org/freedesktop/localsearch/miner/files"',
                )
            elif indexer.found() and tracker3_schema_found
                indexer_found = true
                cdata.set(
                    'INDEXER_DBUS_NAME',
                    '"org.freedesktop.Tracker3.Miner.Files"',
                )
                cdata.set(
                    'INDEXER_DCONF_PATH',
                    '"org/freedesktop/tracker/miner/files"',
                )
            endif

            cdata.set('INDEXER_DCONF_DB_DIR', '"/etc/dconf/db/netatalk.d"')
            cdata.set('INDEXER_DCONF_PROFILE', '"/etc/dconf/profile/netatalk"')

            use_spotlight_localsearch = (
                sparql_found
                and indexer_found
                and dconf.found()
                and glib.found()
                and talloc.found()
                and flex.found()
                and bison.found()
            )

            if use_spotlight_localsearch
                if spotlight_backends != ''
                    spotlight_backends += ' | '
                endif
                spotlight_backends += 'localsearch'
                cdata.set('SPOTLIGHT_BACKEND_LOCALSEARCH', 1)
                cdata.set(
                    'DCONF_UPDATE_COMMAND',
                    '"' + dconf.full_path() + ' update"',
                )
                install_emptydir('/etc/dconf/db')
                if get_option('with-install-hooks')
                    meson.add_install_script(dconf, 'update')
                endif
            else
                warning(
                    'localsearch Spotlight search backend requested but one or more required dependencies not found',
                )
            endif
        endif

        if 'xapian' in get_option('with-spotlight-backends')
            xapian = dependency('xapian-core', required: false)
            libmagic = dependency('libmagic', required: false)

            if not libmagic.found()
                magic_lib = cc.find_library('magic', required: false)

                if magic_lib.found() and cc.has_header('magic.h') and cc.has_function(
                    'magic_open',
                    prefix: '#include <magic.h>',
                    dependencies: magic_lib,
                )
                    libmagic = magic_lib
                endif
            endif

            if cpp_found and xapian.found() and libmagic.found()
                use_spotlight_xapian = true

                if spotlight_backends != ''
                    spotlight_backends += ' | '
                endif

                spotlight_backends += 'xapian'
                cdata.set('SPOTLIGHT_BACKEND_XAPIAN', 1)
            else
                warning(
                    'xapian Spotlight search backend requested but one or more dependencies were not found',
                )
            endif
        endif
    else
        warning('talloc library required for Spotlight search support')
    endif

    have_spotlight = use_spotlight_cnid or use_spotlight_localsearch or use_spotlight_xapian
endif

if have_spotlight
    cdata.set('WITH_SPOTLIGHT', 1)
    cdata.set('SPOTLIGHT_BACKENDS', '"' + spotlight_backends + '"')
endif

#
# Check for CUPS
#

cups = dependency('cups', required: false, version: '>=1.6')
spooldir = ''

if get_option('with-cups') and get_option('with-appletalk')
    spooldir = localstatedir / 'spool' / 'netatalk'

    spooldir_override = get_option('with-spooldir')
    if spooldir_override != ''
        spooldir = spooldir_override
    endif

    have_cups = cups.found()
    if have_cups
        cdata.set('HAVE_CUPS', 1)
        cdata.set('CUPS_API_VERSION', '"' + cups.version() + '"')
    else
        warning(
            'CUPS 1.6 or newer not found',
        )
    endif
else
    have_cups = false
endif

#
# Check for quota support
#

enable_quota = get_option('with-quota')

prop = cc.find_library('prop', required: false)
quota = cc.find_library('quota', required: false)
rpcsvc = cc.find_library('rpcsvc', required: false)
tirpc = dependency('libtirpc', required: false)

quota_deps = []
quota_provider = ''
have_libquota = false

rpc_headers_ok = (
    cc.has_header('rpc/rpc.h')
    and cc.has_header('rpc/pmap_prot.h')
    and cc.has_header('rpcsvc/rquota.h')
)

if not enable_quota
    have_quota = false
    cdata.set('NO_QUOTA_SUPPORT', 1)
elif quota.found() and cc.has_function('quota_open')
    # FreeBSD provides libquota API in libc
    have_libquota = true
    have_quota = true
    quota_provider += 'libquota'
    cdata.set('HAVE_LIBQUOTA', 1)
elif quota.found() and prop.found() and cc.has_function('quota_open', dependencies: [quota, prop])
    # NetBSD provides libquota API in libquota (depends on libprop)
    have_libquota = true
    have_quota = true
    quota_provider += 'libquota'
    quota_deps += [quota, prop]
    cdata.set('HAVE_LIBQUOTA', 1)
elif tirpc.found() and cc.has_header('rpcsvc/rquota.h')
    cdata.set('NEED_RQUOTA', 1)
    quota_deps += tirpc
    quota_provider += 'libtirpc'
    if cc.compiles(
        '''
        #include <rpcsvc/rquota.h>
        int main(void) {
        enum qr_status foo;
        foo = Q_OK;
        return 0;
        }
        ''',
        dependencies: tirpc,
    )
        cdata.set('HAVE_RQUOTA_H_QR_STATUS', 1)
    endif
    have_quota = true
elif rpcsvc.found() and rpc_headers_ok
    quota_deps += rpcsvc
    quota_provider += 'SunRPC'
    have_quota = true
else
    have_quota = false
    cdata.set('NO_QUOTA_SUPPORT', 1)
endif

if enable_quota and not have_quota
    warning(
        'Quota support requested but required libtirpc or libquota libraries not found',
    )
endif

#
# Check for Extended Attributes support
#

netatalk_ea = 'ad'
attr = cc.find_library('attr', required: false)

if host_os == 'sunos'
    # extattr API has full fledged fds for EAs

    have_ea = true
    cdata.set('HAVE_EAFD', 1)
elif host_os == 'freebsd'
    have_ea = true
    ea_functions = [
        'extattr_delete_file',
        'extattr_delete_link',
        'extattr_get_fd',
        'extattr_get_file',
        'extattr_get_link',
        'extattr_list_fd',
        'extattr_list_file',
        'extattr_list_link',
        'extattr_set_fd',
        'extattr_set_file',
        'extattr_set_link',
    ]
    foreach f : ea_functions
        if cc.has_function(f)
            define = 'HAVE_' + f.underscorify().to_upper()
            cdata.set(define, 1)
        endif
    endforeach
elif host_os == 'aix'
    have_ea = true
    ea_functions = [
        'fgetea',
        'fsetea',
        'getea',
        'lgetea',
        'listea',
        'llistea',
        'lremoveea',
        'removeea',
        'setea',
    ]
    foreach f : ea_functions
        if cc.has_function(f)
            define = 'HAVE_' + f.underscorify().to_upper()
            cdata.set(define, 1)
        endif
    endforeach
elif cc.has_function('getxattr', dependencies: attr)
    have_ea = true
    ea_functions = [
        'fgetxattr',
        'fsetxattr',
        'getxattr',
        'lgetxattr',
        'listxattr',
        'llistxattr',
        'lremovexattr',
        'lsetxattr',
        'removexattr',
        'setxattr',
    ]
    foreach f : ea_functions
        if cc.has_function(f)
            define = 'HAVE_' + f.underscorify().to_upper()
            cdata.set(define, 1)
        endif
    endforeach
    if host_os == 'darwin'
        cdata.set('HAVE_EAFD', 1)
    endif
else
    have_ea = false
endif

if have_ea
    netatalk_ea += ' | sys'
endif

cdata.set('EA_MODULES', '"' + netatalk_ea + '"')

# Do xattr functions take additional options like on Darwin?

if cc.compiles(
    '''
#include <sys/types.h>
#include <sys/xattr.h>
int main(void) {
  getxattr(0, 0, 0, 0, 0, 0);
  return 0;
}
''',
)
    cdata.set('XATTR_ADD_OPT', 1)
endif

#
# Check for ACL support
#

enable_acls = get_option('with-acls')

acl_deps = []
acl_includes = []
acl_link_args = []

if not enable_acls
    have_acls = false
elif host_os == 'darwin'
    have_acls = false
    warning('Darwin ACLs are currently unsupported')
elif host_os.contains('sunos')
    have_acls = true
    sec = cc.find_library('sec', required: false)
    acl_deps += sec
    cdata.set('HAVE_ACLS', 1)
    cdata.set('HAVE_SOLARIS_ACLS', 1)
    cdata.set('HAVE_NFSV4_ACLS', 1)
elif host_os == 'freebsd'
    sunacl = cc.find_library(
        'sunacl',
        dirs: libsearch_dirs,
        required: false,
    )
    have_acls = cc.has_function('acl', dependencies: sunacl)
    if have_acls
        acl_deps += sunacl
        cdata.set('HAVE_ACLS', 1)
        cdata.set('HAVE_FREEBSD_SUNACL', 1)
        cdata.set('HAVE_NFSV4_ACLS', 1)
    else
        have_acls = false
        warning('libsunacl not found, disabling ZFS ACL support')
    endif
else
    # Runtime checks for POSIX ACLs

    acl = cc.find_library('acl', required: false)

    if acl.found()
        acl_link_args += '-lacl'
    endif

    if cc.has_function('acl_get_file', dependencies: acl)
        acl_deps += acl
    endif

    if host_os == 'linux'
        if cc.has_function('getxattr', dependencies: attr)
            acl_deps += attr
        endif
    endif

    acl_get_entry_code = '''
        #include <sys/types.h>
        #include <sys/acl.h>
        int main(void) {
            acl_t acl;
            int entry_id;
            acl_entry_t *entry_p;
            return acl_get_entry(acl, entry_id, entry_p);
        }
    '''
    have_acls = cc.links(acl_get_entry_code, args: acl_link_args)
    if have_acls
        cdata.set('HAVE_ACLS', 1)
        cdata.set('HAVE_POSIX_ACLS', 1)
        acl_get_perm_np_code = '''
            #include <sys/types.h>
            #include <sys/acl.h>
            int main(void) {
                acl_permset_t permset_d;
                acl_perm_t perm;
                return acl_get_perm_np(permset_d, perm);
            }
        '''
        if cc.links(acl_get_perm_np_code, args: acl_link_args)
            cdata.set('HAVE_ACL_GET_PERM_NP', 1)
        endif
        if cc.has_function('acl_from_mode', dependencies: acl)
            cdata.set('HAVE_ACL_FROM_MODE', 1)
        endif
    else
        have_acls = false
    endif

    if enable_acls and not have_acls
        warning('ACL support requested but required libraries not found')
    endif
endif

#
# Check for LDAP support, for client-side ACL visibility
#

enable_ldap = get_option('with-ldap')
ldap_path = get_option('with-ldap-path')

ldap_link_args = []

if ldap_path == '' and fs.exists(brew_prefix / 'opt/openldap')
    ldap_path = brew_prefix / 'opt/openldap'
endif

if ldap_path != ''
    ldap_link_args += ['-L' + ldap_path / 'lib', '-lldap']
    ldap = declare_dependency(
        link_args: ldap_link_args,
        include_directories: include_directories(ldap_path / 'include'),
    )
else
    ldap = cc.find_library('ldap', dirs: libsearch_dirs, required: false)
endif

if not enable_ldap
    have_ldap = false
else
    have_ldap = ldap.found() and cc.has_function('ldap_initialize', dependencies: ldap)
    if have_ldap
        cdata.set('HAVE_LDAP', 1)
    else
        have_ldap = false
    endif
endif

if enable_ldap and not have_ldap
    warning('LDAP support requested but LDAP library not found')
endif

#
# Check if realpath() takes NULL
#

if cc.compiles(
    '''
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <signal.h>

void exit_on_core(int ignored) {
    exit(1);
}

int main(void) {
    char *newpath;
    signal(SIGSEGV, exit_on_core);
    newpath = realpath("/tmp", NULL);
    exit((newpath != NULL) ? 0 : 1);
}
''',
)
    cdata.set('REALPATH_TAKES_NULL', 1)
endif

#
# Check for iconv support
#

enable_iconv = get_option('with-libiconv')
iconv_path = get_option('with-libiconv-path')

iconv = dependency('iconv', required: false)
libiconv = cc.find_library('iconv', dirs: libsearch_dirs, required: false)

libiconv_link_args = []

if iconv_path != ''
    libiconv_link_args += ['-L' + iconv_path / 'lib', '-liconv']
    iconv = declare_dependency(
        link_args: libiconv_link_args,
        include_directories: include_directories(iconv_path / 'include'),
    )
endif

if not enable_iconv
    have_iconv = false
else
    have_iconv = (
        (iconv.found() or libiconv.found())
        and cc.compiles(
            '''
    #include <iconv.h>
    int main(void) {
        iconv_t cd = iconv_open("ASCII", "UTF-8");
        if (cd == 0 || cd == (iconv_t)-1) return -1;
    return 0;
    }
    ''',
        )
    )
    if have_iconv
        cdata.set('HAVE_USABLE_ICONV', 1)
        iconv_code = '''
            #ifndef _XPG6
            #define _XPG6 1
            #endif
            #include <stdlib.h>
            #include <iconv.h>
            extern
            #ifdef __cplusplus
                "C"
            #endif
            #if defined(__STDC__) || defined(__cplusplus)
                size_t iconv (iconv_t cd, const char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
            #else
                size_t iconv();
            #endif
        '''

        if cc.compiles(
            iconv_code,
            include_directories: include_directories(include_dirs),
            name: 'iconv with const inbuf',
        )
            cdata.set('ICONV_CONST', 'const')
        else
            cdata.set('ICONV_CONST', '')
        endif

        if meson.can_run_host_binaries()
            if cc.run(
                '''
                #include <iconv.h>
                int main(void) {
                    iconv_t cd = iconv_open("ASCII", "UCS-2-INTERNAL");
                    if (cd == 0 || cd == (iconv_t)-1) return -1;
                    return 0;
                }
                ''',
            ).returncode() == 0
                cdata.set('HAVE_UCS2INTERNAL', 1)
            endif
        endif
    else
        have_iconv = false
        warning(
            'iconv support requested but required libraries not found',
            'Please install libiconv',
        )
    endif
endif

#
# Check for PAM support
#

enable_pam = get_option('with-pam')
pam_path = get_option('with-pam-path')
pam_conf_path = get_option('with-pam-config-path')

pam_dir = ''
pam_d_dir = ''
pam_confdir = ''
pam_includes = []
pam_link_args = []
uams_options = ''

if not enable_pam
    have_pam = false
else
    if host_os != 'sunos'
        pam_paths = [
            '/',
            '/usr',
            '/usr/local',
        ]

        foreach path : pam_paths
            if fs.is_dir(path / 'etc/pam.d')
                pam_dir = path
                pam_d_dir = pam_dir / 'etc/pam.d'
                break
            endif
        endforeach
    else
        warning(
            'PAM installation file = /etc/pam.conf. Please edit this file to enable PAM support',
        )
    endif

    if pam_path != '' and pam_dir != '/'
        pam_link_args += ['-L' + pam_path / 'lib', '-lpam']
        pam = declare_dependency(
            link_args: pam_link_args,
            include_directories: include_directories(pam_path / 'include'),
        )
    else
        pam = cc.find_library('pam', dirs: libsearch_dirs, required: false)
    endif

    pam_header_dirs = include_directories(header_dir)

    have_pam = (
        cc.has_header('security/pam_appl.h', include_directories: pam_header_dirs)
        or cc.has_header('pam/pam_appl.h', include_directories: pam_header_dirs)
        or cc.has_function('pam_set_item', dependencies: pam)
    )

    if have_pam
        uams_options += 'pam'
        if fs.exists(pam_d_dir / 'common-auth')
            # Debian/SuSE
            cdata.set('PAM_DIRECTIVE', 'include')
            cdata.set('PAM_AUTH', 'common-auth')
            cdata.set('PAM_ACCOUNT', 'common-account')
            cdata.set('PAM_PASSWORD', 'common-password')
            if fs.exists(pam_d_dir / 'common-session-noninteractive')
                cdata.set('PAM_SESSION', 'common-session-noninteractive')
            elif fs.exists(pam_d_dir / 'common-session-nonlogin')
                cdata.set('PAM_SESSION', 'common-session-nonlogin')
            else
                cdata.set('PAM_SESSION', 'common-session')
            endif
        elif fs.exists(pam_d_dir / 'system-auth')
            # RHEL/FC
            cdata.set('PAM_DIRECTIVE', 'include')
            cdata.set('PAM_AUTH', 'system-auth')
            cdata.set('PAM_ACCOUNT', 'system-auth')
            cdata.set('PAM_PASSWORD', 'system-auth')
            cdata.set('PAM_SESSION', 'system-auth')
        elif fs.exists(pam_d_dir / 'system')
            # FreeBSD, NetBSD, OpenBSD
            cdata.set('PAM_DIRECTIVE', 'include')
            cdata.set('PAM_AUTH', 'system')
            cdata.set('PAM_ACCOUNT', 'system')
            cdata.set('PAM_PASSWORD', 'system')
            cdata.set('PAM_SESSION', 'system')
        elif fs.exists(pam_d_dir / 'chkpasswd')
            # macOS
            cdata.set('PAM_DIRECTIVE', 'required')
            cdata.set('PAM_AUTH', 'pam_opendirectory.so')
            cdata.set('PAM_ACCOUNT', 'pam_opendirectory.so')
            cdata.set('PAM_PASSWORD', 'pam_permit.so')
            cdata.set('PAM_SESSION', 'pam_permit.so')
        elif fs.exists(pam_d_dir / 'other')
            # Solaris 11+
            cdata.set('PAM_DIRECTIVE', 'include')
            cdata.set('PAM_AUTH', pam_dir / 'etc/pam.d/other')
            cdata.set('PAM_ACCOUNT', pam_dir / 'etc/pam.d/other')
            cdata.set('PAM_PASSWORD', pam_dir / 'etc/pam.d/other')
            cdata.set('PAM_SESSION', pam_dir / 'etc/pam.d/other')
        else
            # Fallback
            cdata.set('PAM_DIRECTIVE', 'required')
            cdata.set('PAM_AUTH', 'pam_unix.so')
            cdata.set('PAM_ACCOUNT', 'pam_unix.so')
            cdata.set('PAM_PASSWORD', '"pam_unix.so use_authtok"')
            cdata.set('PAM_SESSION', 'pam_unix.so')
        endif

        if cc.has_header('security/pam_appl.h', include_directories: pam_header_dirs)
            pam_header = 'security/pam_appl.h'
        elif cc.has_header('pam/pam_appl.h', include_directories: pam_header_dirs)
            pam_header = 'pam/pam_appl.h'
        else
            pam_header = 'security/pam_appl.h'
        endif

        pam_conv_with_const_code = '''
        #include <@0@>

        int my_conv(int, const struct pam_message **, struct pam_response **, void *);

        static struct pam_conv conv = {
        .conv = my_conv,
        .appdata_ptr = 0,
        };

        int main(void) {
        return 0;
        }
        '''.format(pam_header)

        have_pam_conv_with_const = cc.compiles(
            pam_conv_with_const_code,
            include_directories: pam_header_dirs,
            name: 'pam_conv with const pam_message',
        )

        if have_pam_conv_with_const
            cdata.set('HAVE_PAM_CONV_CONST_PAM_MESSAGE', 1)
        endif

        if pam_conf_path != ''
            pam_confdir += pam_conf_path
        else
            pam_confdir += pam_d_dir
        endif

        if pam_dir == ''
            warning(
                'PAM support can be compiled, but the install location for the netatalk.pamd file could not be determined. Please install this file manually. If you are running a Solaris-based host which still relies on /etc/pam.conf you will have to edit this file to get PAM working',
            )
        endif
    else
        have_pam = false
        warning('PAM support requested but required library not found')
    endif
endif

#
# Check for passwd and shadow authentication support
#

crypt = cc.find_library('crypt', required: false)
if crypt.found()
    have_crypt = cc.has_function('crypt', dependencies: crypt)
    have_crypt_checkpass = cc.has_function('crypt_checkpass', dependencies: crypt)
else
    have_crypt = cc.has_function('crypt')
    have_crypt_checkpass = cc.has_function('crypt_checkpass')
endif

if have_crypt_checkpass
    cdata.set('HAVE_CRYPT_CHECKPASS', 1)
endif

if host_os == 'darwin'
    warning('non-PAM authentication currently not supported on macOS')
elif cc.has_header('shadow.h')
    cdata.set('SHADOWPW', 1)
    if uams_options != ''
        uams_options += ' | '
    endif
    uams_options += 'shadow'
elif have_crypt or have_crypt_checkpass
    if uams_options != ''
        uams_options += ' | '
    endif
    uams_options += 'passwd'
endif

if not have_crypt and not have_crypt_checkpass
    warning('crypt functions not found; only PAM authentication is possible')
endif

#
# Netatalk lockfile path
#

lockfile_path = get_option('with-lockfile-path')
lockfile_suffix = ''

if host_os in ['netbsd', 'openbsd', 'darwin']
    lockfile_suffix = '.pid'
endif

if lockfile_path == ''
    if host_os == 'freebsd'
        lockfile_path += '/var/spool/lock'
    elif host_os in ['netbsd', 'openbsd', 'darwin']
        lockfile_path += '/var/run'
    elif host_os == 'linux'
        lockfile_path += '/var/lock'
    else
        lockfile_path += '/var/spool/locks'
    endif
endif

cdata.set(
    'PATH_ATALKD_LOCK',
    '"' + lockfile_path + '/atalkd' + lockfile_suffix + '"',
)
cdata.set(
    'PATH_NETATALK_LOCK',
    '"' + lockfile_path + '/netatalk' + lockfile_suffix + '"',
)
cdata.set('PATH_PAPD_LOCK', '"' + lockfile_path + '/papd' + lockfile_suffix + '"')

#
# Check for largefle support
#

# needed for Linux, Solaris...
file_offset_bits_test = cc.compiles(
    '''
    #if !defined(_FILE_OFFSET_BITS) || (_FILE_OFFSET_BITS != 64)
        #error "Large-file support was not enabled"
    #endif
    ''',
)

# Needed for AIX, macOS
large_files_test = cc.sizeof('off_t') == 8

have_largefile = file_offset_bits_test or large_files_test
if have_largefile
    cdata.set('_FILE_OFFSET_BITS', 64)
else
    error('Largefile support required but not available on this platform')
endif

#
# Check for sendfile
#

enable_sendfile = get_option('with-sendfile')

if not enable_sendfile
    have_sendfile = false
elif host_os == 'linux'
    cdata.set('SENDFILE_FLAVOR_LINUX', 1)
    have_sendfile = cc.has_function('sendfile')
    if have_sendfile
        cdata.set('WITH_SENDFILE', 1)
    endif
elif host_os == 'sunos'
    cdata.set('SENDFILE_FLAVOR_SOLARIS', 1)
    have_sendfile = cc.has_function('sendfile', dependencies: sendfile)
    if have_sendfile
        cdata.set('WITH_SENDFILE', 1)
    endif
    if cc.has_function('sendfilev', dependencies: sendfile)
        cdata.set('HAVE_SENDFILEV', 1)
    endif
elif host_os == 'freebsd'
    cdata.set('SENDFILE_FLAVOR_FREEBSD', 1)
    have_sendfile = cc.has_function('sendfile')
    if have_sendfile
        cdata.set('WITH_SENDFILE', 1)
    endif
endif

#
# Check for recvfile
#

if host_os == 'linux' and cc.has_function('splice')
    cdata.set('WITH_RECVFILE', 1)
    cdata.set('HAVE_SPLICE', 1)
endif

#
# Check for dtrace
#

enable_dtrace = get_option('with-dtrace')

dtrace = find_program('dtrace', required: false)
libelf = cc.find_library('elf', required: false)
dtrace_command = [
    'env',
    'CC=' + ' '.join(cc.cmd_array()),
    dtrace,
]
dtrace_deps = []

if not enable_dtrace
    have_dtrace = false
elif host_os == 'freebsd' and cpu == 'aarch64'

    # See https://wiki.freebsd.org/arm64#Known_Limitations

    have_dtrace = false
    warning('The version of dtrace in aarch64 FreeBSD is currently unsupported')
else
    have_dtrace = dtrace.found()
    if have_dtrace
        cdata.set('WITH_DTRACE', 1)
        if host_os == 'freebsd'
            dtrace_deps += libelf
        endif
    else
        have_dtrace = false
        warning('Dtrace probe support requested but dtrace not found')
    endif
endif

#
# Check whether to enable FCE (File Change Events)
#

have_fce = get_option('with-fce')

if have_fce
    cdata.set('WITH_FCE', 1)
endif

#
# Check for optional initscript install
#

init_style = get_option('with-init-style')
init_dirs = []
init_style_auto = false
init_cmd = ''

if 'auto' in init_style
    init_style_auto = true
    if host_os == 'linux'
        if linux_distro in ['arch', 'centos', 'debian', 'fedora', 'rhel', 'suse', 'ubuntu']
            init_style = ['systemd']
            init_cmd = 'systemctl'
        elif linux_distro in ['alpine', 'gentoo']
            init_style = ['openrc']
            init_cmd = 'rc-service'
        endif
    elif host_os in ['dragonfly', 'freebsd']
        init_style = ['freebsd']
    elif host_os == 'netbsd'
        init_style = ['netbsd']
        init_cmd = 'service'
    elif host_os == 'openbsd'
        init_style = ['openbsd']
        init_cmd = 'rcctl'
    elif host_os == 'darwin'
        init_style = ['macos-launchd']
    elif host_os == 'sunos'
        init_style = ['solaris']
        init_cmd = 'svcadm'
    else
        init_style = ['none']
    endif
endif

if init_cmd != '' and get_option('with-init-hooks')
    init_program = find_program(init_cmd, required: not init_style_auto)
    if not init_program.found()
        warning(init_cmd + ' not found, defaulting to no init scripts')
        init_style = ['none']
        init_cmd = ''
    endif
endif

#
# Check for cracklib support
#

enable_cracklib = get_option('with-cracklib')
cracklib_path = get_option('with-cracklib-path')

crack = cc.find_library('crack', dirs: libsearch_dirs, required: false)
cracklib_dict = ''

if fs.is_dir('/usr/share/cracklib')
    cracklib_dict += '/usr/share/cracklib/pw_dict'
elif fs.is_dir('/var/cache/cracklib')
    cracklib_dict += '/var/cache/cracklib/cracklib_dict'
elif fs.is_dir('/usr/local/libdata/cracklib')
    cracklib_dict += '/usr/local/libdata/cracklib/cracklib-words'
elif fs.is_dir('/usr/pkg/share/cracklib')
    cracklib_dict += '/usr/pkg/share/cracklib/pw_dict'
elif fs.is_dir('/usr/local/share/cracklib')
    cracklib_dict += '/usr/local/share/cracklib/cracklib-small'
elif fs.is_dir('/opt/homebrew/share/cracklib')
    cracklib_dict += '/opt/homebrew/share/cracklib/cracklib-small'
endif

if not enable_cracklib
    have_cracklib = false
else
    have_cracklib = crack.found() and (cracklib_path != '' or cracklib_dict != '')
    if have_cracklib
        cdata.set('USE_CRACKLIB', 1)
        if cracklib_path != ''
            cdata.set('_PATH_CRACKLIB', '"' + cracklib_path + '"')
        elif host_os == 'darwin' and brew_prefix != ''
            cdata.set(
                '_PATH_CRACKLIB',
                '"' + brew_prefix / 'var/cracklib/cracklib-words' + '"',
            )
        elif cracklib_dict != ''
            cdata.set('_PATH_CRACKLIB', '"' + cracklib_dict + '"')
        endif
    else
        have_cracklib = false
        if not crack.found()
            warning('Cracklib support requested but cracklib library not found')
        endif
        if not (cracklib_path != '' or cracklib_dict != '')
            warning('Cracklib support requested but cracklib dictionary not found')
        endif
    endif
endif

#
# Check for TCP wrappers support
#

enable_tcpwrap = get_option('with-tcp-wrappers')

wrap = cc.find_library('wrap', required: false)

if not enable_tcpwrap
    have_tcpwrap = false
else
    tcpwrap_code = '''
#include <tcpd.h>
int main(void) {
    int allow_severity = 0;
    int deny_severity = 0;
    ;
    return 0;
}
'''

    # *BSD have tcpwrappers support in libc
    have_tcpwrap = wrap.found() and cc.links(tcpwrap_code)
    if not have_tcpwrap
        have_tcpwrap = wrap.found() and cc.links(tcpwrap_code, args: '-lwrap')
    endif
    if not have_tcpwrap
        have_tcpwrap = cc.links(tcpwrap_code, args: ['-lwrap', '-lnsl'])
    endif
    if have_tcpwrap
        cdata.set('TCPWRAP', 1)
    else
        have_tcpwrap = false
        warning('TCP wrappers support requested but required library not found')
    endif
endif

#
# Check whether to enable DDP (AppleTalk)
#

enable_appletalk = get_option('with-appletalk')

if not enable_appletalk
    have_appletalk = false
    cdata.set('NO_DDP', 1)
else
    have_appletalk = true
endif

#
# Check whether to install the Netatalk Webmin Module
#

with_webmin = get_option('with-webmin')
have_webmin = false
install_webmin = false

webmin_dirs = [
    '/usr/share/webmin',
    '/usr/libexec/webmin',
    '/opt/webmin',
]

if with_webmin
    tar = find_program('tar', required: true)
    webmin_install_script = 'install-module.pl'
    have_webmin = true
    foreach dir : webmin_dirs
        if fs.exists(dir / webmin_install_script)
            webmin = find_program(dir / webmin_install_script, required: true)
            install_webmin = true
            break
        endif
    endforeach
    if not install_webmin
        warning(
            'Webmin module will be generated but not installed, because Webmin could not be found',
        )
    endif
endif

#
# OS-specific configuration
#

cdata.set('OPEN_NOFOLLOW_ERRNO', 'ELOOP')
use_glibc_at_header = false

if host_os == 'freebsd'
    cdata.set('BSD4_4', 1)
    cdata.set('FREEBSD', 1)
    cdata.set('OPEN_NOFOLLOW_ERRNO', 'EMLINK')
elif host_os == 'dragonfly'
    # FreeBSD-derived: open(O_NOFOLLOW) on a symlink fails with EMLINK, not ELOOP.
    cdata.set('BSD4_4', 1)
    cdata.set('OPEN_NOFOLLOW_ERRNO', 'EMLINK')
elif host_os == 'linux'
    use_glibc_at_header = cc.has_header('netatalk/at.h')
    if cc.compiles(
        '''
#include <sys/socket.h>
#include <sys/types.h>
#include <linux/atalk.h>

struct atalk_addr foo;

int main (void){

    ;
    return 0;
}
''',
    )
        cdata.set('HAVE_ATALK_ADDR', 1)
    endif
    cdata.set('HAVE_BROKEN_DBTOB', 1)
    cdata.set('LINUX', 1)
elif host_os == 'netbsd'
    cdata.set('BSD4_4', 1)
    cdata.set('NETBSD', 1)
    cdata.set('OPEN_NOFOLLOW_ERRNO', 'EFTYPE')
elif host_os == 'openbsd'
    cdata.set('BSD4_4', 1)
elif host_os == 'sunos'
    cdata.set('__svr4__', 1)
    cdata.set('SOLARIS', 1)
elif host_os == 'darwin'
    cdata.set('HAVE_BROKEN_DBTOB', 1)
endif

#
# Check whether to enable debug code
#

if get_option('with-debug')
    cdata.set('DEBUG', 1)
endif

#
# Check whether to enable debugging
#

if get_option('with-debugging')
    cdata.set('DEBUGGING', 1)
endif

#
# Record build type for version display
#

cdata.set('BUILD_TYPE', '"' + build_type + '"')

#
# Variable substitution
#

cdata.set('bindir', bindir)
cdata.set('etcdir', pkgconfdir)
cdata.set('exec_prefix', exec_prefix)
cdata.set('datadir', datadir)
cdata.set('homedir', homedir)
cdata.set('libdir', libdir)
cdata.set('libexecdir', libexecdir)
cdata.set('includedir', includedir)
cdata.set('localstatedir', localstatedir)
cdata.set('lockfile_path', lockfile_path)
cdata.set('netatalk_version', netatalk_version)
cdata.set('pkgconfdir', pkgconfdir)
cdata.set('prefix', prefix)
cdata.set('sbindir', sbindir)

if perl.found()
    cdata.set('PERL', perl.full_path())
endif

if have_webmin
    init_netatalk_start = ''
    init_netatalk_stop = ''
    init_netatalk_restart = ''
    init_atalkd_start = ''
    init_atalkd_stop = ''
    init_atalkd_restart = ''
    init_papd_start = ''
    init_papd_stop = ''
    init_papd_restart = ''
    init_timelord_start = ''
    init_timelord_stop = ''
    init_timelord_restart = ''
    init_a2boot_start = ''
    init_a2boot_stop = ''
    init_a2boot_restart = ''

    if 'systemd' in init_style
        init_netatalk_start = 'systemctl start netatalk'
        init_netatalk_stop = 'systemctl stop netatalk'
        init_netatalk_restart = 'systemctl restart netatalk'
        init_atalkd_start = 'systemctl start atalkd'
        init_atalkd_stop = 'systemctl stop atalkd'
        init_atalkd_restart = 'systemctl restart atalkd'
        init_papd_start = 'systemctl start papd'
        init_papd_stop = 'systemctl stop papd'
        init_papd_restart = 'systemctl restart papd'
        init_timelord_start = 'systemctl start timelord'
        init_timelord_stop = 'systemctl stop timelord'
        init_timelord_restart = 'systemctl restart timelord'
        init_a2boot_start = 'systemctl start a2boot'
        init_a2boot_stop = 'systemctl stop a2boot'
        init_a2boot_restart = 'systemctl restart a2boot'
    elif 'openrc' in init_style
        init_netatalk_start = 'rc-service netatalk start'
        init_netatalk_stop = 'rc-service netatalk stop'
        init_netatalk_restart = 'rc-service netatalk restart'
        init_atalkd_start = 'rc-service atalkd start'
        init_atalkd_stop = 'rc-service atalkd stop'
        init_atalkd_restart = 'rc-service atalkd restart'
        init_papd_start = 'rc-service papd start'
        init_papd_stop = 'rc-service papd stop'
        init_papd_restart = 'rc-service papd restart'
        init_timelord_start = 'rc-service timelord start'
        init_timelord_stop = 'rc-service timelord stop'
        init_timelord_restart = 'rc-service timelord restart'
        init_a2boot_start = 'rc-service a2boot start'
        init_a2boot_stop = 'rc-service a2boot stop'
        init_a2boot_restart = 'rc-service a2boot restart'
    elif 'debian-sysv' in init_style
        init_netatalk_start = 'service netatalk start'
        init_netatalk_stop = 'service netatalk stop'
        init_netatalk_restart = 'service netatalk restart'
        init_atalkd_start = 'service atalkd start'
        init_atalkd_stop = 'service atalkd stop'
        init_atalkd_restart = 'service atalkd restart'
        init_papd_start = 'service papd start'
        init_papd_stop = 'service papd stop'
        init_papd_restart = 'service papd restart'
        init_timelord_start = 'service timelord start'
        init_timelord_stop = 'service timelord stop'
        init_timelord_restart = 'service timelord restart'
        init_a2boot_start = 'service a2boot start'
        init_a2boot_stop = 'service a2boot stop'
        init_a2boot_restart = 'service a2boot restart'
    elif 'freebsd' in init_style
        init_dir_override = get_option('with-init-dir')
        if init_dir_override != ''
            init_dir = init_dir_override
        else
            init_dir = '/usr/local/etc/rc.d'
        endif
        init_netatalk_start = init_dir + '/netatalk start'
        init_netatalk_stop = init_dir + '/netatalk stop'
        init_netatalk_restart = init_dir + '/netatalk restart'
    elif 'macos-launchd' in init_style
        init_netatalk_start = 'netadalkd start'
        init_netatalk_stop = 'netatalkd stop'
        init_netatalk_restart = 'netatalkd restart'
    elif 'netbsd' in init_style
        init_netatalk_start = 'service netatalk onestart'
        init_netatalk_stop = 'service netatalk onestop'
        init_netatalk_restart = 'service netatalk onerestart'
        init_atalkd_start = 'service atalkd onestart'
        init_atalkd_stop = 'service atalkd onestop'
        init_atalkd_restart = 'service atalkd onerestart'
        init_papd_start = 'service papd onestart'
        init_papd_stop = 'service papd onestop'
        init_papd_restart = 'service papd onerestart'
        init_timelord_start = 'service timelord onestart'
        init_timelord_stop = 'service timelord onestop'
        init_timelord_restart = 'service timelord onerestart'
        init_a2boot_start = 'service a2boot onestart'
        init_a2boot_stop = 'service a2boot onestop'
        init_a2boot_restart = 'service a2boot onerestart'
    elif 'openbsd' in init_style
        init_netatalk_start = 'rcctl -d start netatalk'
        init_netatalk_stop = 'rcctl -d stop netatalk'
        init_netatalk_restart = 'rcctl -d reload netatalk'
    elif 'solaris' in init_style
        init_netatalk_start = 'svcadm enable svc:/network/netatalk:default'
        init_netatalk_stop = 'svcadm disable svc:/network/netatalk:default'
        init_netatalk_restart = 'svcadm restart svc:/network/netatalk:default'
    endif

    cdata.set('init_netatalk_start', init_netatalk_start)
    cdata.set('init_netatalk_stop', init_netatalk_stop)
    cdata.set('init_netatalk_restart', init_netatalk_restart)
    cdata.set('init_atalkd_start', init_atalkd_start)
    cdata.set('init_atalkd_stop', init_atalkd_stop)
    cdata.set('init_atalkd_restart', init_atalkd_restart)
    cdata.set('init_papd_start', init_papd_start)
    cdata.set('init_papd_stop', init_papd_stop)
    cdata.set('init_papd_restart', init_papd_restart)
    cdata.set('init_timelord_start', init_timelord_start)
    cdata.set('init_timelord_stop', init_timelord_stop)
    cdata.set('init_timelord_restart', init_timelord_restart)
    cdata.set('init_a2boot_start', init_a2boot_start)
    cdata.set('init_a2boot_stop', init_a2boot_stop)
    cdata.set('init_a2boot_restart', init_a2boot_restart)
endif

configure_file(
    input: 'meson_config.h',
    output: 'config.h',
    configuration: cdata,
)

#########################
# Building the modules  #
#########################

root_includes = include_directories(include_dirs)

subdir('include')
subdir('libatalk')
subdir('bin')
subdir('config')
subdir('etc')
subdir('contrib')
subdir('sys')

if docs_options != []
    subdir('doc')
endif

if 'none' not in init_style
    subdir('distrib')
endif

if get_option('with-tests') or get_option('with-testsuite') or get_option('with-fuzzing')
    subdir('test')
endif

#########################
# Configuration summary #
#########################

# Build environment

summary_info = {
    'Build directory': meson.current_build_dir(),
    'Source path': meson.current_source_dir(),
    'Download dependencies': get_option('wrap_mode') != 'nodownload',
}
summary(summary_info, bool_yn: true, section: 'Build environment:')

# Directories

summary_info = {
    'Installation prefix': get_option('prefix'),
    'Executable directory': bindir,
    'Header file directory': get_option('prefix') / get_option('includedir'),
    'Library directory': libdir,
    'Library executable directory': libexecdir,
    'Manual page directory': mandir,
    'System executable directory': sbindir,
    'Package conf directory': pkgconfdir,
    'Shared state directory': localstatedir,
}
summary(summary_info, bool_yn: true, section: 'Directories:')

# Compilation information

summary_info = {
    'host CPU': cpu,
    'host endianness': build_machine.endian(),
    'C compiler': cc.get_id(),
    'build stype': build_type,
    'Shared or static libraries': get_option('default_library'),
}
summary(summary_info, bool_yn: true, section: 'Compilation:')

# Configuration summary

summary({'Netatalk version': netatalk_version}, section: 'Configuration Summary:')

summary_info = {
    '  Access control': uams_options,
    '  CNID backends': summary_backends,
    '  Default CNID backend': default_backend,
    '  Extended Attributes': netatalk_ea,
    '  Event loop provider': have_libevent ? 'libevent' : 'libev',
    '  Init script style': init_style,
}
summary(summary_info, bool_yn: true, section: '  Options:')

summary_info = {
    '  ClearTxt': true,
    '  DHX': have_libgcrypt,
    '  DHX2': have_libgcrypt,
    '  Guest': true,
    '  Kerberos V': have_krb5_uam,
    '  RandNum': have_libgcrypt,
    '  SRP': have_libgcrypt,
}
summary(summary_info, bool_yn: true, section: '  User Authentication Methods:')

summary_info = {
    '  ACL': have_acls,
    '  AppleTalk': have_appletalk,
    '  Cracklib': have_cracklib,
    '  CUPS': have_cups,
    '  dtrace probes': have_dtrace,
    '  FCE': have_fce,
    '  GSSAPI': have_gssapi,
    '  Kerberos': have_kerberos,
    '  LDAP': have_ldap,
    '  Quota': have_quota,
}
if have_quota
    summary_info += {
        '  Quota provider': quota_provider,
    }
endif
summary_info += {
    '  Spotlight search': have_spotlight,
}
if have_spotlight
    summary_info += {
        '  Spotlight backends': spotlight_backends != '' ? spotlight_backends : 'none',
    }
endif
summary_info += {
    '  TCP wrapper': have_tcpwrap,
    '  Zeroconf': have_zeroconf,
}
if enable_zeroconf
    summary_info += {
        '  Zeroconf provider': zeroconf_provider,
    }
endif
summary(summary_info, bool_yn: true, section: '  Features:')

summary_info = {
    '  dbus daemon path': dbus_daemonpath,
    '  init directory': init_dirs,
    '  lockfile directory': lockfile_path,
    '  PAM config directory': pam_confdir,
    '  Print spool directory': spooldir,
    '  User home basedir': homedir,
}
summary(summary_info, bool_yn: true, section: '  Paths:')

summary_info = {
    '  developer': build_dev_docs,
    '  html manual': build_html_docs,
    '  man pages': build_man_docs,
    '  readmes': build_readme_docs,
}
summary(summary_info, bool_yn: true, section: '  Documentation:')

summary_info = {
    '  afpd integration tests': get_option('with-tests'),
    '  AFP testsuite': get_option('with-testsuite'),
    '  Webmin module': have_webmin,
}
summary(summary_info, bool_yn: true, section: '  Extras:')