Attachment #816082 for bug #852143

Lines 1-8 Link Here

(-)a/attic/wscript (-4 / +9 lines)
1	def build(ctx):	1	def build(ctx):
2	util = [ 'sht',	2	util = [
3	'digest-find', 'clocks', "random",	3	"sht",
4	'digest-timing', 'cmac-timing',	4	"digest-find",
5	'backwards']	5	"clocks",
		6	"random",
		7	"digest-timing",
		8	"cmac-timing",
		9	"backwards",
		10	]
6		11
7	for name in util:	12	for name in util:
8	ctx(	13	ctx(




def build(ctx):

    doc_source = ctx.path.ant_glob("*.adoc", excl="*-body.adoc")

    ctx(
        source=doc_source,

    )

    image_source = []
    ctx.path.get_bld().make_node("hints").mkdir()  # create 'hints' directory
    for dir in ["icons", "pic"]:

        files = ctx.path.ant_glob("%s/*" % dir)  # Find images
        ctx.path.get_bld().make_node(dir).mkdir()  # create 'pic' directory
        image_source += files

        # Copy images

            features="subst",
            is_copy=True,
            source=files,
            target=[ctx.path.find_node(dir).get_bld().make_node(x.name) for x in files],
                    for x in files]
        )

    extra = ["asciidoc.js", "asciidoc.css"]

    # Copy extra files
    ctx(features="subst", is_copy=True, source=extra, target=extra)
        features="subst",
        is_copy=True,
        source=extra,
        target=extra
    )

    # Install HTML
    ctx.install_files(
        "${HTMLDIR}", extra + [x.change_ext(".html").name for x in doc_source]
    )
    ctx.install_files("${HTMLDIR}", image_source, relative_trick=True)




def build(ctx):
    aes_cflags = [
        "-Wno-shadow",
        # '-Wall', '-Wextra', '-Wstrict-prototypes',  # default
        "-Wconversion",
        "-O3",
        "-fomit-frame-pointer",
        "-funroll-loops",
        "-ftree-vectorize",
        "-Wno-inline",  # gcc 10 gives inline warnings?
    ]

    ctx(
        target="aes_siv",
        features="c cstlib",
        includes=[ctx.bldnode.parent.abspath()],
        source="aes_siv.c",
        use="CRYPTO",
        cflags=aes_cflags,
    )





from waflib import Errors, Options
from waflib.Logs import pprint


def build(ctx):

    libntp_source = [

        use="CRYPTO SSL",
    )

    if ctx.env["ntpc"] == "ffi":
        # Loadable FFI stub
        ctx(
            features="c cshlib",

            source=["ntp_c.c", "pymodule-mac.c"] + libntp_source_sharable,
            target="../pylib/ntpc",  # Put the output in the pylib directory
            use="M RT CRYPTO",
            vnum=ctx.env["ntpcver"],
        )
        ctx.add_post_fun(post)
    elif ctx.env["ntpc"] == "ext":
        # Loadable Python extension
        ctx(
            features="c cshlib pyext",
            install_path="${PYTHONARCHDIR}/ntp",
            includes=[ctx.bldnode.parent.abspath(), "../include"],
            source=["pymodule.c", "pymodule-mac.c"] + libntp_source_sharable,
            target="../pylib/ntpc",  # Put the output in the pylib directory
            use="M RT CRYPTO",
        )
    elif "none" == ctx.env["ntpc"]:
        return


def post(ctx):
    if not (ctx.cmd == "install" and ctx.env.BIN_LDCONFIG):
        return

    destdir = Options.options.destdir


    # Try to run ldconfig.  It is not a fatal error here if it fails, as the
    # install could be run by a non-root user.
    ldconfig = " ".join(ctx.env.BIN_LDCONFIG)
    try:
        out = ctx.cmd_and_log(
            ctx.env.BIN_LDCONFIG,
            output=waflib.Context.STDOUT,
            quiet=waflib.Context.BOTH,
        )
        pprint("GREEN", "running: %s  OK" % ldconfig)
    except Errors.WafError as e:
        pprint("RED", "running: %s  FAILED" % ldconfig)

Lines 1-4 Link Here

(-)a/ntpd/wscript (-20 / +22 lines)
1
2	def build(ctx):	1	def build(ctx):
3	bldnode = ctx.bldnode.abspath()	2	bldnode = ctx.bldnode.abspath()
4		3
Lines 15-21 def build(ctx): Link Here
15	# Generate Bison file first.	14	# Generate Bison file first.
16	ctx.add_group()	15	ctx.add_group()
17		16
18	keyword_gen_source = ["keyword-gen.c", ]	17	keyword_gen_source = [
		18	"keyword-gen.c",
		19	]
19		20
20	ctx(	21	ctx(
21	features="c cprogram",	22	features="c cprogram",
Lines 35-41 def build(ctx): Link Here
35	features="c",	36	features="c",
36	rule="%s/ntpd/keyword-gen ${SRC} > ${TGT}" % bldnode,	37	rule="%s/ntpd/keyword-gen ${SRC} > ${TGT}" % bldnode,
37	source="ntp_parser.tab.h",	38	source="ntp_parser.tab.h",
38	target="ntp_keyword.h"	39	target="ntp_keyword.h",
39	)	40	)
40		41
41	# Make sure ntp_keyword.h is created last.	42	# Make sure ntp_keyword.h is created last.
Lines 47-66 def build(ctx): Link Here
47	"ntp_control.c",	48	"ntp_control.c",
48	"ntp_filegen.c",	49	"ntp_filegen.c",
49	"ntp_leapsec.c",	50	"ntp_leapsec.c",
50	"ntp_monitor.c", # Needed by the restrict code	51	"ntp_monitor.c", # Needed by the restrict code
51	"ntp_recvbuff.c",	52	"ntp_recvbuff.c",
52	"ntp_restrict.c",	53	"ntp_restrict.c",
53	"ntp_util.c",	54	"ntp_util.c",
54	]	55	]
55		56
56	if not ctx.env.DISABLE_NTS:	57	if not ctx.env.DISABLE_NTS:
57	libntpd_source += [	58	libntpd_source += [
58	"nts.c",	59	"nts.c",
59	"nts_server.c",	60	"nts_server.c",
60	"nts_client.c",	61	"nts_client.c",
61	"nts_cookie.c",	62	"nts_cookie.c",
62	"nts_extens.c",	63	"nts_extens.c",
63	]	64	]
64		65
65	ctx(	66	ctx(
66	features="c",	67	features="c",
Lines 77-88 def build(ctx): Link Here
77	# use="libntpd_obj bison_obj",	78	# use="libntpd_obj bison_obj",
78	)	79	)
79		80
80	use_refclock = "" # XXX: there must be a better way to do this	81	use_refclock = "" # XXX: there must be a better way to do this
81	if ctx.env.REFCLOCK_ENABLE:	82	if ctx.env.REFCLOCK_ENABLE:
82		83
83	refclock_source = ["ntp_refclock.c",	84	refclock_source = ["ntp_refclock.c", "refclock_conf.c"]
84	"refclock_conf.c"
85	]
86		85
87	ctx(	86	ctx(
88	target="refclock",	87	target="refclock",
Lines 117-135 def build(ctx): Link Here
117	"ntp_timer.c",	116	"ntp_timer.c",
118	"ntp_dns.c",	117	"ntp_dns.c",
119	"ntpd.c",	118	"ntpd.c",
120	ctx.bldnode.parent.find_node("host/ntpd/ntp_parser.tab.c")	119	ctx.bldnode.parent.find_node("host/ntpd/ntp_parser.tab.c"),
121	]	120	]
122		121
123	ctx(	122	ctx(
124	features="c rtems_trace cprogram",	123	features="c rtems_trace cprogram",
125	includes=[	124	includes=[
126	ctx.bldnode.parent.abspath(), "../include",	125	ctx.bldnode.parent.abspath(),
127	"%s/host/ntpd/" % ctx.bldnode.parent.abspath(), "." ],	126	"../include",
128	install_path='${SBINDIR}',	127	"%s/host/ntpd/" % ctx.bldnode.parent.abspath(),
		128	".",
		129	],
		130	install_path="${SBINDIR}",
129	source=ntpd_source,	131	source=ntpd_source,
130	target="ntpd",	132	target="ntpd",
131	use="libntpd_obj ntp M parse RT CAP SECCOMP PTHREAD NTPD "	133	use="libntpd_obj ntp M parse RT CAP SECCOMP PTHREAD NTPD "
132	"CRYPTO SSL DNS_SD %s SOCKET NSL SCF" % use_refclock,	134	"CRYPTO SSL DNS_SD %s SOCKET NSL SCF" % use_refclock,
133	)	135	)
134		136
135	ctx.manpage(8, "ntpd-man.adoc")	137	ctx.manpage(8, "ntpd-man.adoc")




def build(ctx):
    frob_sources = [
        "main.c",
        "bumpclock.c",
        "dump.c",
        "jitter.c",
        "precision.c",
        "pps-api.c",
        "tickadj.c",
    ]

    ctx(
        features="c cprogram",
        includes=[ctx.bldnode.parent.abspath(), "../include"],
        install_path="${BINDIR}",
        source=frob_sources,
        target="ntpfrob",
        use="M RT",

Lines 6-14 def build(ctx): Link Here

(-)a/ntptime/wscript (-1 / +2 lines)
6	includes=[ctx.bldnode.parent.abspath(), "../include"],	6	includes=[ctx.bldnode.parent.abspath(), "../include"],
7	source=["ntptime.c"],	7	source=["ntptime.c"],
8	use="ntp M RT",	8	use="ntp M RT",
9	install_path='${BINDIR}',	9	install_path="${BINDIR}",
10	)	10	)
11		11
12	ctx.manpage(8, "ntptime-man.adoc")	12	ctx.manpage(8, "ntptime-man.adoc")
13		13
		14
14	# end	15	# end

Line 0 Link Here

(-)a/pylib/version.txt.in (+1 lines)
	1	ntpsec-@NTPSEC_VERSION_EXTENDED@






def options(opt):
    opt.load("python")


def configure(conf):
    if conf.env["ntpc"] == "none":
        return
    conf.load("python")

    if not conf.env.ENABLE_CROSS:
        conf.check_python_version((2, 6, 0))
    conf.check_python_headers(features="pyext")  # Extension-only
    try:
        conf.check_python_module("curses")
        conf.env["PYTHON_CURSES"] = True
    except conf.errors.ConfigurationError:
        pprint(
            "YELLOW",
            "WARNING: ntpmon will not be built/installed since "
            "python curses module was not found",
        )
    try:
        conf.check_python_module("argparse")
        conf.env["PYTHON_ARGPARSE"] = True
    except conf.errors.ConfigurationError:
        pprint(
            "YELLOW",
            "WARNING: ntploggps, ntplogtemp, and ntpviz will not "
            "be built/installed since python argparse module was not found",
        )
    try:
        conf.check_python_module("gps", condition="ver >= num(3, 18)")
        conf.env["PYTHON_GPS"] = True
    except conf.errors.ConfigurationError:
        pprint(
            "YELLOW",
            "WARNING: ntploggps will not be built/installed"
            " since python gps module >= 3.18 was not found",
        )


def build(ctx):
    ctx(features="subst", source=["version.txt.in"], target=['version.txt'])
    if ctx.env["ntpc"] == "none":
        return
    srcnode = ctx.srcnode.make_node("pylib")
    bldnode = ctx.bldnode.make_node("pylib")
    target1 = bldnode.make_node("control.py")
    target2 = bldnode.make_node("magic.py")

    sources = []
    if ctx.env["ntpc"] == "ext":
        sources = srcnode.ant_glob("*.py", excl="ntpc.py")
    elif ctx.env["ntpc"] == "ffi":
        sources = srcnode.ant_glob("*.py")
    builds = [x.get_bld() for x in sources]

    # The rm's here were added to fix a reported (but underdocumented) problem

    # including during 'install'. They are now disabled but retained as a
    # comment.

    # # Remove generated files to ensure they are properly updated
    # ctx.exec_command("rm -f %s" % target1.abspath())
    # ctx.exec_command("rm -f %s" % target2.abspath())

    if ctx.env["ntpc"] is None:
        return

    # Make sure Python sees .py as well as .pyc/.pyo
    ctx(
        features="subst",

    )

    ctx(
        before=["pyc", "pyo"],
        cwd=srcnode,
        rule="${PYTHON} ${SRC} >${TGT}",
        source=["../wafhelpers/pythonize-header", "../include/ntp_control.h"],
        target=target1,
    )

    ctx(
        before=["pyc", "pyo"],
        cwd=srcnode,
        rule="${PYTHON} ${SRC} >${TGT}",
        source=["../wafhelpers/pythonize-header", "../include/ntp.h"],
        target=target2,
    )

    ctx.add_group()

    ctx(
        features="py",
        source=builds + [target1, target2],
        install_from=bldnode,
        install_path="${PYTHONARCHDIR}/ntp",
    )

    # pep241  lay an egg
    egg = ["ntp-%s.egg-info" % ctx.env.NTPSEC_VERSION]
    ctx(features="subst", source=["ntp-in.egg-info"], target=egg)
        features="subst",
        source=['ntp-in.egg-info'],
        target=egg
    )
    ctx.install_files(ctx.env.PYTHONARCHDIR, egg)






def build(ctx):
    testsrc = ctx.srcnode.make_node('tests')
    pylib = ctx.srcnode.make_node('pylib')
    testpylib = testsrc.make_node('pylib')
    testpysrc = testpylib.ant_glob('*.py')

    # Unity source
    unity_source = [
        "unity/unity.c",


    unity_config = ["UNITY_INCLUDE_DOUBLE", "UNITY_SUPPORT_64"]

    ctx(defines=unity_config, features="c", target="unity", source=unity_source)
        defines=unity_config,
        features="c",
        target="unity",
        source=unity_source
    )

    # Test main.
    common_source = [

        "libntp/strtolfp.c",
        "libntp/timespecops.c",
        "libntp/vi64ops.c",
        "libntp/ymd2yd.c",
    ] + common_source

    ctx.ntp_test(

    ] + common_source

    if not ctx.env.DISABLE_NTS:
        ntpd_source += [
            "ntpd/nts.c",
            "ntpd/nts_client.c",
            "ntpd/nts_server.c",
            "ntpd/nts_cookie.c",
            "ntpd/nts_extens.c",
        ]

    ctx.ntp_test(
        defines=unity_config + ["TEST_NTPD=1"],
        features="c cprogram test",
        includes=[
            ctx.bldnode.parent.abspath(),
            "../include",
            "unity",
            "../ntpd",
            "common",
            "../libaes_siv",
        ],
        install_path=None,
        source=ntpd_source,
        target="test_ntpd",
        use="ntpd_lib libntpd_obj unity ntp aes_siv " "M PTHREAD CRYPTO RT SOCKET NSL",
            "M PTHREAD CRYPTO RT SOCKET NSL",
    )

    if "none" == ctx.env["ntpc"]:
        return
    testsrc = ctx.srcnode.make_node("tests")
    pylib = ctx.srcnode.make_node("pylib")
    testpylib = testsrc.make_node("pylib")
    testpysrc = testpylib.ant_glob("*.py")
    testpylib.get_bld().mkdir()

    pypath = pylib.get_bld()
    targdir = "tests/pylib"
    linkpath = ctx.bldnode.make_node(targdir + "/ntp").abspath()
    relpath = ("../" * (targdir.count("/") + 1)) + pypath.path_from(ctx.bldnode)
    if (not os.path.exists(linkpath)) or os.readlink(linkpath) != relpath:
        try:
            os.remove(linkpath)

            pass
        os.symlink(relpath, linkpath)

    pytests = [
        "pylib/test_util.py",
        "pylib/test_agentx.py",
        "pylib/test_agentx_packet.py",
        "pylib/test_ntpc.py",
        "pylib/test_packet.py",
        "pylib/test_statfiles.py",
    ]

    ctx(
        features="subst",




from __future__ import print_function
import os
import os.path

# import sys
import waflib.Context
import waflib.Logs
import waflib.Utils

    ("main/ntpclients/ntpleapfetch", "--version"): "ntpleapfetch %s\n",
    ("main/ntpd/ntpd", "--version"): "ntpd %s\n",
    ("main/ntpfrob/ntpfrob", "-V"): "ntpfrob %s\n",
    ("main/ntptime/ntptime", "-V"): "ntptime %s\n",
}
cmd_map_python = {
    ("main/ntpclients/ntpdig", "--version"): "ntpdig %s\n",

    ("main/ntpclients/ntpsnmpd", "--version"): "ntpsnmpd %s\n",
    ("main/ntpclients/ntpsweep", "--version"): "ntpsweep %s\n",
    ("main/ntpclients/ntptrace", "--version"): "ntptrace %s\n",
    ("main/ntpclients/ntpwait", "--version"): "ntpwait %s\n",
}
# Need argparse
cmd_map_python_argparse = {

        addLog("YELLOW", prefix + " SKIPPING (does not exist)")
        return False

    envy = {}
    if python:
        cmd = python + list(cmd)
        envy = {"PYTHONPATH": waflib.Context.out_dir + "/main/tests/pylib"}
    p = Popen(
        cmd,
        env=envy,
        universal_newlines=True,
        stdin=waflib.Utils.subprocess.PIPE,
        stdout=waflib.Utils.subprocess.PIPE,
        stderr=waflib.Utils.subprocess.PIPE,
        cwd=waflib.Context.out_dir,
    )

    stdout, stderr = p.communicate()


        addLog("GREEN", prefix + "  OK")
        return True
    addLog("RED", prefix + "  FAILED")
    addLog("PINK", "Expected: '%s'" % expected)
    if stdout:
        addLog("PINK", "Got (stdout): '%s'" % stdout)
    if stderr:
        addLog("PINK", "Got (stderr): '%s'" % stderr)
    return False


def cmd_bin_test(ctx):
    """Run a suite of binary tests."""
    fails = 0
    with open(waflib.Context.out_dir + "/main/pylib/version.txt") as fp:
        version = fp.read().strip(' \n')

    if not os.path.isdir(waflib.Context.out_dir + "/main/tests/pylib"):
        if ctx.env["PYTHON_ARGPARSE"]:
            cmd_map_python.update(cmd_map_python_argparse)
        if ctx.env["PYTHON_CURSES"]:
            cmd_map_python.update(cmd_map_python_curses)
        for cmd in sorted(cmd_map_python):
            if not run(cmd, cmd_map_python[cmd] % version, ctx.env["PYTHON"]):
                fails += 1
    version = p.communicate()[0].rstrip()

    if ctx.env['PYTHON_ARGPARSE']:
        cmd_map_python.update(cmd_map_python_argparse)

    if ctx.env['PYTHON_CURSES']:
        cmd_map_python.update(cmd_map_python_curses)

    for cmd in sorted(cmd_map):
        if not run(cmd, cmd_map[cmd] % version):
            fails += 1

    for cmd in sorted(cmd_map_python):
        if not run(cmd, cmd_map_python[cmd] % version, ctx.env['PYTHON']):
            fails += 1

    if 1 == fails:
        bin_test_summary(ctx)
        ctx.fatal("1 binary test failed!")




from __future__ import print_function

# from datetime import datetime
import itertools
import os
import shlex
import sys

# import time

from waflib import Build
from waflib import Context
from waflib import Scripting
from waflib import Utils
from waflib.Build import (
    BuildContext,
    CleanContext,
    InstallContext,
    StepContext,
    ListContext,
)
from waflib.Context import BOTH
from waflib.Errors import WafError
from waflib.Logs import pprint


pprint.__doc__ = None

APPNAME = "ntpsec"

out = "build"

config = {"out": out, "OPT_STORE": {}}
    "out": out,
    "OPT_STORE": {}
}


def help(ctx):
    "Be helpful, give a usage"
    print(
        """
Usage: waf <command>
    build       Build the project
    check       Run tests

    loccount    Show SLOC count of the source tree
    uninstall   Uninstall the project

"""
    )


def options(ctx):
    options_cmd(ctx, config)
    ctx.load("asciidoc", tooldir="wafhelpers/")
    ctx.recurse("pylib")


def configure(ctx):
    ctx.load("asciidoc", tooldir="wafhelpers/")

    class oc(Build.BuildContext):
        cmd = "oc"

        def exec_command(self, cmd, **kw):
            kw["output"] = BOTH
            try:
                err, out = self.cmd_and_log(cmd, **kw)
            except WafError as e:
                self.logger.debug("WafError")
                return e.returncode
            if len(out) and any(
                word in out
                for word in [
                    "err",
                    "err:",
                    "error",
                    "error:",
                    "ignored",
                    "illegal",
                    "unknown",
                    "unrecognized",
                    "warning",
                ]
            ):
                self.logger.debug("noooo %r" % out)
                return 1
            if err:
                self.logger.debug("noooo %r" % err)
                return 1
            return 0


    srcnode = ctx.srcnode.abspath()
    bldnode = ctx.bldnode.abspath()

    ctx.run_build_cls = "check"
    ctx.load("waf", tooldir="wafhelpers/")
    ctx.load("waf_unit_test")
    ctx.load("gnu_dirs")

    with open("VERSION", "r") as f:
        ntpsec_release = f.read().split(" ")[0].strip()

            opt = flag.replace("--", "").upper()
            opt_map[opt] = ctx.env.OPT_STORE[flag]

    ctx.env["ntpc"] = ctx.options.enable_pylib
    ctx.env["ntpcver"] = "1.1.0"

    msg("--- Configuring host ---")
    ctx.setenv("host", ctx.env.derive())

    ctx.load("compiler_c")
    ctx.start_msg("Checking compiler version")
    ctx.end_msg("%s" % ".".join(ctx.env.CC_VERSION))

    # Some distros do not have /sbin in the PATH for non-root users.  We honor
    # the real PATH first, but append the sbin directories.
    ctx.find_program(
        "ldconfig",
        var="BIN_LDCONFIG",
        mandatory=False,
        path_list=(
            os.environ.get("PATH", "").split(os.pathsep)
            + ["/sbin", "/usr/sbin", "/usr/local/sbin"]
        ),
    )

    # Ensure m4 is present, or bison will fail with SIGPIPE
    ctx.find_program("m4")
    ctx.load("bison")

    for opt in opt_map:
        ctx.env[opt] = opt_map[opt]

    if ctx.options.enable_rtems_trace:
        ctx.find_program(
            "rtems-tld",
            var="BIN_RTEMS_TLD",
            path_list=[ctx.options.rtems_trace_path, "${BINDIR}"],
        )
        ctx.env.RTEMS_TEST_ENABLE = True
        ctx.env.RTEMS_TEST_FLAGS = [
            "-C",
            "%s/devel/trace/ntpsec-trace.ini" % srcnode,
            "-W",
            "%s/ntpsec-wrapper" % bldnode,
            "-P",
            "%s/devel/trace/" % srcnode,
            "-f",
            "-I%s" % bldnode,
            "-f",
            "-I%s/include/" % srcnode,
        ]

    # Not needed to build.  Used by utility scripts.

    ctx.find_program("sh", var="BIN_SH", mandatory=False)

    ctx.check_cfg(
        package="systemd",
        variables=["systemdsystemunitdir"],
        uselib_store="SYSTEMD",
        mandatory=False,
        msg="Checking for systemd",
    )
    if ctx.env.SYSTEMD_systemdsystemunitdir:
        ctx.start_msg("systemd unit directory:")
        ctx.end_msg(ctx.env.SYSTEMD_systemdsystemunitdir)


    build_desc = ctx.options.build_desc.strip()
    if build_desc:
        build_desc = " " + build_desc
    if ctx.env.BIN_GIT:
        # 'tag', '7', and 'deadbeef' are fill ins for
        # a previous tag (always dropped), commits since that tag,

        # 3-4 gets the first token dropped and the rest added
        # I have never seen 5+ tokens, we should be safe
        cmd = ctx.env.BIN_GIT + shlex.split("describe --tags --dirty --always")
        git_short_hash = ctx.cmd_and_log(cmd).strip().split("-")
        clip = 1 if len(git_short_hash) > 2 else 0
        git_short_hash = "-".join(git_short_hash[clip:])

        ctx.env.NTPSEC_VERSION = "%s+" % ntpsec_release
        ctx.env.NTPSEC_VERSION_EXTENDED = "%s+%s%s" % (
            ntpsec_release,
            git_short_hash,
            build_desc,
        )
    else:
        ctx.env.NTPSEC_VERSION = "%s" % ntpsec_release
        ctx.env.NTPSEC_VERSION_EXTENDED = "%s%s" % (ntpsec_release, build_desc)
                                                      build_desc))
    ctx.define("NTPSEC_VERSION", ctx.env.NTPSEC_VERSION)
    ctx.define("NTPSEC_VERSION_EXTENDED", ctx.env.NTPSEC_VERSION_EXTENDED)


        ctx.env.ENABLE_CROSS = True

        ctx.start_msg("Using Cross compiler CC:")
        #           ctx.get_cc_version(ctx.env.CC, gcc=True)
        ctx.end_msg(ctx.options.cross_compiler)

        ctx.env.CC = shlex.split(ctx.options.cross_compiler)


    if ctx.options.list:
        from wafhelpers.refclock import refclock_map

        print("ID    Description")
        print("~~    ~~~~~~~~~~~")
        for id in refclock_map:

        ctx.define("WORDS_BIGENDIAN", 1)

    if ctx.options.enable_leap_testing:
        ctx.define(
            "ENABLE_LEAP_TESTING",
            1,
            comment="Enable leap seconds on other than 1st of month.",
        )

    # check for some libs first.  some options, like stack protector,
    # may depend on some libs, like -lssp
    ctx.check_cc(lib="m", comment="Math library")
    ctx.check_cc(lib="rt", mandatory=False, comment="realtime library")
    ctx.check_cc(lib="pthread", mandatory=False, comment="threads library")
    ctx.check_cc(lib="execinfo", mandatory=False, comment="BSD backtrace library")
    ret = ctx.check_cc(lib="bsd", mandatory=False, comment="BSD compatibility library")
    ret = ctx.check_cc(lib="bsd", mandatory=False,
                       comment="BSD compatibility library")
    if ret:
        ctx.env.LDFLAGS += ["-lbsd"]

    # -lssp and -lssp_nonshared may be needed by older gcc to
    # support "-fstack-protector-all"
    ret = ctx.check_cc(lib="ssp", mandatory=False, comment="libssp")
                       comment="libssp")
    if ret:
        ctx.env.LDFLAGS += ["-lssp"]

    ret = ctx.check_cc(lib="ssp_nonshared", mandatory=False, comment="libssp_nonshared")
                       comment="libssp_nonshared")
    if ret:
        ctx.env.LDFLAGS += ["-lssp_nonshared"]

    cc_test_flags = [
        ("f_stack_protector_all", "-fstack-protector-all"),
        ("PIC", "-fPIC"),
        ("PIE", "-pie -fPIE"),
        # this quiets most of macOS warnings on -fpie
        ("unused", "-Qunused-arguments"),
        # This is a useless warning on any architecture with a barrel
        # shifter, which includes Intel and ARM and basically
        # everything nowadays. Even so, we'd enable it out of

        # useful for forcing structure alignment in order to suppress
        # it locally don't seem to be working quite right.
        # ('w_cast_align', "-Wcast-align"),
        ("w_cast_qual", "-Wcast-qual"),
        ("w_disabled_optimization", "-Wdisabled-optimization"),
        ("w_float_equal", "-Wfloat-equal"),
        ("w_format", "-Wformat"),
        ("w_format_security", "-Wformat-security"),
        # fails on OpenBSD 6
        ("w_format_signedness", "-Wformat-signedness"),
        ("w_implicit_function_declaration", "-Wimplicit-function-declaration"),
        ("w_init_self", "-Winit-self"),
        ("w_invalid_pch", "-Winvalid-pch"),
        ("w_missing_declarations", "-Wmissing-declarations"),
        ("w_multichar", "-Wmultichar"),
        ("w_packed", "-Wpacked"),
        ("w_pointer_arith", "-Wpointer-arith"),
        ("w_shadow", "-Wshadow"),
        # fails on clang
        ("w_suggest_attribute_noreturn", "-Wsuggest-attribute=noreturn"),
        ("w_write_strings", "-Wwrite-strings"),
    ]

    # Check which linker flags are supported
    ld_hardening_flags = [
        ("z_now", "-Wl,-z,now"),  # no deferred symbol resolution
    ]

    # we prepend our options to CFLAGS, this allows user provided

    else:
        # not gdb debugging
        cc_test_flags += [
            ("LTO", "-flto"),  # link time optimization
        ]
        ld_hardening_flags += [
            ("stripall", "-Wl,--strip-all"),  # Strip binaries
        ]

    if ctx.options.enable_debug:
        ctx.define("DEBUG", 1, comment="Enable debug mode")

            # "-Wcast-align",         # fails on RasPi, needs fixing.
            # "-Wbad-function-cast",  # ntpd casts long<->double a lot
            # "-Wformat-nonliteral",  # complains about a used feature
            "-Winline",  # some OS have inline issues.
            # "-Wmissing-format-attribute", # false positives
            # "-Wnested-externs",     # incompatible w/ Unity...
            # "-Wpadded",             # duck... over 3k warnings
            # "-Wredundant-decls",    # incompatible w/ Unity
            "-Wswitch-default",  # warns on Bison bug
        ] + ctx.env.CFLAGS
        cc_test_flags += [
            ("w_implicit_fallthru", "-Wimplicit-fallthrough=3"),
            # Fails on Solaris, OpenBSD 6, and RasPi
            # Complains about a Bison bug
            # Cannot be suppressed

            # ('w_suggest_attribute_const', "-Wsuggest-attribute=const"),
            # fails on clang, lot's of false positives and Unity complaints
            # ('w_suggest_attribute_pure', "-Wsuggest-attribute=pure"),
        ]

    ctx.env.CFLAGS = [
        # -O1 will turn on -D_FORTIFY_SOURCE=2 for us

        "-Wstrict-prototypes",
        "-Wundef",
        "-Wunused",
    ] + ctx.env.CFLAGS

    # gotta be tricky to test for -Wsuggest-attribute=const
    FRAGMENT = """
int tmp;
int main(int argc, char **argv) {
        (void)argc; (void)argv;
        tmp = argc;
        return argc;
}
"""

    # check if C compiler supports some flags
    old_run_build_cls = ctx.run_build_cls
    ctx.run_build_cls = "oc"
    for (name, ccflag) in cc_test_flags:
        ctx.check(
            cflags=ccflag,
            define_name="HAS_" + name,
            fragment=FRAGMENT,
            mandatory=False,
            msg="Checking if C compiler supports " + ccflag,
            run_build_cls="oc",
        )

    ctx.run_build_cls = old_run_build_cls


    if ctx.env.HAS_PIE:
        ctx.env.LINKFLAGS_NTPD += [
            "-pie",
        ]
        ctx.env.CFLAGS_bin = ["-fPIE", "-pie"] + ctx.env.CFLAGS
        ld_hardening_flags += [
            ("relro", "-Wl,-z,relro"),  # hardening, marks some read only,
        ]

    if ctx.env.HAS_unused:
        ctx.env.CFLAGS = ["-Qunused-arguments"] + ctx.env.CFLAGS

    # XXX: -flto currently breaks link of ntpd
    if ctx.env.HAS_LTO and False:


    # debug warnings that are not available with all compilers
    if ctx.env.HAS_w_implicit_fallthru:
        ctx.env.CFLAGS = ["-Wimplicit-fallthrough=3"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_suggest_attribute_const:
        ctx.env.CFLAGS = ["-Wsuggest-attribute=const"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_suggest_attribute_noreturn:
        ctx.env.CFLAGS = ["-Wsuggest-attribute=noreturn"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_suggest_attribute_pure:
        ctx.env.CFLAGS = ["-Wsuggest-attribute=pure"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_format_security:
        ctx.env.CFLAGS = ["-Wformat-security"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_format_signedness:
        ctx.env.CFLAGS = ["-Wformat-signedness"] + ctx.env.CFLAGS
    # should be before other -Wformat-* in CFLAGS
    if ctx.env.HAS_w_format:
        ctx.env.CFLAGS = ["-Wformat"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_float_equal:
        ctx.env.CFLAGS = ["-Wfloat-equal"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_init_self:
        ctx.env.CFLAGS = ["-Winit-self"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_write_strings:
        ctx.env.CFLAGS = ["-Wwrite-strings"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_pointer_arith:
        ctx.env.CFLAGS = ["-Wpointer-arith"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_invalid_pch:
        ctx.env.CFLAGS = ["-Winvalid-pch"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_implicit_function_declaration:
        ctx.env.CFLAGS = ["-Wimplicit-function-declaration"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_disabled_optimization:
        ctx.env.CFLAGS = ["-Wdisabled-optimization"] + ctx.env.CFLAGS
    # if ctx.env.HAS_w_cast_align:
    #     ctx.env.CFLAGS = ['-Wcast-align'] + ctx.env.CFLAGS
    if ctx.env.HAS_w_missing_declarations:
        ctx.env.CFLAGS = ["-Wmissing-declarations"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_cast_qual:
        ctx.env.CFLAGS = ["-Wcast-qual"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_packed:
        ctx.env.CFLAGS = ["-Wpacked"] + ctx.env.CFLAGS
    if ctx.env.HAS_w_shadow:
        ctx.env.CFLAGS = ["-Wshadow"] + ctx.env.CFLAGS
    # if ctx.env.HAS_w_sign_conversion:
    #     ctx.env.CFLAGS = ['-Wsign-conversion'] + ctx.env.CFLAGS
    if ctx.env.HAS_f_stack_protector_all:
        ctx.env.CFLAGS = ["-fstack-protector-all"] + ctx.env.CFLAGS

    # old gcc takes -z,relro, but then barfs if -fPIE available and used.
    # ("relro", "-Wl,-z,relro"), # marks some sections read only
    old_run_build_cls = ctx.run_build_cls
    ctx.run_build_cls = "oc"
    for (name, ldflag) in ld_hardening_flags:
        ctx.check(
            define_name="HAS_" + name,
            fragment=FRAGMENT,
            ldflags=ldflag,
            mandatory=False,
            msg="Checking if linker supports " + ldflag,
            run_build_cls="oc",
        )
        if ctx.env["HAS_" + name]:
            ctx.env.LDFLAGS += [ldflag]

    ctx.run_build_cls = old_run_build_cls

            #    ] + ctx.env.CFLAGS
            ctx.env.LDFLAGS += [
                "-Wl,-z,relro",  # hardening, marks some section read only,
            ]
    # else:  # gcc, probably

    # Exclude Unity's support for printing floating point numbers
    # since it triggers warnings
    # with -Wfloat-equal
    ctx.env.CFLAGS = ["-DUNITY_EXCLUDE_FLOAT_PRINT"] + ctx.env.CFLAGS

    # XXX: hack
    if ctx.env.DEST_OS in ["freebsd"]:
        ctx.env.INCLUDES = ["/usr/local/include"]
        ctx.env.LIBPATH = ["/usr/local/lib"]
        if os.path.isdir("/usr/local/ssl/"):
            # This assumes OpenSSL is the only thing that was in /usr/local/
            ctx.env.INCLUDES = ["/usr/local/ssl/include"]
            ctx.env.LIBPATH = ["/usr/local/ssl/lib"]
    elif ctx.env.DEST_OS == "netbsd" and os.path.isdir("/usr/pkg/include"):
        ctx.env.INCLUDES = ["/usr/pkg/include"]
        ctx.env.LIBPATH = ["/usr/pkg/lib"]
        ctx.env.LDFLAGS += ["-rpath=/usr/pkg/lib"]
        if os.path.isdir("/usr/local/ssl/"):
            # This assumes OpenSSL is the only thing that was in /usr/pkg/
            ctx.env.INCLUDES = ["/usr/local/ssl/include"]
            ctx.env.LIBPATH = ["/usr/local/ssl/lib"]
    elif ctx.env.DEST_OS == "linux" and os.path.isdir("/usr/local/ssl/"):
        # This supports building OpenSSL from source
        # That allows using OpenSSL 1.1.1 on older CentOS

        # see HOWTO-OpenSSL
        ctx.env.INCLUDES = ["/usr/local/ssl/include"]
        if os.path.isdir("/usr/local/ssl/lib64/"):
            ctx.env.LIBPATH = ["/usr/local/ssl/lib64"]
        else:
            ctx.env.LIBPATH = ["/usr/local/ssl/lib"]
    elif ctx.env.DEST_OS == "darwin":
        # macports location
        if os.path.isdir("/opt/local/include"):

        if os.path.isdir("/opt/local/lib"):
            ctx.env.LIBPATH = ["/opt/local/lib"]
        # OS X needs this for IPv6
        ctx.define("__APPLE_USE_RFC_3542", 1, comment="Needed for IPv6 support")
                   comment="Needed for IPv6 support")
    elif ctx.env.DEST_OS == "sunos":
        # Declare compatibility with the POSIX.1-2001 standard, and any
        # headers/interfaces not in conflict with that standard

        ctx.define("__EXTENSIONS__", "1", quote=False)

    # Borrowed from waf-1.9, when type_name and field_name were valid keywords
    SNIP_TYPE = """
    int main(int argc, char **argv) {
        (void)argc; (void)argv;
        if ((%(type_name)s *) 0) return 0;
        if (sizeof (%(type_name)s)) return 0;
        return 1;
    }
    """

    SNIP_FIELD = """
    #include <stddef.h>
    int main(int argc, char **argv) {
        char *off;

        off = (char*) &((%(type_name)s*)0)->%(field_name)s;
        return (size_t) off < sizeof(%(type_name)s);
    }
    """

    def to_header(header_name):
        return "".join(["#include <%s>\n" % x for x in Utils.to_list(header_name)])
                       x for x in Utils.to_list(header_name)])

    structures = (
        ("struct if_laddrconf", ["sys/types.h", "net/if6.h"], False),

    )
    for (s, h, r) in structures:
        ctx.check_cc(
            fragment=to_header(h) + SNIP_TYPE % {"type_name": s},
            msg="Checking for type %s" % s,
            define_name=ctx.have_define(s.upper()),
            mandatory=r,
        )

    )
    for (s, f, h) in structure_fields:
        ctx.check_cc(
            fragment=(to_header(h) + SNIP_FIELD % {"type_name": s, "field_name": f}),
            msg="Checking for field %s in %s" % (f, s),
            define_name=ctx.have_define((s + "_" + f).upper()),
            define_name=ctx.have_define((s + '_' + f).upper()),
            mandatory=False,
        )

    # mostly used by timetoa.h and timespecops.h
    sizeofs = [
        ("time.h", "time_t"),
        (None, "long"),
    ]

    for header, sizeof in sorted(sizeofs, key=lambda x: x[1:]):

    if not ctx.options.disable_nts:
        # Check via pkg-config first, then fall back to a direct search
        if not ctx.check_cfg(
            package="libssl",
            uselib_store="SSL",
            args=["--cflags", "--libs"],
            msg="Checking for OpenSSL/libssl (via pkg-config)",
            define_name="",
            mandatory=False,
        ):
            ctx.check_cc(
                msg="Checking for OpenSSL's ssl library", lib="ssl", mandatory=True
            )

    # Check via pkg-config first, then fall back to a direct search
    if not ctx.check_cfg(
        package="libcrypto",
        uselib_store="CRYPTO",
        args=["--cflags", "--libs"],
        msg="Checking for OpenSSL/libcrypto (via pkg-config)",
        define_name="",
        mandatory=False,
    ):
        ctx.check_cc(
            msg="Checking for OpenSSL's crypto library", lib="crypto", mandatory=True
        )

    # Optional functions.  Do all function checks here, otherwise
    # we're likely to duplicate them.
    optional_functions = (
        ("_Unwind_Backtrace", ["unwind.h"]),
        ("adjtimex", ["sys/time.h", "sys/timex.h"]),
        ("backtrace_symbols_fd", ["execinfo.h"]),
        ("ntp_adjtime", ["sys/time.h", "sys/timex.h"]),  # BSD
        ("ntp_gettime", ["sys/time.h", "sys/timex.h"]),  # BSD
        ("res_init", ["netinet/in.h", "arpa/nameser.h", "resolv.h"]),
        ("strlcpy", ["string.h"]),
        ("strlcat", ["string.h"]),
        ("timegm", ["time.h"]),
        # Hack.  It's not a function, but this works.
        ("PRIV_NTP_ADJTIME", ["sys/priv.h"]),  # FreeBSD
    )
    for ft in optional_functions:
        probe_function(ctx, function=ft[0], prerequisites=ft[1])

    # Sanity checks to give a sensible error message
    required_functions = (
        # MacOS doesn't have timer_create ??
        ("timer_create", ["signal.h", "time.h"], "RT", False),
        # Very old versions of OpenSSL don't have cmac.h
        #  We could add ifdefs, but old crypto is deprecated in favor of CMAC
        #  and so far, all the systems that we want to support are new enough.
        ("CMAC_CTX_new", ["openssl/cmac.h"], "CRYPTO", True),
        # Next should be above, but it needs a library
        # EVP_PKEY_new_CMAC_key added in OpenSSL 1.1.1
        ("EVP_PKEY_new_CMAC_key", ["openssl/cmac.h"], "CRYPTO", False),
    )
    for ft in required_functions:
        probe_function(
            ctx, function=ft[0], prerequisites=ft[1], use=ft[2], mandatory=ft[3]
        )

    # check for BSD versions outside of libc
    if not ctx.get_define("HAVE_STRLCAT"):
        ret = probe_function(ctx, function="strlcat", prerequisites=["bsd/string.h"])
                             prerequisites=['bsd/string.h'])
        if ret:
            ctx.define("HAVE_STRLCAT", 1, comment="Using bsd/strlcat")

    if not ctx.get_define("HAVE_STRLCPY"):
        ret = probe_function(ctx, function="strlcpy", prerequisites=["bsd/string.h"])
                             prerequisites=['bsd/string.h'])
        if ret:
            ctx.define("HAVE_STRLCPY", 1, comment="Using bsd/strlcpy")

    # Nobody uses the symbol, but this seems like a good sanity check.
    ctx.check_cc(header_name="stdbool.h", mandatory=True, comment="Sanity check.")
                 comment="Sanity check.")

    # This is a list of every optional include header in the
    # codebase that is guarded by a directly corresponding HAVE_*_H symbol.

    optional_headers = (
        "alloca.h",
        ("arpa/nameser.h", ["sys/types.h"]),
        "bsd/string.h",  # bsd emulation
        ("ifaddrs.h", ["sys/types.h"]),
        ("linux/if_addr.h", ["sys/socket.h"]),
        ("linux/rtnetlink.h", ["sys/socket.h"]),
        "linux/serial.h",
        "net/if6.h",
        ("net/route.h", ["sys/types.h", "sys/socket.h", "net/if.h"]),
        "priv.h",  # Solaris
        "stdatomic.h",
        "sys/clockctl.h",  # NetBSD
        "sys/ioctl.h",
        "sys/modem.h",  # Apple
        "sys/sockio.h",
        ("sys/sysctl.h", ["sys/types.h"]),
        ("timepps.h", ["inttypes.h"]),

    )
    for hdr in optional_headers:
        if isinstance(hdr, str):
            if ctx.check_cc(
                header_name=hdr, mandatory=False, comment="<%s> header" % hdr
            ):
                continue
        else:
            (hdr, prereqs) = hdr

            # Sanity check...
            print("Compilation check failed but include exists %s" % hdr)

    if ctx.get_define("HAVE_TIMEPPS_H") or ctx.get_define("HAVE_SYS_TIMEPPS_H"):
            ctx.get_define("HAVE_SYS_TIMEPPS_H"))):
        ctx.define("HAVE_PPSAPI", 1, comment="Enable the PPS API")

    # Check for Solaris capabilities
    if ctx.get_define("HAVE_PRIV_H") and ctx.env.DEST_OS == "sunos":
        ctx.define(
            "HAVE_SOLARIS_PRIVS", 1, comment="Enable Solaris Privileges (Solaris only)"
        )

    from wafhelpers.check_sockaddr import check_sockaddr

    check_sockaddr(ctx)

    from wafhelpers.check_strerror import check_strerror

    check_strerror(ctx)

    # Check for Solaris's service configuration facility library
    ctx.check_cc(header_name="libscf.h", lib="scf", mandatory=False, uselib_store="SCF")
                 uselib_store="SCF")

    # Some systems don't have sys/timex.h eg OS X, OpenBSD...
    if ctx.get_define("HAVE_SYS_TIMEX_H"):


    if ctx.options.refclocks:
        from wafhelpers.refclock import refclock_config

        refclock_config(ctx)
        # timegm needed by refclock_nmea, it's not in POSIX
        # It's in Linux, FreeBSD, and NetBSD

    # ctx.define("OS_MISSES_SPECIFIC_ROUTE_UPDATES", 1)

    if ctx.options.enable_leap_smear:
        ctx.define(
            "ENABLE_LEAP_SMEAR", 1, comment="Enable experimental leap smearing code"
        )

    if ctx.options.enable_mssntp:
        ctx.define(
            "ENABLE_MSSNTP",
            1,
            comment="Enable MS-SNTP extensions "
            " https://msdn.microsoft.com/en-us/library/cc212930.aspx",
        )

    if ctx.options.enable_attic:
        ctx.env.ENABLE_ATTIC = True

    if ctx.options.disable_nts:
        ctx.env.DISABLE_NTS = True
        ctx.define("DISABLE_NTS", 1, comment="Disable NTS")
                   comment="Disable NTS")

    if not ctx.options.disable_droproot:
        ctx.define("ENABLE_DROPROOT", 1, comment="Drop root after initialising")
                   comment="Drop root after initialising")
    if ctx.options.enable_early_droproot:
        ctx.define("ENABLE_EARLY_DROPROOT", 1, comment="Enable early drop root")
                   comment="Enable early drop root")
    if not ctx.options.disable_fuzz:
        ctx.define("ENABLE_FUZZ", 1, comment="Enable fuzzing low bits of time")
                   comment="Enable fuzzing low bits of time")

    # SO_REUSEADDR socket option is needed to open a socket on an
    # interface when the port number is already in use on another
    # interface. Linux needs this, NetBSD does not, status on
    # other platforms is unknown.  It is probably harmless to
    # have it on everywhere.
    ctx.define(
        "NEED_REUSEADDR_FOR_IFADDRBIND",
        1,
        comment="Whether SO_REUSEADDR is needed to open "
        "same sockets on alternate interfaces, required "
        "by Linux at least",
    )

    # Check for directory separator
    if ctx.env.DEST_OS == "win32":

    else:
        sep = "/"

    ctx.define("DIR_SEP", "'%s'" % sep, quote=False, comment="Directory separator used")
               comment="Directory separator used")

    if ctx.get_define("HAVE_SYS_SYSCTL_H"):
        ctx.define("HAVE_IFLIST_SYSCTL", 1, comment="Whether sysctl interface exists")
                   comment="Whether sysctl interface exists")

    # Header/library checks


        ctx.check_cc(header_name="sys/capability.h", mandatory=False)
        ctx.check_cc(lib="cap", comment="Capability library", mandatory=False)

        if (
            ctx.get_define("HAVE_SYS_CAPABILITY_H")
            and ctx.get_define("HAVE_SYS_PRCTL_H")
            and ctx.env.LIB_CAP
        ):
            ctx.define("HAVE_LINUX_CAPABILITY", 1)

    if ctx.options.enable_seccomp:


        # Check via pkg-config first, then fall back to a direct search
        if not ctx.check_cfg(
            package="libseccomp",
            args=["--libs", "--cflags"],
            uselib_store="SECCOMP",
            define_name="HAVE_SECCOMP_H",
            mandatory=False,
        ):
            ctx.check_cc(header_name="seccomp.h")
            ctx.check_cc(lib="seccomp")

    if not ctx.options.disable_mdns_registration:
        ctx.check_cc(
            header_name="dns_sd.h", lib="dns_sd", mandatory=False, uselib_store="DNS_SD"
        )

    # Solaris needs -lsocket and -lnsl for socket code
    if ctx.env.DEST_OS == "sunos":

    if not ctx.env.DISABLE_NTS:
        from wafhelpers.openssl import check_libssl_tls13
        from wafhelpers.openssl import check_openssl_bad_version

        check_libssl_tls13(ctx)
        check_openssl_bad_version(ctx)


    msg_setting("Build Docs", yesno(ctx.env.BUILD_DOC))
    msg_setting("Build Manpages", yesno(ctx.env.BUILD_MAN))

    if ctx.env["ntpc"] == "none":
        return
    ctx.recurse("pylib")
    ctx.env.PYSHEBANG = ctx.options.pyshebang
    msg_setting("PYSHEBANG", ctx.env.PYSHEBANG)



class check(BuildContext):
    cmd = "check"
    variant = "main"


def bin_test(ctx):
    """Run binary check, use after tests."""
    from wafhelpers.bin_test import cmd_bin_test

    cmd_bin_test(ctx)


def bin_test_summary(ctx):
    """Display results of binary check, use after tests."""
    from wafhelpers.bin_test import bin_test_summary

    bin_test_summary(ctx)



for v in ["host", "main"]:
    # the reason for creating these subclasses is just for __doc__ below...
    for cmd, cls in variant_cmd:

        class tmp(cls):
            __doc__ = "%s %s" % (cmd, v)
            cmd = "%s_%s" % (cmd, v)


def init_handler(ctx):
    cmd = ctx.cmd
    if cmd == "init_handler":
        cmd = "build"

    def make_context(name):
        for x in Context.classes:
            if x.cmd == name and x.fun != "init_handler":
                return x()
        ctx.fatal("No class for %r" % cmd)

    # By default we want to iterate over each variant.
    for v in ["host", "main"]:



for command, func, descr in commands:

    class tmp1(Context.Context):
        if descr:
            __doc__ = descr
        cmd = command
        fun = func
        if command in "install uninstall build clean list step":
            'install uninstall build clean list step'
             )):
            execute = Scripting.autoconfigure(Context.Context.execute)


# end borrowed code



    # Note that this setup is applied to the build tree, not the
    # source tree.  Only the build-tree copies of the programs are
    # expected to work.
    if "none" == ctx.env["ntpc"]:
        return
    for x in (
        "ntpclients",
        "tests/pylib",
    ):
        # List used to be longer...
        path_build = ctx.bldnode.make_node("pylib")
        path_source = ctx.bldnode.make_node(x + "/ntp")
        relpath = ("../" * (x.count("/") + 1)) + path_build.path_from(ctx.bldnode)
        if ctx.cmd in ("install", "build"):
            if (
                not path_source.exists()
                or os.readlink(path_source.abspath()) != relpath
            ):
                try:
                    os.remove(path_source.abspath())
                except OSError:



def build(ctx):
    global python_scripts
    from waflib.Logs import verbose

    ctx.load("waf", tooldir="wafhelpers/")
    ctx.load("asciidoc", tooldir="wafhelpers/")
    ctx.load("rtems_trace", tooldir="wafhelpers/")

    if ctx.variant == "host":
        ctx.recurse("ntpd")

        ctx.add_pre_fun(lambda ctx: ctx.exec_command("rm -f pylib/*.py[co]"))
        # Start purging ntp.ntpc files from build dir
        # so old extension won't clobber FFI or reverse
        bldnode = ctx.bldnode.make_node("pylib")
        bldnode.mkdir()
        target3 = bldnode.ant_glob("*ntpc*")
        for _ in target3:
            ctx.exec_command("rm -f %s" % _.abspath())
        # Finish purging ntp.ntpc

        ctx.recurse("libparse")
    ctx.recurse("libntp")
    if not ctx.env.DISABLE_NTS:
        ctx.recurse("libaes_siv")
    ctx.recurse("ntpd")
    ctx.recurse("ntpfrob")
    ctx.recurse("ntptime")
    ctx.recurse("pylib")
    if ctx.env.ENABLE_ATTIC:
        ctx.recurse("attic")
    ctx.recurse("etc")
    ctx.recurse("tests")

    if ctx.env["PYTHON_ARGPARSE"]:
        python_scripts.add("ntpclients/ntplogtemp.py")
        python_scripts.add("ntpclients/ntpviz.py")
    if ctx.env["PYTHON_ARGPARSE"] and ctx.env["PYTHON_GPS"]:
        python_scripts.add("ntpclients/ntploggps.py")
    if ctx.env["PYTHON_CURSES"]:
        python_scripts.add("ntpclients/ntpmon.py")
    if "none" == ctx.env["ntpc"]:
        python_scripts = []
    else:
        # Make sure the python scripts compile, but don't install them
        ctx(
            features="py",
            source=python_scripts,
            install_path=None,
        )

    scripts = ["ntpclients/ntpleapfetch"] + list(python_scripts)

    ctx(
        features="subst",
        source=scripts,
        target=[x.replace(".py", "") for x in scripts],
        chmod=Utils.O755,
        install_path="${BINDIR}",
    )

    ctx.add_post_fun(afterparty)
    if ctx.cmd == "clean":
        afterparty(ctx)

    if ctx.env["PYTHON_ARGPARSE"]:
        ctx.manpage(1, "ntpclients/ntplogtemp-man.adoc")
        ctx.manpage(1, "ntpclients/ntpviz-man.adoc")
    if ctx.env["PYTHON_ARGPARSE"] and ctx.env["PYTHON_GPS"]:
        ctx.manpage(1, "ntpclients/ntploggps-man.adoc")
    if ctx.env["PYTHON_CURSES"]:
        ctx.manpage(1, "ntpclients/ntpmon-man.adoc")
    ctx.manpage(1, "ntpclients/ntpdig-man.adoc")
    ctx.manpage(1, "ntpclients/ntpq-man.adoc")


    # Skip running unit tests on a cross compile build
    from waflib import Options

    if not ctx.env.ENABLE_CROSS:
        # Force re-running of tests.  Same as 'waf --alltests'
        if ctx.cmd == "check":


    if ctx.cmd == "build":
        if "PYTHONPATH" not in os.environ:
            print(
                "--- PYTHONPATH is not set, "
                "loading the Python ntp library may be troublesome ---"
            )
        elif ctx.env.PYTHONARCHDIR not in os.environ["PYTHONPATH"]:
            print(
                "--- PYTHONARCHDIR not in PYTHONPATH, "
                "loading the Python ntp library may be troublesome ---"
            )


#
# Miscellaneous utility productions


def cxfreeze(ctx):
    "Create standalone binaries from Python scripts."
    ctx.exec_command(
        "for prog in " + " ".join(python_scripts) + "; do cxfreeze $prog; done"
    )


def linkcheck(ctx):
    "Report references without anchors in the documentation."
    ctx.exec_command("devel/linkcheck docs/")


# The following sets edit modes for GNU EMACS
# Local Variables:
# mode:python
- 

Return to bug 852143

Lines 1-6 Link Here

(-)a/docs/wscript (-15 / +10 lines)
1	def build(ctx):	1	def build(ctx):
2		2
3	doc_source = ctx.path.ant_glob(".adoc", excl='-body.adoc')	3	doc_source = ctx.path.ant_glob(".adoc", excl="-body.adoc")
4		4
5	ctx(	5	ctx(
6	source=doc_source,	6	source=doc_source,
Lines 8-18 def build(ctx): Link Here
8	)	8	)
9		9
10	image_source = []	10	image_source = []
11	ctx.path.get_bld().make_node("hints").mkdir() # create 'hints' directory	11	ctx.path.get_bld().make_node("hints").mkdir() # create 'hints' directory
12	for dir in ["icons", "pic"]:	12	for dir in ["icons", "pic"]:
13		13
14	files = ctx.path.ant_glob('%s/*' % dir) # Find images	14	files = ctx.path.ant_glob("%s/*" % dir) # Find images
15	ctx.path.get_bld().make_node(dir).mkdir() # create 'pic' directory	15	ctx.path.get_bld().make_node(dir).mkdir() # create 'pic' directory
16	image_source += files	16	image_source += files
17		17
18	# Copy images	18	# Copy images
Lines 20-40 def build(ctx): Link Here
20	features="subst",	20	features="subst",
21	is_copy=True,	21	is_copy=True,
22	source=files,	22	source=files,
23	target=[ctx.path.find_node(dir).get_bld().make_node(x.name)	23	target=[ctx.path.find_node(dir).get_bld().make_node(x.name) for x in files],
24	for x in files]
25	)	24	)
26		25
27	extra = ["asciidoc.js", "asciidoc.css"]	26	extra = ["asciidoc.js", "asciidoc.css"]
28		27
29	# Copy extra files	28	# Copy extra files
30	ctx(	29	ctx(features="subst", is_copy=True, source=extra, target=extra)
31	features="subst",
32	is_copy=True,
33	source=extra,
34	target=extra
35	)
36		30
37	# Install HTML	31	# Install HTML
38	ctx.install_files('${HTMLDIR}', extra +	32	ctx.install_files(
39	[x.change_ext(".html").name for x in doc_source])	33	"${HTMLDIR}", extra + [x.change_ext(".html").name for x in doc_source]
40	ctx.install_files('${HTMLDIR}', image_source, relative_trick=True)	34	)
		35	ctx.install_files("${HTMLDIR}", image_source, relative_trick=True)

Lines 1-21 Link Here

(-)a/libaes_siv/wscript (-14 / +14 lines)
1	def build(ctx):	1	def build(ctx):
2	aes_cflags=['-Wno-shadow',	2	aes_cflags = [
3	# '-Wall', '-Wextra', '-Wstrict-prototypes', # default	3	"-Wno-shadow",
4	'-Wconversion',	4	# '-Wall', '-Wextra', '-Wstrict-prototypes', # default
5	'-O3',	5	"-Wconversion",
6	'-fomit-frame-pointer',	6	"-O3",
7	'-funroll-loops',	7	"-fomit-frame-pointer",
8	'-ftree-vectorize',	8	"-funroll-loops",
9	'-Wno-inline', # gcc 10 gives inline warnings?	9	"-ftree-vectorize",
10	]	10	"-Wno-inline", # gcc 10 gives inline warnings?
11		11	]
12		12
13	ctx(	13	ctx(
14	target='aes_siv',	14	target="aes_siv",
15	features='c cstlib',	15	features="c cstlib",
16	includes=[ctx.bldnode.parent.abspath()],	16	includes=[ctx.bldnode.parent.abspath()],
17	source='aes_siv.c',	17	source="aes_siv.c",
18	use='CRYPTO',	18	use="CRYPTO",
19	cflags=aes_cflags,	19	cflags=aes_cflags,
20	)	20	)
21		21

Lines 4-9 import waflib Link Here

(-)a/libntp/wscript (-8 / +14 lines)
4	from waflib import Errors, Options	4	from waflib import Errors, Options
5	from waflib.Logs import pprint	5	from waflib.Logs import pprint
6		6
		7
7	def build(ctx):	8	def build(ctx):
8		9
9	libntp_source = [	10	libntp_source = [
Lines 53-59 def build(ctx): Link Here
53	use="CRYPTO SSL",	54	use="CRYPTO SSL",
54	)	55	)
55		56
56	if ctx.env['ntpc'] == 'ffi':	57	if ctx.env["ntpc"] == "ffi":
57	# Loadable FFI stub	58	# Loadable FFI stub
58	ctx(	59	ctx(
59	features="c cshlib",	60	features="c cshlib",
Lines 61-82 def build(ctx): Link Here
61	source=["ntp_c.c", "pymodule-mac.c"] + libntp_source_sharable,	62	source=["ntp_c.c", "pymodule-mac.c"] + libntp_source_sharable,
62	target="../pylib/ntpc", # Put the output in the pylib directory	63	target="../pylib/ntpc", # Put the output in the pylib directory
63	use="M RT CRYPTO",	64	use="M RT CRYPTO",
64	vnum=ctx.env['ntpcver'],	65	vnum=ctx.env["ntpcver"],
65	)	66	)
66	ctx.add_post_fun(post)	67	ctx.add_post_fun(post)
67	elif ctx.env['ntpc'] == 'ext':	68	elif ctx.env["ntpc"] == "ext":
68	# Loadable Python extension	69	# Loadable Python extension
69	ctx(	70	ctx(
70	features="c cshlib pyext",	71	features="c cshlib pyext",
71	install_path='${PYTHONARCHDIR}/ntp',	72	install_path="${PYTHONARCHDIR}/ntp",
72	includes=[ctx.bldnode.parent.abspath(), "../include"],	73	includes=[ctx.bldnode.parent.abspath(), "../include"],
73	source=["pymodule.c", "pymodule-mac.c"] + libntp_source_sharable,	74	source=["pymodule.c", "pymodule-mac.c"] + libntp_source_sharable,
74	target="../pylib/ntpc", # Put the output in the pylib directory	75	target="../pylib/ntpc", # Put the output in the pylib directory
75	use="M RT CRYPTO",	76	use="M RT CRYPTO",
76	)	77	)
		78	elif "none" == ctx.env["ntpc"]:
		79	return
		80
77		81
78	def post(ctx):	82	def post(ctx):
79	if not (ctx.cmd == 'install' and ctx.env.BIN_LDCONFIG):	83	if not (ctx.cmd == "install" and ctx.env.BIN_LDCONFIG):
80	return	84	return
81		85
82	destdir = Options.options.destdir	86	destdir = Options.options.destdir
Lines 92-102 def post(ctx): Link Here
92		96
93	# Try to run ldconfig. It is not a fatal error here if it fails, as the	97	# Try to run ldconfig. It is not a fatal error here if it fails, as the
94	# install could be run by a non-root user.	98	# install could be run by a non-root user.
95	ldconfig = ' '.join(ctx.env.BIN_LDCONFIG)	99	ldconfig = " ".join(ctx.env.BIN_LDCONFIG)
96	try:	100	try:
97	out = ctx.cmd_and_log(	101	out = ctx.cmd_and_log(
98	ctx.env.BIN_LDCONFIG, output=waflib.Context.STDOUT,	102	ctx.env.BIN_LDCONFIG,
99	quiet=waflib.Context.BOTH)	103	output=waflib.Context.STDOUT,
		104	quiet=waflib.Context.BOTH,
		105	)
100	pprint("GREEN", "running: %s OK" % ldconfig)	106	pprint("GREEN", "running: %s OK" % ldconfig)
101	except Errors.WafError as e:	107	except Errors.WafError as e:
102	pprint("RED", "running: %s FAILED" % ldconfig)	108	pprint("RED", "running: %s FAILED" % ldconfig)

Lines 1-11 Link Here

(-)a/ntpfrob/wscript (-3 / +10 lines)
1	def build(ctx):	1	def build(ctx):
2	frob_sources = ['main.c', 'bumpclock.c', 'dump.c', 'jitter.c',	2	frob_sources = [
3	'precision.c', 'pps-api.c', 'tickadj.c']	3	"main.c",
		4	"bumpclock.c",
		5	"dump.c",
		6	"jitter.c",
		7	"precision.c",
		8	"pps-api.c",
		9	"tickadj.c",
		10	]
4		11
5	ctx(	12	ctx(
6	features="c cprogram",	13	features="c cprogram",
7	includes=[ctx.bldnode.parent.abspath(), "../include"],	14	includes=[ctx.bldnode.parent.abspath(), "../include"],
8	install_path='${BINDIR}',	15	install_path="${BINDIR}",
9	source=frob_sources,	16	source=frob_sources,
10	target="ntpfrob",	17	target="ntpfrob",
11	use="M RT",	18	use="M RT",

Lines 2-46 from waflib.Logs import pprint Link Here

(-)a/pylib/wscript (-41 / +52 lines)
2		2
3		3
4	def options(opt):	4	def options(opt):
5	opt.load('python')	5	opt.load("python")
6		6
7		7
8	def configure(conf):	8	def configure(conf):
9	conf.load('python')	9	if conf.env["ntpc"] == "none":
		10	return
		11	conf.load("python")
		12
10	if not conf.env.ENABLE_CROSS:	13	if not conf.env.ENABLE_CROSS:
11	conf.check_python_version((2, 6, 0))	14	conf.check_python_version((2, 6, 0))
12	conf.check_python_headers(features='pyext') # Extension-only, no embedded	15	conf.check_python_headers(features="pyext") # Extension-only
13	try:	16	try:
14	conf.check_python_module('curses')	17	conf.check_python_module("curses")
15	conf.env['PYTHON_CURSES'] = True	18	conf.env["PYTHON_CURSES"] = True
16	except conf.errors.ConfigurationError:	19	except conf.errors.ConfigurationError:
17	pprint("YELLOW", "WARNING: ntpmon will not be built/installed since "	20	pprint(
18	"python curses module was not found")	21	"YELLOW",
		22	"WARNING: ntpmon will not be built/installed since "
		23	"python curses module was not found",
		24	)
19	try:	25	try:
20	conf.check_python_module('argparse')	26	conf.check_python_module("argparse")
21	conf.env['PYTHON_ARGPARSE'] = True	27	conf.env["PYTHON_ARGPARSE"] = True
22	except conf.errors.ConfigurationError:	28	except conf.errors.ConfigurationError:
23	pprint("YELLOW", "WARNING: ntploggps, ntplogtemp, and ntpviz will not "	29	pprint(
24	"be built/installed since python argparse module was not found")	30	"YELLOW",
		31	"WARNING: ntploggps, ntplogtemp, and ntpviz will not "
		32	"be built/installed since python argparse module was not found",
		33	)
25	try:	34	try:
26	conf.check_python_module('gps', condition="ver >= num(3, 18)")	35	conf.check_python_module("gps", condition="ver >= num(3, 18)")
27	conf.env['PYTHON_GPS'] = True	36	conf.env["PYTHON_GPS"] = True
28	except conf.errors.ConfigurationError:	37	except conf.errors.ConfigurationError:
29	pprint("YELLOW", "WARNING: ntploggps will not be built/installed since "	38	pprint(
30	"python gps module >= 3.18 was not found")	39	"YELLOW",
		40	"WARNING: ntploggps will not be built/installed"
		41	" since python gps module >= 3.18 was not found",
		42	)
31		43
32		44
33	def build(ctx):	45	def build(ctx):
34	srcnode = ctx.srcnode.make_node('pylib')	46	ctx(features="subst", source=["version.txt.in"], target=['version.txt'])
35	bldnode = ctx.bldnode.make_node('pylib')	47	if ctx.env["ntpc"] == "none":
36	target1 = bldnode.make_node('control.py')	48	return
37	target2 = bldnode.make_node('magic.py')	49	srcnode = ctx.srcnode.make_node("pylib")
		50	bldnode = ctx.bldnode.make_node("pylib")
		51	target1 = bldnode.make_node("control.py")
		52	target2 = bldnode.make_node("magic.py")
38		53
39	sources = []	54	sources = []
40	if ctx.env['ntpc'] == 'ext':	55	if ctx.env["ntpc"] == "ext":
41	sources = srcnode.ant_glob("*.py", excl='ntpc.py')	56	sources = srcnode.ant_glob("*.py", excl="ntpc.py")
42	elif ctx.env['ntpc'] == 'ffi':	57	elif ctx.env["ntpc"] == "ffi":
43	sources = srcnode.ant_glob('*.py')	58	sources = srcnode.ant_glob("*.py")
44	builds = [x.get_bld() for x in sources]	59	builds = [x.get_bld() for x in sources]
45		60
46	# The rm's here were added to fix a reported (but underdocumented) problem	61	# The rm's here were added to fix a reported (but underdocumented) problem
Lines 52-64 def build(ctx): Link Here
52	# including during 'install'. They are now disabled but retained as a	67	# including during 'install'. They are now disabled but retained as a
53	# comment.	68	# comment.
54		69
55	## Remove generated files to ensure they are properly updated	70	# # Remove generated files to ensure they are properly updated
56	#ctx.exec_command("rm -f %s" % target1.abspath())	71	# ctx.exec_command("rm -f %s" % target1.abspath())
57	#ctx.exec_command("rm -f %s" % target2.abspath())	72	# ctx.exec_command("rm -f %s" % target2.abspath())
58		73
59	if ctx.env['ntpc'] is None:	74	if ctx.env["ntpc"] is None:
60	return	75	return
61		76
62	# Make sure Python sees .py as well as .pyc/.pyo	77	# Make sure Python sees .py as well as .pyc/.pyo
63	ctx(	78	ctx(
64	features="subst",	79	features="subst",
Lines 67-83 def build(ctx): Link Here
67	)	82	)
68		83
69	ctx(	84	ctx(
70	before=['pyc', 'pyo'],	85	before=["pyc", "pyo"],
71	cwd=srcnode,	86	cwd=srcnode,
72	rule='${PYTHON} ${SRC} >${TGT}',	87	rule="${PYTHON} ${SRC} >${TGT}",
73	source=["../wafhelpers/pythonize-header", "../include/ntp_control.h"],	88	source=["../wafhelpers/pythonize-header", "../include/ntp_control.h"],
74	target=target1,	89	target=target1,
75	)	90	)
76		91
77	ctx(	92	ctx(
78	before=['pyc', 'pyo'],	93	before=["pyc", "pyo"],
79	cwd=srcnode,	94	cwd=srcnode,
80	rule='${PYTHON} ${SRC} >${TGT}',	95	rule="${PYTHON} ${SRC} >${TGT}",
81	source=["../wafhelpers/pythonize-header", "../include/ntp.h"],	96	source=["../wafhelpers/pythonize-header", "../include/ntp.h"],
82	target=target2,	97	target=target2,
83	)	98	)
Lines 86-102 def build(ctx): Link Here
86	ctx.add_group()	101	ctx.add_group()
87		102
88	ctx(	103	ctx(
89	features='py',	104	features="py",
90	source=builds+[target1, target2],	105	source=builds + [target1, target2],
91	install_from=bldnode,	106	install_from=bldnode,
92	install_path='${PYTHONARCHDIR}/ntp'	107	install_path="${PYTHONARCHDIR}/ntp",
93	)	108	)
94		109
95	# pep241 lay an egg	110	# pep241 lay an egg
96	egg = ['ntp-%s.egg-info' % ctx.env.NTPSEC_VERSION]	111	egg = ["ntp-%s.egg-info" % ctx.env.NTPSEC_VERSION]
97	ctx(	112	ctx(features="subst", source=["ntp-in.egg-info"], target=egg)
98	features="subst",
99	source=['ntp-in.egg-info'],
100	target=egg
101	)
102	ctx.install_files(ctx.env.PYTHONARCHDIR, egg)	113	ctx.install_files(ctx.env.PYTHONARCHDIR, egg)

Lines 3-13 from waflib import Utils # pylint: disable=import-error Link Here

(-)a/tests/wscript (-29 / +33 lines)
3		3
4		4
5	def build(ctx):	5	def build(ctx):
6	testsrc = ctx.srcnode.make_node('tests')
7	pylib = ctx.srcnode.make_node('pylib')
8	testpylib = testsrc.make_node('pylib')
9	testpysrc = testpylib.ant_glob('*.py')
10
11	# Unity source	6	# Unity source
12	unity_source = [	7	unity_source = [
13	"unity/unity.c",	8	"unity/unity.c",
Lines 17-28 def build(ctx): Link Here
17		12
18	unity_config = ["UNITY_INCLUDE_DOUBLE", "UNITY_SUPPORT_64"]	13	unity_config = ["UNITY_INCLUDE_DOUBLE", "UNITY_SUPPORT_64"]
19		14
20	ctx(	15	ctx(defines=unity_config, features="c", target="unity", source=unity_source)
21	defines=unity_config,
22	features="c",
23	target="unity",
24	source=unity_source
25	)
26		16
27	# Test main.	17	# Test main.
28	common_source = [	18	common_source = [
Lines 52-58 def build(ctx): Link Here
52	"libntp/strtolfp.c",	42	"libntp/strtolfp.c",
53	"libntp/timespecops.c",	43	"libntp/timespecops.c",
54	"libntp/vi64ops.c",	44	"libntp/vi64ops.c",
55	"libntp/ymd2yd.c"	45	"libntp/ymd2yd.c",
56	] + common_source	46	] + common_source
57		47
58	ctx.ntp_test(	48	ctx.ntp_test(
Lines 95-125 def build(ctx): Link Here
95	] + common_source	85	] + common_source
96		86
97	if not ctx.env.DISABLE_NTS:	87	if not ctx.env.DISABLE_NTS:
98	ntpd_source += [	88	ntpd_source += [
99	"ntpd/nts.c",	89	"ntpd/nts.c",
100	"ntpd/nts_client.c",	90	"ntpd/nts_client.c",
101	"ntpd/nts_server.c",	91	"ntpd/nts_server.c",
102	"ntpd/nts_cookie.c",	92	"ntpd/nts_cookie.c",
103	"ntpd/nts_extens.c",	93	"ntpd/nts_extens.c",
104	]	94	]
105		95
106	ctx.ntp_test(	96	ctx.ntp_test(
107	defines=unity_config + ["TEST_NTPD=1"],	97	defines=unity_config + ["TEST_NTPD=1"],
108	features="c cprogram test",	98	features="c cprogram test",
109	includes=[ctx.bldnode.parent.abspath(), "../include", "unity", "../ntpd", "common", "../libaes_siv"],	99	includes=[
		100	ctx.bldnode.parent.abspath(),
		101	"../include",
		102	"unity",
		103	"../ntpd",
		104	"common",
		105	"../libaes_siv",
		106	],
110	install_path=None,	107	install_path=None,
111	source=ntpd_source,	108	source=ntpd_source,
112	target="test_ntpd",	109	target="test_ntpd",
113	use="ntpd_lib libntpd_obj unity ntp aes_siv "	110	use="ntpd_lib libntpd_obj unity ntp aes_siv " "M PTHREAD CRYPTO RT SOCKET NSL",
114	"M PTHREAD CRYPTO RT SOCKET NSL",
115	)	111	)
116		112
		113	if "none" == ctx.env["ntpc"]:
		114	return
		115	testsrc = ctx.srcnode.make_node("tests")
		116	pylib = ctx.srcnode.make_node("pylib")
		117	testpylib = testsrc.make_node("pylib")
		118	testpysrc = testpylib.ant_glob("*.py")
117	testpylib.get_bld().mkdir()	119	testpylib.get_bld().mkdir()
118		120
119	pypath = pylib.get_bld()	121	pypath = pylib.get_bld()
120	targdir = "tests/pylib"	122	targdir = "tests/pylib"
121	linkpath = ctx.bldnode.make_node(targdir + "/ntp").abspath()	123	linkpath = ctx.bldnode.make_node(targdir + "/ntp").abspath()
122	relpath = ("../" * (targdir.count("/")+1)) + pypath.path_from(ctx.bldnode)	124	relpath = ("../" * (targdir.count("/") + 1)) + pypath.path_from(ctx.bldnode)
123	if (not os.path.exists(linkpath)) or os.readlink(linkpath) != relpath:	125	if (not os.path.exists(linkpath)) or os.readlink(linkpath) != relpath:
124	try:	126	try:
125	os.remove(linkpath)	127	os.remove(linkpath)
Lines 127-138 def build(ctx): Link Here
127	pass	129	pass
128	os.symlink(relpath, linkpath)	130	os.symlink(relpath, linkpath)
129		131
130	pytests = ["pylib/test_util.py",	132	pytests = [
131	"pylib/test_agentx.py",	133	"pylib/test_util.py",
132	"pylib/test_agentx_packet.py",	134	"pylib/test_agentx.py",
133	"pylib/test_ntpc.py",	135	"pylib/test_agentx_packet.py",
134	"pylib/test_packet.py",	136	"pylib/test_ntpc.py",
135	"pylib/test_statfiles.py"]	137	"pylib/test_packet.py",
		138	"pylib/test_statfiles.py",
		139	]
136		140
137	ctx(	141	ctx(
138	features="subst",	142	features="subst",

Lines 2-8 Link Here

(-)a/wafhelpers/bin_test.py (-35 / +29 lines)
2	from __future__ import print_function	2	from __future__ import print_function
3	import os	3	import os
4	import os.path	4	import os.path
5	import sys	5
		6	# import sys
6	import waflib.Context	7	import waflib.Context
7	import waflib.Logs	8	import waflib.Logs
8	import waflib.Utils	9	import waflib.Utils
Lines 13-19 cmd_map = { Link Here
13	("main/ntpclients/ntpleapfetch", "--version"): "ntpleapfetch %s\n",	14	("main/ntpclients/ntpleapfetch", "--version"): "ntpleapfetch %s\n",
14	("main/ntpd/ntpd", "--version"): "ntpd %s\n",	15	("main/ntpd/ntpd", "--version"): "ntpd %s\n",
15	("main/ntpfrob/ntpfrob", "-V"): "ntpfrob %s\n",	16	("main/ntpfrob/ntpfrob", "-V"): "ntpfrob %s\n",
16	("main/ntptime/ntptime", "-V"): "ntptime %s\n"	17	("main/ntptime/ntptime", "-V"): "ntptime %s\n",
17	}	18	}
18	cmd_map_python = {	19	cmd_map_python = {
19	("main/ntpclients/ntpdig", "--version"): "ntpdig %s\n",	20	("main/ntpclients/ntpdig", "--version"): "ntpdig %s\n",
Lines 22-28 cmd_map_python = { Link Here
22	("main/ntpclients/ntpsnmpd", "--version"): "ntpsnmpd %s\n",	23	("main/ntpclients/ntpsnmpd", "--version"): "ntpsnmpd %s\n",
23	("main/ntpclients/ntpsweep", "--version"): "ntpsweep %s\n",	24	("main/ntpclients/ntpsweep", "--version"): "ntpsweep %s\n",
24	("main/ntpclients/ntptrace", "--version"): "ntptrace %s\n",	25	("main/ntpclients/ntptrace", "--version"): "ntptrace %s\n",
25	("main/ntpclients/ntpwait", "--version"): "ntpwait %s\n"	26	("main/ntpclients/ntpwait", "--version"): "ntpwait %s\n",
26	}	27	}
27	# Need argparse	28	# Need argparse
28	cmd_map_python_argparse = {	29	cmd_map_python_argparse = {
Lines 57-71 def run(cmd, expected, python=None): Link Here
57	addLog("YELLOW", prefix + " SKIPPING (does not exist)")	58	addLog("YELLOW", prefix + " SKIPPING (does not exist)")
58	return False	59	return False
59		60
		61	envy = {}
60	if python:	62	if python:
61	cmd = python + list(cmd)	63	cmd = python + list(cmd)
62	p = Popen(cmd, env={'PYTHONPATH': '%s/main/tests/pylib' %	64	envy = {"PYTHONPATH": waflib.Context.out_dir + "/main/tests/pylib"}
63	waflib.Context.out_dir},	65	p = Popen(
64	universal_newlines=True,	66	cmd,
65	stdin=waflib.Utils.subprocess.PIPE,	67	env=envy,
66	stdout=waflib.Utils.subprocess.PIPE,	68	universal_newlines=True,
67	stderr=waflib.Utils.subprocess.PIPE,	69	stdin=waflib.Utils.subprocess.PIPE,
68	cwd=waflib.Context.out_dir)	70	stdout=waflib.Utils.subprocess.PIPE,
		71	stderr=waflib.Utils.subprocess.PIPE,
		72	cwd=waflib.Context.out_dir,
		73	)
69		74
70	stdout, stderr = p.communicate()	75	stdout, stderr = p.communicate()
71		76
Lines 73-116 def run(cmd, expected, python=None): Link Here
73	addLog("GREEN", prefix + " OK")	78	addLog("GREEN", prefix + " OK")
74	return True	79	return True
75	addLog("RED", prefix + " FAILED")	80	addLog("RED", prefix + " FAILED")
76	addLog("PINK", "Expected: " + expected)	81	addLog("PINK", "Expected: '%s'" % expected)
77	if stdout:	82	if stdout:
78	addLog("PINK", "Got (stdout): " + stdout)	83	addLog("PINK", "Got (stdout): '%s'" % stdout)
79	if stderr:	84	if stderr:
80	addLog("PINK", "Got (stderr): " + stderr)	85	addLog("PINK", "Got (stderr): '%s'" % stderr)
81	return False	86	return False
82		87
83		88
84	def cmd_bin_test(ctx):	89	def cmd_bin_test(ctx):
85	"""Run a suite of binary tests."""	90	"""Run a suite of binary tests."""
86	fails = 0	91	fails = 0
87		92	with open(waflib.Context.out_dir + "/main/pylib/version.txt") as fp:
88	cmd = ctx.env['PYTHON'] + ['-c',	93	version = fp.read().strip(' \n')
89	'from __future__ import print_function;'	94
90	'import ntp.util;'	95	if not os.path.isdir(waflib.Context.out_dir + "/main/tests/pylib"):
91	'print(ntp.util.stdversion())']	96	if ctx.env["PYTHON_ARGPARSE"]:
92	p = waflib.Utils.subprocess.Popen(cmd, env={'PYTHONPATH': '%s/main/tests/pylib' %	97	cmd_map_python.update(cmd_map_python_argparse)
93	waflib.Context.out_dir},	98	if ctx.env["PYTHON_CURSES"]:
94	universal_newlines=True,	99	cmd_map_python.update(cmd_map_python_curses)
95	stdin=waflib.Utils.subprocess.PIPE,	100	for cmd in sorted(cmd_map_python):
96	stdout=waflib.Utils.subprocess.PIPE,	101	if not run(cmd, cmd_map_python[cmd] % version, ctx.env["PYTHON"]):
97	stderr=waflib.Utils.subprocess.PIPE, cwd=waflib.Context.out_dir)	102	fails += 1
98	version = p.communicate()[0].rstrip()
99
100	if ctx.env['PYTHON_ARGPARSE']:
101	cmd_map_python.update(cmd_map_python_argparse)
102
103	if ctx.env['PYTHON_CURSES']:
104	cmd_map_python.update(cmd_map_python_curses)
105		103
106	for cmd in sorted(cmd_map):	104	for cmd in sorted(cmd_map):
107	if not run(cmd, cmd_map[cmd] % version):	105	if not run(cmd, cmd_map[cmd] % version):
108	fails += 1	106	fails += 1
109		107
110	for cmd in sorted(cmd_map_python):
111	if not run(cmd, cmd_map_python[cmd] % version, ctx.env['PYTHON']):
112	fails += 1
113
114	if 1 == fails:	108	if 1 == fails:
115	bin_test_summary(ctx)	109	bin_test_summary(ctx)
116	ctx.fatal("1 binary test failed!")	110	ctx.fatal("1 binary test failed!")