| # -*- Autoconf -*- |
| # Process this file with autoconf to produce a configure script. |
| |
| # |
| # Copyright (c) 2018-2019 Google LLC |
| # Copyright (c) 2014-2018 Nest Labs, Inc. |
| # All rights reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| # |
| # Description: |
| # This file is the GNU autoconf input source file for the |
| # Nest Labs Weave package. |
| # |
| |
| # |
| # Declare autoconf version requirements |
| # |
| AC_PREREQ([2.68]) |
| |
| # |
| # Initialize autoconf for the package |
| # |
| AC_INIT([Weave], |
| m4_esyscmd([third_party/nlbuild-autotools/repo/scripts/mkversion -b `cat .default-version` .]), |
| [weave.support@nestlabs.com], |
| [weave], |
| [https://developer.nest.com/]) |
| |
| # Tell the rest of the build system the absolute path where the |
| # nlbuild-autotools repository is rooted at. |
| |
| AC_SUBST(nlbuild_autotools_stem,[third_party/nlbuild-autotools/repo]) |
| AC_SUBST(abs_top_nlbuild_autotools_dir,[\${abs_top_srcdir}/\${nlbuild_autotools_stem}]) |
| |
| # |
| # Weave interface current, revision, and age versions. |
| # |
| # NOTE: At present, the Nest Weave SDK makes NO ABI compatibility |
| # commitments. Consequently, these simply serve as documentation |
| # for how the interfaces have evolved. |
| # |
| # Maintainters: Please manage these fields as follows: |
| # |
| # Interfaces removed: CURRENT++, AGE = 0, REVISION = 0 |
| # Interfaces added: CURRENT++, AGE++, REVISION = 0 |
| # No interfaces changed: REVISION++ |
| # |
| # |
| AC_SUBST(LIBWEAVE_VERSION_CURRENT, [1]) |
| AC_SUBST(LIBWEAVE_VERSION_AGE, [0]) |
| AC_SUBST(LIBWEAVE_VERSION_REVISION, [5]) |
| AC_SUBST(LIBWEAVE_VERSION_INFO, [${LIBWEAVE_VERSION_CURRENT}:${LIBWEAVE_VERSION_REVISION}:${LIBWEAVE_VERSION_AGE}]) |
| |
| # |
| # Check the sanity of the source directory by checking for the |
| # presence of a key watch file |
| # |
| AC_CONFIG_SRCDIR([src/lib/core/WeaveConfig.h]) |
| |
| # |
| # Tell autoconf where to find auxilliary build tools (e.g. config.guess, |
| # install-sh, missing, etc.) |
| # |
| AC_CONFIG_AUX_DIR([build/autoconf]) |
| |
| # |
| # Tell autoconf where to find auxilliary M4 macros |
| # Note that nlbuild-autotools has macros in two subdirs, for local vs third-party scripts |
| # |
| AC_CONFIG_MACRO_DIRS([build/autoconf/m4 third_party/nlbuild-autotools/repo/third_party/autoconf/m4 third_party/nlbuild-autotools/repo/autoconf/m4]) |
| |
| # |
| # Tell autoconf what file the package is using to aggregate C preprocessor |
| # defines. |
| # |
| AC_CONFIG_HEADERS([src/include/BuildConfig.h]) |
| |
| # |
| # Guards against multiple inclusion of the BuildConfig.h |
| # |
| |
| AH_TOP([#ifndef WEAVE_BUILD_CONFIG_H |
| #define WEAVE_BUILD_CONFIG_H]) |
| |
| AH_BOTTOM([#endif // WEAVE_BUILD_CONFIG_H]) |
| |
| # |
| # Figure out what the canonical build, host and target tuples are. |
| # |
| AC_CANONICAL_BUILD |
| AC_CANONICAL_HOST |
| AC_CANONICAL_TARGET |
| |
| # |
| # Mac OS X / Darwin ends up putting some versioning cruft on the end of its |
| # tuple that we don't care about in this script. Create "clean" variables |
| # devoid of it. |
| # |
| |
| NL_FILTERED_CANONICAL_BUILD |
| NL_FILTERED_CANONICAL_HOST |
| NL_FILTERED_CANONICAL_TARGET |
| |
| # |
| # Configure automake with the desired options, indicating that this is not |
| # a native GNU package, that we want "silent" build rules, and that we want |
| # objects built in the same subdirectory as their source rather than collapsed |
| # together at the top-level directory. |
| # |
| # Disable silent build rules by either passing --disable-silent-rules to |
| # configure or passing V=1 to make |
| # |
| AM_INIT_AUTOMAKE([1.14 foreign silent-rules subdir-objects tar-pax no-define]) |
| |
| # |
| # Silent build rules requires at least automake-1.11. Employ |
| # techniques for not breaking earlier versions of automake. |
| # |
| m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) |
| AM_SILENT_RULES([yes]) |
| |
| # |
| # Enable maintainer mode to prevent the package from constantly trying |
| # to rebuild configure, Makefile.in, etc. Rebuilding such files rarely, |
| # if ever, needs to be done "in the field". |
| # |
| # Use the included 'bootstrap' script instead when necessary. |
| # |
| AM_MAINTAINER_MODE |
| |
| # |
| # Check for the target style |
| # |
| WEAVE_TARGET_STYLE= |
| WEAVE_TARGET_STYLE_UNIX=0 |
| WEAVE_TARGET_STYLE_EMBEDDED=0 |
| |
| AC_MSG_CHECKING([for target style]) |
| |
| # The user may have attempted to explicitly specify the target |
| # style. Sanity check it or default to 'auto'. |
| |
| AC_ARG_WITH(target-style, |
| [AS_HELP_STRING([--with-target-style=TARGET], |
| [Specify the target style from one of: auto, embedded or unix @<:@default=auto@:>@.])], |
| [ |
| case "${with_target_style}" in |
| |
| auto|embedded|unix) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_target_style} for --with-target-style]) |
| ;; |
| |
| esac |
| ], |
| [with_target_style=auto]) |
| |
| # At this point, the target style is one of the allowed |
| # values. If it's 'auto' we autodetect it. |
| |
| if test "${with_target_style}" = "auto"; then |
| case ${target_os} in |
| |
| *cygwin*|*darwin*|*linux*|*freebsd*|*netbsd*|*openbsd*) |
| with_target_style=unix |
| ;; |
| |
| *freertos*) |
| with_target_style=embedded |
| ;; |
| |
| *) |
| AC_MSG_RESULT([unknown]) |
| AC_MSG_ERROR([Unsupported target OS ${target_os}]) |
| ;; |
| |
| esac |
| fi |
| |
| WEAVE_TARGET_STYLE=${with_target_style} |
| |
| case ${with_target_style} in |
| |
| embedded) |
| WEAVE_TARGET_STYLE_EMBEDDED=1 |
| ;; |
| |
| unix) |
| WEAVE_TARGET_STYLE_UNIX=1 |
| ;; |
| |
| esac |
| |
| AC_MSG_RESULT(${WEAVE_TARGET_STYLE}) |
| |
| AC_SUBST(WEAVE_TARGET_STYLE) |
| AC_DEFINE_UNQUOTED([WEAVE_TARGET_STYLE],[${WEAVE_TARGET_STYLE}],[Weave target style]) |
| |
| AC_SUBST(WEAVE_TARGET_STYLE_EMBEDDED) |
| AM_CONDITIONAL([WEAVE_TARGET_STYLE_EMBEDDED], [test "${WEAVE_TARGET_STYLE}" = "embedded"]) |
| AC_DEFINE_UNQUOTED([WEAVE_TARGET_STYLE_EMBEDDED],[${WEAVE_TARGET_STYLE_EMBEDDED}],[Define to 1 if you want to use Weave with an embedded (i.e. non-Unix-based) system]) |
| |
| AC_SUBST(WEAVE_TARGET_STYLE_UNIX) |
| AM_CONDITIONAL([WEAVE_TARGET_STYLE_UNIX], [test "${WEAVE_TARGET_STYLE}" = "unix"]) |
| AC_DEFINE_UNQUOTED([WEAVE_TARGET_STYLE_UNIX],[${WEAVE_TARGET_STYLE_UNIX}],[Define to 1 if you want to use Weave with a Unix-based system]) |
| |
| # |
| # Checks for build host programs |
| # |
| |
| # If we are cross-compiling and we are on an embedded target that |
| # doesn't support independent, standalone executables, then all |
| # compiler tests that attempt to create an executable will fail. In |
| # such circumstances, set AC_NO_EXECUTABLES (see http://sourceware.org/ |
| # ml/newlib/2006/msg00353.html). |
| |
| AC_MSG_CHECKING([whether to disable executable checking]) |
| if test "$cross_compiling" = yes -a "${WEAVE_TARGET_STYLE}" = "embedded"; then |
| # AC_NO_EXECUTABLES |
| AC_MSG_RESULT([yes]) |
| else |
| AC_MSG_RESULT([no]) |
| fi |
| |
| # Passing -Werror to GCC-based or -compatible compilers breaks some |
| # autoconf tests (see |
| # http://lists.gnu.org/archive/html/autoconf-patches/2008-09/msg00014.html). |
| # |
| # If -Werror has been passed transform it into -Wno-error. We'll |
| # transform it back later with NL_RESTORE_WERROR. |
| |
| NL_SAVE_WERROR |
| |
| # Check for compilers. |
| # |
| # These should be checked BEFORE we check for and, implicitly, |
| # initialize libtool such that libtool knows what languages it has to |
| # work with. |
| |
| AC_PROG_CPP |
| AC_PROG_CPP_WERROR |
| |
| AC_PROG_CC |
| AC_PROG_CC_C_O |
| |
| AC_PROG_CXXCPP |
| |
| AC_PROG_CXX |
| AC_PROG_CXX_C_O |
| |
| AC_PROG_OBJC |
| AC_PROG_OBJCXX |
| |
| # Check for other compiler toolchain tools. |
| |
| AC_CHECK_TOOL(AR, ar) |
| AC_CHECK_TOOL(RANLIB, ranlib) |
| AC_CHECK_TOOL(OBJCOPY, objcopy) |
| AC_CHECK_TOOL(STRIP, strip) |
| |
| # Check for other host tools. |
| |
| AC_PROG_INSTALL |
| AC_PROG_LN_S |
| |
| AC_PATH_PROG(CMP, cmp) |
| AC_PATH_PROG(PERL, perl) |
| |
| # |
| # Python |
| # |
| # At minimum, a Python interpreter is absolutely required to |
| # auto-generate a number of header files (e.g., ASN1OID.h). |
| # Additionally, Python support is used for one binding of the |
| # Device Manager as well as to run and orchestrate several |
| # unit and functional tests. |
| # |
| |
| # In a normal "build-and-install on 'this' machine" context, |
| # placing Python packages in the normal pythondir and pyexecdir |
| # (typically |
| # lib/pythonPYTHON_VERSION/{dist,site}-packages/PACKAGE) makes |
| # sense. |
| # |
| # However, in our case, we're building and 'installing' for |
| # standalone distrubution to any number of machines for which we |
| # don't know the Python version. In those cases, override |
| # pythondir and pyexec dir. |
| |
| case "${prefix}" in |
| |
| /opt|/usr|/usr/local|NONE) |
| ;; |
| |
| *) |
| am_cv_python_pythondir="\${prefix}/lib/python" |
| am_cv_python_pyexecdir="\${exec_prefix}/lib/python" |
| ;; |
| |
| esac |
| |
| # Check for Python |
| |
| AM_PATH_PYTHON |
| |
| # If a Python interpreter of any color cannot be found, error out. |
| |
| if test "${PYTHON}" = ""; then |
| AC_MSG_ERROR([could not find python: python is required to build this package.]) |
| fi |
| |
| # Check for specific Python packages |
| |
| AC_MSG_CHECKING([for Python setuptools package]) |
| if ${PYTHON} -c 'import setuptools' >/dev/null 2>&1; then |
| have_python_package_setuptools=yes |
| else |
| have_python_package_setuptools=no |
| fi |
| AC_MSG_RESULT(${have_python_package_setuptools}) |
| |
| AC_MSG_CHECKING([for Python wheel package]) |
| if ${PYTHON} -c 'import wheel' >/dev/null 2>&1; then |
| have_python_package_wheel=yes |
| else |
| have_python_package_wheel=no |
| fi |
| AC_MSG_RESULT(${have_python_package_wheel}) |
| |
| |
| # |
| # Checks for specific compiler characteristics |
| # |
| |
| # |
| # Common compiler flags we would like to have. |
| # |
| # -Wall -Wshadow -Wframe-larger-than=9472 -Wtype-limits CC, CXX, OBJC, OBJCXX [unix, embedded] |
| # -fPIC CC, CXX, OBJC, OBJCXX [unix] |
| # -fno-stack-protector CC, CXX, OBJC, OBJCXX [unix] |
| # -fno-exceptions CXX, OBJCXX [unix] |
| # -fobjc-call-cxx-cdtors OBJC, OBJCXX [cocoa] |
| # -fobjc-arc OBJC, OBJCXX [cocoa] |
| # |
| # |
| |
| PROSPECTIVE_CFLAGS="-Wall -Wshadow -Wframe-larger-than=9472 -Wtype-limits" |
| PROSPECTIVE_CXXFLAGS="" |
| PROSPECTIVE_OBJCFLAGS="-fobjc-call-cxx-cdtors -fobjc-arc" |
| PROSPECTIVE_OBJCXXFLAGS="" |
| |
| # Suppress clang-specific warnings about -Wnonportable-include-path. |
| # |
| # -Wnonportable-include-path warns about include paths that can be |
| # problematic. This creates false positives for Weave when compiling |
| # the Weave Addressing and Routing Module (WARM) in which source |
| # directories (e.g. src/warm/...) and public include directories |
| # (e.g. src/include/Warm/...) have identical, and consequently |
| # ambiguous, naming on case-insensitive file systems. |
| |
| case "`basename ${CC}`" in |
| |
| *clang) |
| AX_CHECK_COMPILER_OPTIONS([C], -Wno-nonportable-include-path) |
| ;; |
| |
| esac |
| |
| case "`basename ${CXX}`" in |
| |
| *clang++) |
| AX_CHECK_COMPILER_OPTIONS([C++], -Wno-nonportable-include-path) |
| ;; |
| |
| esac |
| |
| # For the flags that are desired for the "unix" target style, add |
| # those to the set to be checked. For the "embedded" target style, the |
| # Weave system integrator knows best as to what compiler flags should |
| # be added and will have passed them in. |
| |
| if test "${WEAVE_TARGET_STYLE}" = "unix"; then |
| PROSPECTIVE_CFLAGS="${PROSPECTIVE_CFLAGS} -fPIC -fno-stack-protector" |
| PROSPECTIVE_CXXFLAGS="${PROSPECTIVE_CXXFLAGS} -fno-exceptions" |
| fi |
| |
| # Weave intentionally uses derived classes that do not use an explicit |
| # destructor and a virtual one at that. Consequently, do not emit |
| # compiler warnings or errors about it when deletion is performed on |
| # such objects. |
| |
| PROSPECTIVE_CXXFLAGS="${PROSPECTIVE_CXXFLAGS} -Wno-delete-non-virtual-dtor" |
| |
| # Check whether the C++ compiler supports C++11 with GNU |
| # extensions. If it is supported, enable it. Otherwise, proceed |
| # without error or warning. While the Weave code itself does not rely |
| # on the GNU extensions, Android build targets crash when the standard |
| # is set to strict C++11 |
| |
| AX_CXX_COMPILE_STDCXX_11(noext, optional) |
| |
| AM_CONDITIONAL([HAVE_CXX11], [test "x${HAVE_CXX11}" == "x1"]) |
| |
| if test "x${HAVE_CXX11}" == "x1"; then |
| PROSPECTIVE_CXXFLAGS="${PROSPECTIVE_CXXFLAGS} -std=gnu++11" |
| fi |
| |
| AX_CHECK_COMPILER_OPTIONS([C], ${PROSPECTIVE_CFLAGS}) |
| AX_CHECK_COMPILER_OPTIONS([C++], ${PROSPECTIVE_CFLAGS} ${PROSPECTIVE_CXXFLAGS}) |
| |
| # Check for and initialize libtool |
| |
| LT_INIT |
| |
| # |
| # Android support |
| # |
| with_android=no |
| |
| AC_MSG_CHECKING([for an Android target]) |
| |
| case "${target}" in |
| |
| *android*) |
| with_android=yes |
| ;; |
| |
| *) |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ |
| #if !defined(__ANDROID__) || !__ANDROID__ |
| #error "We are not compiling with Android." |
| #endif |
| ]])], |
| [with_android=yes], |
| [with_android=no]) |
| ;; |
| |
| esac |
| |
| AC_MSG_RESULT(${with_android}) |
| |
| AM_CONDITIONAL([WEAVE_WITH_ANDROID], [test "${with_android}" = "yes"]) |
| |
| AC_SUBST(CROSS_SYSROOT, [$lt_sysroot]) |
| # |
| # Weave package-specific build customization options |
| # |
| |
| # |
| # Check for logging style |
| # |
| |
| WEAVE_LOGGING_STYLE= |
| WEAVE_LOGGING_STYLE_ANDROID=0 |
| WEAVE_LOGGING_STYLE_EXTERNAL=0 |
| WEAVE_LOGGING_STYLE_STDIO=0 |
| WEAVE_LOGGING_STYLE_STDIO_WEAK=0 |
| |
| AC_MSG_CHECKING([for logging style]) |
| |
| AC_ARG_WITH(logging-style, |
| [AS_HELP_STRING([--with-logging-style=STYLE], |
| [Specify the logging style from one of: auto, android, stdio, stdio-weak, or external @<:@default=auto@:>@.])], |
| [ |
| case "${with_logging_style}" in |
| |
| android|auto|external|stdio|stdio-weak) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_logging_style} for --with-logging-style]) |
| ;; |
| |
| esac |
| ], |
| [with_logging_style=auto]) |
| |
| # At this point, the logging style is one of the allowed values. If |
| # it's 'auto' we autodetect it. Otherwise, sanity check the specified |
| # value. |
| |
| if test "${with_logging_style}" = "auto"; then |
| |
| if test "${with_android}" = "yes"; then |
| with_logging_style=android |
| |
| elif test "${with_target_style}" = "unix"; then |
| with_logging_style=stdio |
| |
| else |
| with_logging_style=external |
| |
| fi |
| |
| else |
| if test "${with_android}" != "yes"; then |
| if test "${with_logging_style}" = "android"; then |
| AC_MSG_ERROR([Android-style logging may only be specified when building for Android.]) |
| fi |
| fi |
| fi |
| |
| WEAVE_LOGGING_STYLE=${with_logging_style} |
| |
| case ${with_logging_style} in |
| |
| android) |
| WEAVE_LOGGING_STYLE_ANDROID=1 |
| ;; |
| |
| external) |
| WEAVE_LOGGING_STYLE_EXTERNAL=1 |
| ;; |
| |
| stdio) |
| WEAVE_LOGGING_STYLE_STDIO=1 |
| ;; |
| |
| stdio-weak) |
| WEAVE_LOGGING_STYLE_STDIO_WEAK=1 |
| ;; |
| |
| esac |
| |
| AC_MSG_RESULT(${WEAVE_LOGGING_STYLE}) |
| |
| AC_SUBST(WEAVE_LOGGING_STYLE) |
| AC_DEFINE_UNQUOTED([WEAVE_LOGGING_STYLE],[${WEAVE_LOGGING_STYLE}],[Weave logging style]) |
| |
| AC_SUBST(WEAVE_LOGGING_STYLE_ANDROID) |
| AM_CONDITIONAL([WEAVE_LOGGING_STYLE_ANDROID], [test "${WEAVE_LOGGING_STYLE}" = "android"]) |
| AC_DEFINE_UNQUOTED([WEAVE_LOGGING_STYLE_ANDROID],[${WEAVE_LOGGING_STYLE_ANDROID}],[Define to 1 if you want to use Weave with the Android logging system]) |
| |
| AC_SUBST(WEAVE_LOGGING_STYLE_EXTERNAL) |
| AM_CONDITIONAL([WEAVE_LOGGING_STYLE_EXTERNAL], [test "${WEAVE_LOGGING_STYLE}" = "external"]) |
| AC_DEFINE_UNQUOTED([WEAVE_LOGGING_STYLE_EXTERNAL],[${WEAVE_LOGGING_STYLE_EXTERNAL}],[Define to 1 if you want to use Weave with an external (i.e. platform- and integrator-defined) logging system]) |
| |
| AC_SUBST(WEAVE_LOGGING_STYLE_STDIO) |
| AM_CONDITIONAL([WEAVE_LOGGING_STYLE_STDIO], [test "${WEAVE_LOGGING_STYLE}" = "stdio"]) |
| AC_DEFINE_UNQUOTED([WEAVE_LOGGING_STYLE_STDIO],[${WEAVE_LOGGING_STYLE_STDIO}],[Define to 1 if you want to use Weave with a C Standard I/O Library-based logging system]) |
| |
| AC_SUBST(WEAVE_LOGGING_STYLE_STDIO_WEAK) |
| AM_CONDITIONAL([WEAVE_LOGGING_STYLE_STDIO_WEAK], [test "${WEAVE_LOGGING_STYLE}" = "stdio-weak"]) |
| AC_DEFINE_UNQUOTED([WEAVE_LOGGING_STYLE_STDIO_WEAK],[${WEAVE_LOGGING_STYLE_STDIO_WEAK}],[Define to 1 if you want to use Weave with a C Standard I/O Library-based logging system,but override, at link-time an external (i.e. platform- and integrator-defined) logging system]) |
| |
| # |
| # If C Standard I/O logging is used, prepending timestamps before log |
| # lines may be enabled to support test automation and other debugging |
| # activities. |
| # |
| |
| WEAVE_LOGGING_STYLE_STDIO_WITH_TIMESTAMPS=0 |
| |
| AC_MSG_CHECKING([whether to enable stdio logging timestamps]) |
| AC_ARG_ENABLE(stdio-logging-timestamps, |
| [AS_HELP_STRING([--enable-stdio-logging-timestamps],[Enable timestamps in stdio- or stdio-weak- style log output @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| if test "${enableval}" = "yes"; then |
| if test "${WEAVE_LOGGING_STYLE}" != "stdio"; then |
| AC_MSG_ERROR([The Weave logging style must be 'stdio' to use logging timestamps. Use --with-logging-style=stdio Use --with-logging-style=stdio-weak to enable this logging style.]) |
| else |
| WEAVE_LOGGING_STYLE_STDIO_WITH_TIMESTAMPS=1 |
| fi |
| fi |
| |
| enable_stdio_logging_timestamps=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-stdio-logging-timestamps]) |
| ;; |
| |
| esac |
| ], |
| [enable_stdio_logging_timestamps=no]) |
| AC_MSG_RESULT(${enable_stdio_logging_timestamps}) |
| |
| AC_DEFINE_UNQUOTED([WEAVE_LOGGING_STYLE_STDIO_WITH_TIMESTAMPS],[${WEAVE_LOGGING_STYLE_STDIO_WITH_TIMESTAMPS}],[Define to 1 if you want to use Weave with a C Standard I/O Library-based logging system with timestamped log entries]) |
| |
| # |
| # Cocoa support |
| # |
| AC_MSG_CHECKING([whether to build Cocoa support]) |
| AC_ARG_ENABLE(cocoa, |
| [AS_HELP_STRING([--enable-cocoa],[Enable Cocoa support, required for the iOS device manager @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| enable_cocoa=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-cocoa]) |
| ;; |
| |
| esac |
| ], |
| [enable_cocoa=no]) |
| AC_MSG_RESULT(${enable_cocoa}) |
| |
| AM_CONDITIONAL([WEAVE_WITH_COCOA], [test "${enable_cocoa}" = "yes"]) |
| |
| if test "${enable_cocoa}" = "yes" ; then |
| |
| # Check if the Objective C and Objective C++ compilers support |
| # some overall options we want for those sources. |
| |
| AX_CHECK_COMPILER_OPTIONS([Objective C], ${PROSPECTIVE_CFLAGS} ${PROSPECTIVE_OBJCFLAGS}) |
| AX_CHECK_COMPILER_OPTIONS([Objective C++], ${PROSPECTIVE_CFLAGS} ${PROSPECTIVE_CXXFLAGS} ${PROSPECTIVE_OBJCFLAGS} ${PROSPECTIVE_OBJCXXFLAGS}) |
| |
| AC_LANG_PUSH([Objective C++]) |
| |
| # Check for required Cocoa headers. |
| |
| AC_CHECK_HEADERS([Foundation/Foundation.h], |
| [], |
| [ |
| AC_MSG_ERROR(The Cocoa header "$ac_header" is required but cannot be found.) |
| ]) |
| |
| AC_LANG_POP([Objective C++]) |
| fi |
| |
| # |
| # Java support |
| # |
| |
| # Influential external variables for Java support |
| |
| AC_ARG_VAR(JAVA_HOME, [Java SDK root directory]) |
| AC_ARG_VAR(JNI_CPPFLAGS, [Java Native Interface (JNI) C preprocessor flags]) |
| AC_ARG_VAR(JAVAC, [Java class compiler command]) |
| AC_ARG_VAR(JAR, [Java archiver command]) |
| |
| AC_MSG_CHECKING([whether to build Java support]) |
| AC_ARG_ENABLE(java, |
| [AS_HELP_STRING([--disable-java],[Disable Java support, otherwise required for the Android device manager and Nest service support @<:@default=auto@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| auto|no|yes) |
| enable_java=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-java]) |
| ;; |
| |
| esac |
| ], |
| [enable_java=auto]) |
| |
| if test "${enable_java}" = "auto"; then |
| if test "x${JAVA_HOME}" != "x"; then |
| enable_java=yes |
| else |
| enable_java=no |
| fi |
| fi |
| |
| AC_MSG_RESULT(${enable_java}) |
| |
| # If Java support has been requested, then check for the relevant Java |
| # headers and tools. |
| |
| if test "${enable_java}" = "yes" ; then |
| # Check for Java |
| |
| # If a specific set of JNI_INCLUDE_DIRS has *not* been given, attempt |
| # to locate the JNI include dirs from JAVA_HOME or the location of |
| # javac. |
| if test "x${JNI_INCLUDE_DIRS}" = "x" ; then |
| AC_JNI_INCLUDE_DIR |
| fi |
| |
| if test "x${JNI_INCLUDE_DIRS}" != "x" ; then |
| for dir in ${JNI_INCLUDE_DIRS} ; do |
| JNI_CPPFLAGS="${JNI_CPPFLAGS} -I${dir}" |
| done |
| |
| AC_SUBST(JNI_CPPFLAGS) |
| fi |
| |
| AC_PATH_PROG([JAVAC], [javac], [], [${JAVA_HOME:+${JAVA_HOME}/bin}${PATH_SEPARATOR}${PATH}]) |
| AC_PATH_PROG([JAR], [jar], [], [${JAVA_HOME:+${JAVA_HOME}/bin}${PATH_SEPARATOR}${PATH}]) |
| fi |
| |
| AM_CONDITIONAL([WEAVE_WITH_JAVA], [test "${enable_java}" = "yes"]) |
| |
| # |
| # Debug and profile instances |
| # |
| AC_MSG_NOTICE([checking whether to build debug and profile instances]) |
| |
| # Debug |
| |
| NL_ENABLE_DEBUG([no]) |
| |
| AM_CONDITIONAL([WEAVE_BUILD_DEBUG], [test "${nl_cv_build_debug}" = "yes"]) |
| |
| # Profile |
| |
| AC_MSG_CHECKING([whether to build profile instances of programs and libraries]) |
| AC_ARG_ENABLE(profile, |
| [AS_HELP_STRING([--disable-profile],[Disable the generation of profile instances @<:@default=yes@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_profile=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-profile]) |
| ;; |
| |
| esac |
| ], |
| [build_profile=no]) |
| AC_MSG_RESULT(${build_profile}) |
| AM_CONDITIONAL([WEAVE_BUILD_PROFILE], [test "${build_profile}" = "yes"]) |
| |
| # |
| # Code coverage and compiler optimization |
| # |
| |
| # Coverage |
| |
| NL_ENABLE_COVERAGE([no]) |
| |
| AM_CONDITIONAL([WEAVE_BUILD_COVERAGE], [test "${nl_cv_build_coverage}" = "yes"]) |
| |
| NL_ENABLE_COVERAGE_REPORTS([auto]) |
| |
| AM_CONDITIONAL([WEAVE_BUILD_COVERAGE_REPORTS], [test "${nl_cv_build_coverage_reports}" = "yes"]) |
| |
| # Optimization |
| |
| NL_ENABLE_OPTIMIZATION([yes]) |
| |
| AM_CONDITIONAL([WEAVE_BUILD_OPTIMIZED], [test "${nl_cv_build_optimized}" = "yes"]) |
| |
| # |
| # Treat Compiler Warnings as Errors |
| # |
| NL_ENABLE_WERROR([no]) |
| |
| # |
| # Tests and tools |
| # |
| AC_MSG_NOTICE([checking whether to build tools and tests]) |
| |
| # Tests |
| |
| NL_ENABLE_TESTS([yes]) |
| |
| AM_CONDITIONAL([WEAVE_BUILD_TESTS], [test "${nl_cv_build_tests}" = "yes"]) |
| |
| NL_ENABLE_LONG_TESTS([no]) |
| |
| AM_CONDITIONAL([WEAVE_RUN_LONG_TESTS], [test "${nl_cv_build_long_tests}" = "yes"]) |
| |
| # Tools |
| |
| AC_MSG_CHECKING([whether to build tools]) |
| AC_ARG_ENABLE(tools, |
| [AS_HELP_STRING([--disable-tools],[Disable building of tools @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_tools=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-tools]) |
| ;; |
| |
| esac |
| ], |
| [build_tools=yes]) |
| AC_MSG_RESULT(${build_tools}) |
| AM_CONDITIONAL([WEAVE_BUILD_TOOLS], [test "${build_tools}" = "yes"]) |
| |
| # Happy |
| |
| AC_MSG_CHECKING([checking whether to run functional tests with Happy]) |
| AC_ARG_WITH(happy, |
| [AS_HELP_STRING([--with-happy=HAPPY], |
| [Run Weave functional tests using the Nest Labs network functional test framework (Happy): yes, no, auto, or a path to the Nest Labs network functional test framework (Happy) [default=auto].])], |
| [ |
| case "${with_happy}" in |
| |
| no|yes) |
| ;; |
| |
| *) |
| configure_happy_path=${with_happy} |
| happy_path="${with_happy}/lib/python${am_cv_python_version}/site-packages/" |
| with_happy=yes |
| ;; |
| esac |
| ], |
| [with_happy=auto]) |
| if test "${nl_cv_build_tests}" != "yes"; then |
| with_happy=no |
| happy_path="-" |
| else |
| if test -n ${happy_path}; then |
| grep "Nest Labs" ${configure_happy_path}/setup.py &> /dev/null |
| if test $? = 0; then |
| AC_MSG_ERROR(["You have specified a valid path, ${configure_happy_path} to a Nest Labs network functional test framework (Happy) source directory; however, it does not appear to be built and installed. Please build and install Happy from the specified path, ${configure_happy_path}, and then try again."]) |
| fi |
| if ! test -d ${happy_path}; then |
| AC_MSG_ERROR(["No Nest Labs network functional test framework (Happy) installation could be found at ${configure_happy_path}. Please provide a path to a valid Happy installation."]) |
| fi |
| fi |
| fi |
| if test "${with_happy}" != "no"; then |
| PYTHONPATH=${happy_path}:${PYTHONPATH} python -c 'import happy' 2> /dev/null |
| if test $? != 0; then |
| if test "${with_happy}" = "yes"; then |
| if test -z ${happy_path}; then |
| AC_MSG_ERROR(["The Nest Labs network functional test framework (Happy) was configured with the defaults; however, Happy could not be found in the Python default package locations. Please either install Happy in a default location or invoke 'configure' with an explicit path using '--with-happy=<path to happy>'."]) |
| else |
| AC_MSG_ERROR(["The Nest Labs network functional test framework (Happy) was configured with the path ${happy_path}; however, Happy could neither be found in the Python default package locations and nor at ${happy_path}."]) |
| fi |
| else |
| # with_happy = auto |
| with_happy=no |
| happy_path="-" |
| fi |
| else |
| with_happy=yes |
| fi |
| fi |
| if test "${with_happy}" = "yes"; then |
| HAPPY_MINIMUM_VERSION="1.1.36" |
| happy_version=`PYTHONPATH=${happy_path}:${PYTHONPATH} ${PYTHON} -c 'import happy; print happy.__version__ if "__version__" in dir(happy) else "0.0.0"'` |
| AX_COMPARE_VERSION([${HAPPY_MINIMUM_VERSION}],[gt],[${happy_version}],[AC_MSG_ERROR(["The Nest Labs network functional test framework (Happy) is installed with version ${happy_version}; however, Weave test apps require at least version ${HAPPY_MINIMUM_VERSION}."])],[]) |
| fi |
| AC_MSG_RESULT(${with_happy}) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY], [test "${with_happy}" = "yes"]) |
| AC_SUBST(HAPPY_PATH,[${happy_path}]) |
| |
| AC_MSG_CHECKING([checking whether to run functional tests with Happy against cloud services]) |
| AC_ARG_WITH(happy-service, |
| [AS_HELP_STRING([--with-happy-service=SERVICE], |
| [Run Weave Happy functional tests connecting to cloud services: no or cloud services address [default=no].])], |
| [ |
| case "${with_happy_service}" in |
| |
| no) |
| ;; |
| |
| yes) |
| AC_MSG_ERROR([Invalid value ${with_happy_service} for --with-happy-service]) |
| ;; |
| |
| *) |
| use_happy_service=yes |
| ;; |
| esac |
| ], |
| [use_happy_service=no]) |
| |
| if test "${with_happy}" != "yes"; then |
| if test "${use_happy_service}" = "yes"; then |
| AC_MSG_ERROR(["Nest Labs network functional test framework must be enabled to run tests against cloud services."]) |
| fi |
| fi |
| AC_MSG_RESULT(${use_happy_service}) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_SERVICE], [test "${use_happy_service}" = "yes"]) |
| AC_SUBST(HAPPY_SERVICE,[${with_happy_service}]) |
| |
| AC_MSG_CHECKING([checking whether to use specific DNS servers while running Happy tests]) |
| AC_ARG_WITH(happy-dns, |
| [AS_HELP_STRING([--with-happy-dns=DNS], |
| [Run Weave Happy functional tests using specif DNS servers [default=none].])], |
| [ |
| case "${with_happy_dns}" in |
| |
| no) |
| ;; |
| |
| yes) |
| AC_MSG_ERROR([Invalid value ${with_happy_dns} for --with-happy-dns]) |
| ;; |
| |
| *) |
| use_happy_dns=yes |
| ;; |
| esac |
| ], |
| [use_happy_dns=no]) |
| |
| AC_MSG_RESULT(${use_happy_dns}) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_DNS], [test "${use_happy_dns}" = "yes"]) |
| AC_SUBST(HAPPY_DNS,[${with_happy_dns}]) |
| |
| AC_MSG_CHECKING([checking whether to use specific schema while running data management in mobile client]) |
| AC_ARG_WITH(schema, |
| [AS_HELP_STRING([--with-schema=SCHEMA], |
| [Add custom schema directory for weave data management client support, where the directory needs to include |
| pre-generated schema cpp and header files and CustomBuiltInTraitSchemaDirectory.cpp file. [default=none].])], |
| [ |
| case "${with_schema}" in |
| |
| no) |
| ;; |
| |
| yes) |
| AC_MSG_ERROR([Invalid value ${with_schema} for --with-schema]) |
| ;; |
| |
| *) |
| use_schema=yes |
| ;; |
| esac |
| ], |
| [use_schema=no]) |
| |
| AC_MSG_RESULT(${use_schema}) |
| |
| AM_CONDITIONAL([WEAVE_CONFIG_CUSTOM_BUILTIN_SCHEMA_INCLUDE], [test "${use_schema}" = "yes"]) |
| AC_SUBST(WEAVE_CONFIG_CUSTOM_BUILTIN_SCHEMA_INCLUDE,[${with_schema}]) |
| if test "${use_schema}" = "yes"; then |
| AC_DEFINE_UNQUOTED([WEAVE_CONFIG_CUSTOM_BUILTIN_SCHEMA_INCLUDE],[${WEAVE_CONFIG_CUSTOM_BUILTIN_SCHEMA_INCLUDE}/CustomBuiltInTraitSchemaDirectory.cpp],[Define custom schema directory]) |
| fi |
| |
| # |
| # Happy Service Test Suite |
| # |
| CONFIG_TARGET_SUITES=all |
| |
| AC_MSG_CHECKING([checking which test suite is running while running Happy service tests]) |
| AC_ARG_WITH(happy-test-suite, |
| [AS_HELP_STRING([--with-happy-test-suite=SUITE], |
| [Specify the target test suite from one or more of, separated by commas: minimal, all, wdm, echo, tunnel, time, pairing, bdx, key_export, core, inet, secmgr, servicedir, perf@<:@default=all@:>@.])], |
| [ |
| CONFIG_TARGET_SUITES=`echo ${with_happy_test_suite} | sed -e 's/,/ /g'` |
| for target_suite in ${CONFIG_TARGET_SUITES}; do |
| case "${target_suite}" in |
| |
| perf) |
| if test "${use_happy_service}" = "no"; then |
| AC_MSG_ERROR([Invalid value ${with_happy_test_suite} for --with-happy-test-suite; suite is available only with service tests]) |
| fi |
| ;; |
| |
| bdx | key_export | core | secmgr) |
| if test "${use_happy_service}" = "yes"; then |
| AC_MSG_ERROR([Invalid value ${with_happy_test_suite} for --with-happy-test-suite; suite is available only with standalone tests]) |
| fi |
| ;; |
| |
| yes | no | minimal | all | inet | wdm | echo | tunnel | time | pairing | servicedir) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_happy_test_suite} for --with-happy-test-suite]) |
| ;; |
| |
| esac |
| done |
| ], |
| [with_happy_test_suite=${CONFIG_TARGET_SUITES}]) |
| |
| AC_MSG_RESULT(${with_happy_test_suite}) |
| |
| for target_suite in ${CONFIG_TARGET_SUITES}; do |
| case ${target_suite} in |
| |
| minimal) |
| HAPPY_TEST_USE_ECHO=1 |
| HAPPY_TEST_USE_TUNNEL=1 |
| ;; |
| |
| all) |
| HAPPY_TEST_USE_ECHO=1 |
| HAPPY_TEST_USE_TUNNEL=1 |
| HAPPY_TEST_USE_TIME=1 |
| HAPPY_TEST_USE_PAIRING=1 |
| HAPPY_TEST_USE_WDM=1 |
| HAPPY_TEST_USE_KEY_EXPORT=1 |
| HAPPY_TEST_USE_BDX=1 |
| HAPPY_TEST_USE_CORE=1 |
| HAPPY_TEST_USE_INET=1 |
| HAPPY_TEST_USE_SECMGR=1 |
| HAPPY_TEST_USE_SERVICEDIR=1 |
| ;; |
| |
| wdm) |
| HAPPY_TEST_USE_WDM=1 |
| ;; |
| |
| echo) |
| HAPPY_TEST_USE_ECHO=1 |
| ;; |
| |
| tunnel) |
| HAPPY_TEST_USE_TUNNEL=1 |
| ;; |
| |
| time) |
| HAPPY_TEST_USE_TIME=1 |
| ;; |
| |
| pairing) |
| HAPPY_TEST_USE_PAIRING=1 |
| ;; |
| |
| key_export) |
| HAPPY_TEST_USE_KEY_EXPORT=1 |
| ;; |
| |
| perf) |
| HAPPY_TEST_USE_PERF=1 |
| ;; |
| |
| bdx) |
| HAPPY_TEST_USE_BDX=1 |
| ;; |
| |
| core) |
| HAPPY_TEST_USE_CORE=1 |
| ;; |
| |
| inet) |
| HAPPY_TEST_USE_INET=1 |
| ;; |
| |
| secmgr) |
| HAPPY_TEST_USE_SECMGR=1 |
| ;; |
| |
| servicedir) |
| HAPPY_TEST_USE_SERVICEDIR=1 |
| ;; |
| |
| esac |
| done |
| |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_WDM], [test "${HAPPY_TEST_USE_WDM}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_ECHO], [test "${HAPPY_TEST_USE_ECHO}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_PAIRING], [test "${HAPPY_TEST_USE_PAIRING}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_PERF], [test "${HAPPY_TEST_USE_PERF}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_TUNNEL], [test "${HAPPY_TEST_USE_TUNNEL}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_TIME], [test "${HAPPY_TEST_USE_TIME}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_KEY_EXPORT], [test "${HAPPY_TEST_USE_KEY_EXPORT}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_CORE], [test "${HAPPY_TEST_USE_CORE}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_INET], [test "${HAPPY_TEST_USE_INET}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_BDX], [test "${HAPPY_TEST_USE_BDX}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_SECMGR], [test "${HAPPY_TEST_USE_SECMGR}" = 1]) |
| AM_CONDITIONAL([WEAVE_RUN_HAPPY_SERVICEDIR], [test "${HAPPY_TEST_USE_SERVICEDIR}" = 1]) |
| |
| # |
| # WoBle Control Path and Throughput Test (Woble Test) |
| # |
| |
| AC_MSG_CHECKING([whether to build WoBle Test]) |
| AC_ARG_ENABLE(woble-test, |
| [AS_HELP_STRING([--enable-woble-test],[Enable WoBle Test @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| enable_woble_test=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-woble-test]) |
| ;; |
| |
| esac |
| ], |
| [enable_woble_test=no]) |
| AC_MSG_RESULT(${enable_woble_test}) |
| AM_CONDITIONAL([WEAVE_ENABLE_WOBLE_TEST], [test "${enable_woble_test}" = "yes"]) |
| if test "${enable_woble_test}" = "yes"; then |
| WEAVE_ENABLE_WOBLE_TEST=1 |
| else |
| WEAVE_ENABLE_WOBLE_TEST=0 |
| fi |
| AC_DEFINE_UNQUOTED([WEAVE_ENABLE_WOBLE_TEST],[${WEAVE_ENABLE_WOBLE_TEST}],[Define to 1 if you want to enable WoBle Control Path and Throughput Test.]) |
| |
| # |
| # WARM - Weave Address and Routing Module |
| # |
| |
| AC_MSG_CHECKING([whether to build Warm]) |
| AC_ARG_ENABLE(warm, |
| [AS_HELP_STRING([--disable-warm],[Disable building of the Weave Addressing and Routing Module (WARM) @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_warm=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-warm]) |
| ;; |
| |
| esac |
| ], |
| [build_warm=yes]) |
| AC_MSG_RESULT(${build_warm}) |
| AM_CONDITIONAL([WEAVE_BUILD_WARM], [test "${build_warm}" = "yes"]) |
| |
| # |
| # Weave Tunnel failover support |
| # |
| |
| AC_MSG_CHECKING([whether to build support for Weave Tunnel failover]) |
| AC_ARG_ENABLE(tunnel-failover, |
| [AS_HELP_STRING([--enable-tunnel-failover],[Enable building of Weave tunnel failover @<:@default=yes@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_tunnel_failover=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-tunnel-failover]) |
| ;; |
| |
| esac |
| ], |
| [build_tunnel_failover=no]) |
| AC_MSG_RESULT(${build_tunnel_failover}) |
| |
| if test "${build_tunnel_failover}" = yes; then |
| AC_DEFINE(WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED, 1, [Define to 1 for enabling Weave Tunnel failover]) |
| fi |
| |
| # |
| # Legacy WDM profile support |
| # |
| |
| AC_MSG_CHECKING([whether to build the legacy WDM profile]) |
| AC_ARG_ENABLE(legacy-wdm, |
| [AS_HELP_STRING([--disable-legacy-wdm],[Disable building of the legacy WDM profile @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_legacy_wdm=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-legacy-wdm]) |
| ;; |
| |
| esac |
| ], |
| [build_legacy_wdm=yes]) |
| AC_MSG_RESULT(${build_legacy_wdm}) |
| if test "${build_legacy_wdm}" = yes; then |
| LEGACY_WDM=1 |
| else |
| if test "${build_device_manager}" = "yes"; then |
| AC_MSG_ERROR([The Legacy Weave Data Management profile must be enabled to build the Weave Device Manager]) |
| fi |
| LEGACY_WDM=0 |
| fi |
| AM_CONDITIONAL([WEAVE_BUILD_LEGACY_WDM], [test "${LEGACY_WDM}" = 1]) |
| AC_DEFINE_UNQUOTED([WEAVE_CONFIG_LEGACY_WDM],[${LEGACY_WDM}],[Define to 1 to use the legacy WDM profile.]) |
| |
| # |
| # Documentation |
| # |
| |
| # Determine whether or not documentation (via Doxygen) should be built |
| # or not, with 'auto' as the default and establish a default support |
| # value for GraphViz 'dot' support. |
| |
| NL_ENABLE_DOCS([auto],[NO]) |
| |
| AM_CONDITIONAL(WEAVE_BUILD_DOCS, [test "${nl_cv_build_docs}" = "yes"]) |
| |
| # |
| # Network Technology Layer |
| # |
| AC_MSG_CHECKING([network layer]) |
| AC_ARG_WITH(network-layer, |
| [AS_HELP_STRING([--with-network-layer=LAYER], |
| [Specify the target network layers from one of: ble, inet, or all @<:@default=all@:>@.])], |
| [ |
| case "${with_network_layer}" in |
| |
| ble|inet|all) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_network_layer} for --with-network-layer]) |
| ;; |
| |
| esac |
| ], |
| [with_network_layer=all]) |
| AC_MSG_RESULT(${with_network_layer}) |
| |
| case "${with_network_layer}" in |
| |
| ble) |
| CONFIG_NETWORK_LAYER_BLE=1 |
| CONFIG_NETWORK_LAYER_INET=0 |
| ;; |
| |
| inet) |
| CONFIG_NETWORK_LAYER_BLE=0 |
| CONFIG_NETWORK_LAYER_INET=1 |
| ;; |
| |
| all) |
| CONFIG_NETWORK_LAYER_BLE=1 |
| CONFIG_NETWORK_LAYER_INET=1 |
| ;; |
| |
| esac |
| |
| # NOTE WELL: The following logic is a transitional patch (BLE layer is currently dependent on INET layer) |
| if test ${CONFIG_NETWORK_LAYER_INET} = 0 && test ${CONFIG_NETWORK_LAYER_BLE} = 1; then |
| with_network_layer=all |
| CONFIG_NETWORK_LAYER_INET=1 |
| AC_MSG_NOTICE([NOTE WELL: the BLE layer currently requires the INET layer.]) |
| fi |
| |
| AC_SUBST(CONFIG_NETWORK_LAYER_BLE) |
| AM_CONDITIONAL([CONFIG_NETWORK_LAYER_BLE], [test "${CONFIG_NETWORK_LAYER_BLE}" = 1]) |
| AC_DEFINE_UNQUOTED([CONFIG_NETWORK_LAYER_BLE],[${CONFIG_NETWORK_LAYER_BLE}],[Define to 1 if you want to use Weave with the Bluetooth Low Energy network stack.]) |
| |
| AC_SUBST(CONFIG_NETWORK_LAYER_INET) |
| AM_CONDITIONAL([CONFIG_NETWORK_LAYER_INET], [test "${CONFIG_NETWORK_LAYER_INET}" = 1]) |
| AC_DEFINE_UNQUOTED([CONFIG_NETWORK_LAYER_INET],[${CONFIG_NETWORK_LAYER_INET}],[Define to 1 if you want to use Weave with the Internet Protocol network stack.]) |
| |
| # |
| # OpenWeave Device Layer |
| # |
| AC_MSG_CHECKING([device layer]) |
| AC_ARG_WITH(device-layer, |
| [AS_HELP_STRING([--with-device-layer=LAYER], |
| [Specify the target environment for the Weave Device Layer. Choose one of: efr32, esp32, nrf5, or none @<:@default=none@:>@.])], |
| [ |
| case "${with_device_layer}" in |
| |
| esp32|none) |
| ;; |
| |
| nrf5|none) |
| ;; |
| |
| efr32|none) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_device_layer} for --with-device-layer]) |
| ;; |
| |
| esac |
| ], |
| [with_device_layer=none]) |
| AC_MSG_RESULT(${with_device_layer}) |
| |
| case "${with_device_layer}" in |
| esp32) |
| CONFIG_DEVICE_LAYER=1 |
| WEAVE_DEVICE_LAYER_TARGET=ESP32 |
| WEAVE_DEVICE_LAYER_TARGET_ESP32=1 |
| WEAVE_DEVICE_LAYER_TARGET_NRF5=0 |
| WEAVE_DEVICE_LAYER_TARGET_EFR32=0 |
| ;; |
| |
| nrf5) |
| CONFIG_DEVICE_LAYER=1 |
| WEAVE_DEVICE_LAYER_TARGET=nRF5 |
| WEAVE_DEVICE_LAYER_TARGET_NRF5=1 |
| WEAVE_DEVICE_LAYER_TARGET_ESP32=0 |
| WEAVE_DEVICE_LAYER_TARGET_EFR32=0 |
| ;; |
| |
| efr32) |
| CONFIG_DEVICE_LAYER=1 |
| WEAVE_DEVICE_LAYER_TARGET=EFR32 |
| WEAVE_DEVICE_LAYER_TARGET_EFR32=1 |
| WEAVE_DEVICE_LAYER_TARGET_NRF5=0 |
| WEAVE_DEVICE_LAYER_TARGET_ESP32=0 |
| ;; |
| |
| none) |
| CONFIG_DEVICE_LAYER=0 |
| WEAVE_DEVICE_LAYER_TARGET=NONE |
| WEAVE_DEVICE_LAYER_TARGET_ESP32=0 |
| WEAVE_DEVICE_LAYER_TARGET_NRF5=0 |
| WEAVE_DEVICE_LAYER_TARGET_EFR32=0 |
| ;; |
| |
| esac |
| |
| AC_SUBST(CONFIG_DEVICE_LAYER) |
| AM_CONDITIONAL([CONFIG_DEVICE_LAYER], [test "${CONFIG_DEVICE_LAYER}" = 1]) |
| AC_DEFINE_UNQUOTED([CONFIG_DEVICE_LAYER],[${CONFIG_DEVICE_LAYER}],[Define to 1 if you want to use the OpenWeave Device Layer.]) |
| |
| AC_SUBST(WEAVE_DEVICE_LAYER_TARGET) |
| AC_DEFINE_UNQUOTED([WEAVE_DEVICE_LAYER_TARGET],[${WEAVE_DEVICE_LAYER_TARGET}],[Target platform name for OpenWeave Device Layer.]) |
| |
| AC_SUBST(WEAVE_DEVICE_LAYER_TARGET_EFR32) |
| AM_CONDITIONAL([WEAVE_DEVICE_LAYER_TARGET_EFR32], [test "${WEAVE_DEVICE_LAYER_TARGET_EFR32}" = 1]) |
| AC_DEFINE_UNQUOTED([WEAVE_DEVICE_LAYER_TARGET_EFR32],[${WEAVE_DEVICE_LAYER_TARGET_EFR32}],[Define to 1 if you want to build the OpenWeave Device Layer for Silicon Labs EFR32 platforms.]) |
| |
| AC_SUBST(WEAVE_DEVICE_LAYER_TARGET_ESP32) |
| AM_CONDITIONAL([WEAVE_DEVICE_LAYER_TARGET_ESP32], [test "${WEAVE_DEVICE_LAYER_TARGET_ESP32}" = 1]) |
| AC_DEFINE_UNQUOTED([WEAVE_DEVICE_LAYER_TARGET_ESP32],[${WEAVE_DEVICE_LAYER_TARGET_ESP32}],[Define to 1 if you want to build the OpenWeave Device Layer for the Espressif ESP32.]) |
| |
| AC_SUBST(WEAVE_DEVICE_LAYER_TARGET_NRF5) |
| AM_CONDITIONAL([WEAVE_DEVICE_LAYER_TARGET_NRF5], [test "${WEAVE_DEVICE_LAYER_TARGET_NRF5}" = 1]) |
| AC_DEFINE_UNQUOTED([WEAVE_DEVICE_LAYER_TARGET_NRF5],[${WEAVE_DEVICE_LAYER_TARGET_NRF5}],[Define to 1 if you want to build the OpenWeave Device Layer for Nordic nRF5* platforms.]) |
| |
| if test "${CONFIG_DEVICE_LAYER}" = 1; then |
| AC_DEFINE_UNQUOTED([BLE_PLATFORM_CONFIG_INCLUDE], |
| [<Weave/DeviceLayer/${WEAVE_DEVICE_LAYER_TARGET}/BlePlatformConfig.h>], |
| [Path to BLE platform config header file]) |
| AC_DEFINE_UNQUOTED([INET_PLATFORM_CONFIG_INCLUDE], |
| [<Weave/DeviceLayer/${WEAVE_DEVICE_LAYER_TARGET}/InetPlatformConfig.h>], |
| [Path to Inet Layer platform config header file]) |
| AC_DEFINE_UNQUOTED([SYSTEM_PLATFORM_CONFIG_INCLUDE], |
| [<Weave/DeviceLayer/${WEAVE_DEVICE_LAYER_TARGET}/SystemPlatformConfig.h>], |
| [Path to System Layer platform config header file]) |
| AC_DEFINE_UNQUOTED([WARM_PLATFORM_CONFIG_INCLUDE], |
| [<Weave/DeviceLayer/${WEAVE_DEVICE_LAYER_TARGET}/WarmPlatformConfig.h>], |
| [Path to WARM platform config header file]) |
| AC_DEFINE_UNQUOTED([WEAVE_PLATFORM_CONFIG_INCLUDE], |
| [<Weave/DeviceLayer/${WEAVE_DEVICE_LAYER_TARGET}/WeavePlatformConfig.h>], |
| [Path to Weave platform config header file]) |
| AC_DEFINE_UNQUOTED([WEAVE_DEVICE_PLATFORM_CONFIG_INCLUDE], |
| [<Weave/DeviceLayer/${WEAVE_DEVICE_LAYER_TARGET}/WeaveDevicePlatformConfig.h>], |
| [Path to Weave Device Layer platform config header file]) |
| fi |
| |
| |
| # |
| # WoBle over Bluez Peripheral support |
| # |
| |
| # Only a concern when the BLE layer is enabled. |
| |
| CONFIG_BLE_PLATFORM_BLUEZ=0 |
| enable_woble_bluez="no" |
| |
| NL_WITH_OPTIONAL_INTERNAL_PACKAGE( |
| [BlueZ], |
| [BLUEZ], |
| [bluez], |
| [-lgdbus-internal -lshared-glib], |
| [ |
| # actions if not external |
| # At this time, enable this only for linux, and only if the tests are enabled |
| if test "${nl_cv_build_tests}" = "yes" && test "${CONFIG_NETWORK_LAYER_BLE}" = 1 ; then |
| case "${target}" in |
| |
| *linux*) |
| if test "x${HAVE_CXX11}" == "0"; then |
| AC_MSG_ERROR([BlueZ support requires C++11 compiler]) |
| fi |
| CONFIG_BLE_PLATFORM_BLUEZ=1 |
| enable_woble_bluez="yes" |
| BLUEZ_CPPFLAGS="-I\${abs_top_srcdir}/third_party/bluez/repo/" |
| BLUEZ_LDFLAGS="-L${ac_pwd}/third_party/bluez/repo/gdbus/ -L${ac_pwd}/third_party/bluez/repo/src/" |
| BLUEZ_LIBS="-lgdbus-internal -lshared-glib" |
| ;; |
| |
| *) |
| CONFIG_BLE_PLATFORM_BLUEZ=0 |
| ;; |
| |
| esac |
| fi |
| ], |
| [ # actions if not internal |
| |
| CONFIG_BLE_PLATFORM_BLUEZ=1 |
| enable_woble_bluez="yes" |
| ] |
| ) |
| |
| # Depending on whether bluez has been configured for an internal |
| # location, its directory stem within this package needs to be set |
| # accordingly. In addition, if the location is internal, then we need |
| # to attempt to pull it down using the bootstrap makefile. |
| |
| if test "${nl_with_bluez}" = "internal" && test "${enable_woble_bluez}" = "yes"; then |
| maybe_bluez_dirstem="bluez/repo" |
| bluez_dirstem="third_party/${maybe_bluez_dirstem}" |
| |
| AC_MSG_NOTICE([attempting to create internal ${bluez_dirstem}]) |
| |
| ${MAKE-make} --no-print-directory -C ${srcdir} -f Makefile-bootstrap ${bluez_dirstem} |
| |
| if test $? -ne 0; then |
| AC_MSG_ERROR([failed to create ${bluez_dirstem}. Please check your network connection or the correctness of 'repos.conf']) |
| fi |
| |
| echo " BOOTSTRAP ${bluez_dirstem}" |
| |
| (cd ${srcdir}/${bluez_dirstem} && ./bootstrap) |
| |
| else |
| maybe_bluez_dirstem="" |
| fi |
| |
| AC_SUBST(BLUEZ_SUBDIRS, [${maybe_bluez_dirstem}]) |
| AM_CONDITIONAL([WEAVE_WITH_BLUEZ_INTERNAL], [test "${nl_with_bluez}" = "internal"]) |
| |
| AM_CONDITIONAL([CONFIG_BLE_PLATFORM_BLUEZ], [test "${enable_woble_bluez}" = "yes"]) |
| AC_DEFINE_UNQUOTED([CONFIG_BLE_PLATFORM_BLUEZ],[${CONFIG_BLE_PLATFORM_BLUEZ}],[Define to 1 if you want to enable WoBle over bluez.]) |
| |
| if test "${enable_woble_bluez}" = "yes"; then |
| PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.28, dummy=yes, |
| AC_MSG_ERROR(GLib >= 2.28 is required)) |
| AC_SUBST(GLIB_CFLAGS) |
| AC_SUBST(GLIB_LIBS) |
| |
| PKG_CHECK_MODULES(DBUS, dbus-1 >= 1.6, dummy=yes, |
| AC_MSG_ERROR(D-Bus >= 1.6 is required)) |
| AC_SUBST(DBUS_CFLAGS) |
| AC_SUBST(DBUS_LIBS) |
| |
| AX_CHECK_COMPILER_OPTIONS([C], ${GLIB_CFLAGS} ${DBUS_CFLAGS}) |
| AX_CHECK_COMPILER_OPTIONS([C++], ${GLIB_CFLAGS} ${DBUS_CFLAGS}) |
| fi |
| |
| # |
| # Weave target network stack(s) |
| # |
| CONFIG_TARGET_NETWORKS=sockets |
| |
| AC_MSG_CHECKING([target network]) |
| AC_ARG_WITH(target-network, |
| [AS_HELP_STRING([--with-target-network=NETWORK], |
| [Specify the target network stack from one or more of, separated by commas: sockets or lwip @<:@default=sockets@:>@.])], |
| [ |
| CONFIG_TARGET_NETWORKS=`echo ${with_target_network} | sed -e 's/,/ /g'` |
| |
| for target_network in ${CONFIG_TARGET_NETWORKS}; do |
| case "${target_network}" in |
| |
| lwip|sockets) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_target_network} for --with-target-network]) |
| ;; |
| |
| esac |
| done |
| ], |
| [with_target_network=${CONFIG_TARGET_NETWORKS}]) |
| AC_MSG_RESULT(${with_target_network}) |
| AC_SUBST(CONFIG_TARGET_NETWORKS) |
| AC_DEFINE_UNQUOTED([CONFIG_TARGET_NETWORKS], "${CONFIG_TARGET_NETWORKS}", [Weave target network stack(s)]) |
| |
| WEAVE_SYSTEM_CONFIG_USE_LWIP=0 |
| WEAVE_SYSTEM_CONFIG_USE_SOCKETS=0 |
| |
| for target_network in ${CONFIG_TARGET_NETWORKS}; do |
| case ${target_network} in |
| |
| lwip) |
| WEAVE_SYSTEM_CONFIG_USE_LWIP=1 |
| ;; |
| |
| sockets) |
| WEAVE_SYSTEM_CONFIG_USE_SOCKETS=1 |
| ;; |
| |
| esac |
| done |
| |
| AC_SUBST(WEAVE_SYSTEM_CONFIG_USE_LWIP) |
| AM_CONDITIONAL([WEAVE_SYSTEM_CONFIG_USE_LWIP], [test "${WEAVE_SYSTEM_CONFIG_USE_LWIP}" = 1]) |
| AC_DEFINE_UNQUOTED([WEAVE_SYSTEM_CONFIG_USE_LWIP], [${WEAVE_SYSTEM_CONFIG_USE_LWIP}], |
| [Define to 1 if you want to use LwIP with Weave System Layer.]) |
| |
| AC_SUBST(WEAVE_SYSTEM_CONFIG_USE_SOCKETS) |
| AM_CONDITIONAL([WEAVE_SYSTEM_CONFIG_USE_SOCKETS], [test "${WEAVE_SYSTEM_CONFIG_USE_SOCKETS}" = 1]) |
| AC_DEFINE_UNQUOTED([WEAVE_SYSTEM_CONFIG_USE_SOCKETS], [${WEAVE_SYSTEM_CONFIG_USE_SOCKETS}], |
| [Define to 1 if you want to use BSD sockets with Weave System Layer.]) |
| |
| # |
| # Internet Protocol Network Endpoints |
| # |
| if test ${CONFIG_NETWORK_LAYER_INET} = 1; then |
| AC_MSG_CHECKING([IPv4 enabled]) |
| AC_ARG_ENABLE(ipv4, |
| [AS_HELP_STRING([--disable-ipv4],[Disable the inclusion of IPv4 networking @<:@default=yes@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| enable_ivp4=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-ivp4]) |
| ;; |
| |
| esac |
| ], |
| [enable_ivp4=yes]) |
| AC_MSG_RESULT(${enable_ivp4}) |
| |
| INET_WANT_IPV4=1 |
| |
| if test "${enable_ipv4}" = no; then |
| INET_WANT_IPV4=0 |
| fi |
| |
| AM_CONDITIONAL([INET_WANT_IPV4], [test "${INET_WANT_IPV4}" = 1]) |
| AC_DEFINE_UNQUOTED([INET_WANT_IPV4],[${INET_WANT_IPV4}], [Define to 1 if you want to use Weave with IPv4.]) |
| |
| if test "${INET_WANT_IPV4}" = 1; then |
| AC_DEFINE(INET_CONFIG_ENABLE_IPV4, 1, [Define to 1 for enabling IPv4]) |
| fi |
| |
| AC_MSG_CHECKING([inet network endpoint]) |
| AC_ARG_WITH(inet-endpoint, |
| [AS_HELP_STRING([--with-inet-endpoint=ENDPOINT], |
| [Specify the inet network endpoint from one or more of: raw, tcp, tun, udp @<:@default=all@:>@.])], |
| [ |
| INET_ENDPOINTS=`echo ${with_inet_endpoint} | sed -e 's/,/ /g'` |
| |
| for inet_endpoint in ${INET_ENDPOINTS}; do |
| |
| case "${inet_endpoint}" in |
| |
| dns|raw|tcp|tun|udp|all) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_inet_endpoint} for --with-inet-endpoint]) |
| ;; |
| |
| esac |
| |
| done |
| ], |
| [INET_ENDPOINTS=all]) |
| AC_MSG_RESULT(${with_inet_endpoint}) |
| |
| AC_SUBST(INET_ENDPOINTS) |
| AC_DEFINE_UNQUOTED([INET_ENDPOINTS], "${INET_ENDPOINTS}", [Weave target inet network endpoint(s)]) |
| |
| INET_WANT_ENDPOINT_DNS=0 |
| INET_WANT_ENDPOINT_RAW=0 |
| INET_WANT_ENDPOINT_TCP=0 |
| INET_WANT_ENDPOINT_TUN=0 |
| INET_WANT_ENDPOINT_UDP=0 |
| |
| for wanted_endpoint in ${INET_ENDPOINTS}; do |
| |
| case "${wanted_endpoint}" in |
| |
| dns) |
| INET_WANT_ENDPOINT_DNS=1 |
| ;; |
| |
| raw) |
| INET_WANT_ENDPOINT_RAW=1 |
| ;; |
| |
| tcp) |
| INET_WANT_ENDPOINT_TCP=1 |
| ;; |
| |
| tun) |
| INET_WANT_ENDPOINT_TUN=1 |
| ;; |
| |
| udp) |
| INET_WANT_ENDPOINT_UDP=1 |
| ;; |
| |
| all) |
| INET_WANT_ENDPOINT_DNS=1 |
| INET_WANT_ENDPOINT_RAW=1 |
| INET_WANT_ENDPOINT_TCP=1 |
| INET_WANT_ENDPOINT_TUN=1 |
| INET_WANT_ENDPOINT_UDP=1 |
| ;; |
| esac |
| |
| done |
| |
| if test "${INET_WANT_ENDPOINT_TUN}" = 1; then |
| AC_CHECK_HEADERS(linux/if_tun.h,[AC_SUBST(HAVE_LINUX_IF_TUN_H, [1])], [], []) |
| AC_CHECK_TYPE(struct rtentry, , AC_CHECK_HEADERS(linux/route.h, [AC_SUBST(HAVE_LINUX_ROUTE_H, [1])], [], []), [[#include <net/route.h>]]) |
| AC_CHECK_TYPE(struct in6_rtmsg, , AC_CHECK_HEADERS(linux/ipv6_route.h, [AC_SUBST(HAVE_LINUX_IPV6_ROUTE_H, [1])], [], []), [[#include <net/route.h>]]) |
| # Check whether linux/if_tun.h defines TUNGETIFF. |
| AC_MSG_CHECKING([whether linux/if_tun.h declares TUNGETIFF]) |
| AC_COMPILE_IFELSE([ |
| AC_LANG_PROGRAM( |
| [[ |
| #if HAVE_LINUX_IF_TUN_H |
| # include <linux/if_tun.h> |
| #endif |
| ]], |
| [[ |
| #if !defined(TUNGETIFF) |
| #error "TUNGETIFF is not defined" |
| #endif |
| ]])], |
| [ |
| AC_MSG_RESULT([yes]) |
| AC_DEFINE(HAVE_TUNGETIFF, 1, [Define to 1 if <linux/if_tun.h> header file defines the TUNGETIFF ioctl command.]) |
| ], |
| [ |
| AC_MSG_RESULT([no]) |
| ]) |
| AC_CHECK_TYPES(struct in6_rtmsg, [AC_SUBST(HAVE_IN6_RTMSG, [1])],[],[#include<net/route.h>]) |
| if [[[ "${WEAVE_SYSTEM_CONFIG_USE_LWIP}" -eq 0 ]]] && |
| [[[ "${HAVE_LINUX_IF_TUN_H}" -eq 0 || "${HAVE_IN6_RTMSG}" -eq 0 ]]]; then |
| AC_MSG_NOTICE([Tun EndPoint cannot be enabled for current target |
| WEAVE_SYSTEM_CONFIG_USE_LWIP=$WEAVE_SYSTEM_CONFIG_USE_LWIP, HAVE_LINUX_IF_TUN_H=$HAVE_LINUX_IF_TUN_H, |
| HAVE_IN6_RTMSG=$HAVE_IN6_RTMSG]) |
| INET_WANT_ENDPOINT_TUN=0 |
| fi |
| fi |
| |
| AM_CONDITIONAL([INET_WANT_ENDPOINT_DNS], [test "${INET_WANT_ENDPOINT_DNS}" = 1]) |
| AC_DEFINE_UNQUOTED([INET_WANT_ENDPOINT_DNS],[${INET_WANT_ENDPOINT_DNS}], |
| [Define to 1 if you want to use Weave with the inet dns resolver.]) |
| |
| AM_CONDITIONAL([INET_WANT_ENDPOINT_RAW], [test "${INET_WANT_ENDPOINT_RAW}" = 1]) |
| AC_DEFINE_UNQUOTED([INET_WANT_ENDPOINT_RAW],[${INET_WANT_ENDPOINT_RAW}], |
| [Define to 1 if you want to use Weave with the inet raw endpoint.]) |
| |
| AM_CONDITIONAL([INET_WANT_ENDPOINT_TCP], [test "${INET_WANT_ENDPOINT_TCP}" = 1]) |
| AC_DEFINE_UNQUOTED([INET_WANT_ENDPOINT_TCP],[${INET_WANT_ENDPOINT_TCP}], |
| [Define to 1 if you want to use Weave with the inet tcp endpoint.]) |
| |
| AM_CONDITIONAL([INET_WANT_ENDPOINT_TUN], [test "${INET_WANT_ENDPOINT_TUN}" = 1]) |
| AC_DEFINE_UNQUOTED([INET_WANT_ENDPOINT_TUN],[${INET_WANT_ENDPOINT_TUN}], |
| [Define to 1 if you want to use Weave with the inet tun endpoint.]) |
| |
| AM_CONDITIONAL([INET_WANT_ENDPOINT_UDP], [test "${INET_WANT_ENDPOINT_UDP}" = 1]) |
| AC_DEFINE_UNQUOTED([INET_WANT_ENDPOINT_UDP],[${INET_WANT_ENDPOINT_UDP}], |
| [Define to 1 if you want to use Weave with the inet udp endpoint.]) |
| |
| if test "${INET_WANT_ENDPOINT_DNS}" = 1; then |
| AC_DEFINE(INET_CONFIG_ENABLE_DNS_RESOLVER, 1, [Define to 1 for enabling DNS Resolver]) |
| fi |
| |
| if test "${INET_WANT_ENDPOINT_RAW}" = 1; then |
| AC_DEFINE(INET_CONFIG_ENABLE_RAW_ENDPOINT, 1, [Define to 1 for enabling Raw Endpoint]) |
| fi |
| |
| if test "${INET_WANT_ENDPOINT_TCP}" = 1; then |
| AC_DEFINE(INET_CONFIG_ENABLE_TCP_ENDPOINT, 1, [Define to 1 for enabling TCP Endpoint]) |
| fi |
| |
| if test "${INET_WANT_ENDPOINT_TUN}" = 1; then |
| AC_DEFINE(INET_CONFIG_ENABLE_TUN_ENDPOINT, 1, [Define to 1 for enabling TUN Endpoint (only for LWIP and Linux w/ support)]) |
| fi |
| |
| if test "${INET_WANT_ENDPOINT_UDP}" = 1; then |
| AC_DEFINE(INET_CONFIG_ENABLE_UDP_ENDPOINT, 1, [Define to 1 for enabling UDP Endpoint]) |
| fi |
| fi |
| |
| # Asynchronous DNS |
| AC_MSG_CHECKING([whether to build with asynchronous DNS resolution support]) |
| AC_ARG_ENABLE(adns, |
| [AS_HELP_STRING([--disable-adns],[Disable building of adns @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_adns=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --disable-adns]) |
| ;; |
| |
| esac |
| ], |
| [build_adns=yes]) |
| AC_MSG_RESULT(${build_adns}) |
| |
| AM_CONDITIONAL([INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS], [test "${build_adns}" = "yes"]) |
| |
| if test ${build_adns} = "yes" && test ${INET_WANT_ENDPOINT_DNS} = 1 && test ${WEAVE_SYSTEM_CONFIG_USE_SOCKETS} = 1; then |
| AC_DEFINE(INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS, 1, [Define to 1 for enabling ASYNC DNS]) |
| else |
| AC_DEFINE(INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS, 0, [Define to 0 for disabling ASYNC DNS]) |
| fi |
| |
| |
| # |
| # Device Manager |
| # |
| |
| AC_MSG_CHECKING([whether to build Device Manager wrapper libraries]) |
| AC_ARG_ENABLE(device_manager, |
| [AS_HELP_STRING([--enable-device-manager],[Enable building of Device Manager wrapper libraries @<:@default=yes@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_device_manager=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-device-manager]) |
| ;; |
| |
| esac |
| ], |
| [ |
| # Enable building Device Manager wrapper libraries by default UNLESS the "sockets" network |
| # stack is not enabled. |
| if test ${WEAVE_SYSTEM_CONFIG_USE_SOCKETS} -eq 1; then |
| build_device_manager=yes |
| else |
| build_device_manager=no |
| fi |
| ]) |
| |
| # Fail if Device Manager wrapper libraries are enabled but the "sockets" network stack is not. This combination is |
| # not supported. |
| if test "${build_device_manager}" = "yes"; then |
| if test ${WEAVE_SYSTEM_CONFIG_USE_SOCKETS} -eq 0; then |
| AC_MSG_ERROR([Building Device Manager wrapper libraries requires selecting sockets as a target network stack]) |
| fi |
| fi |
| |
| AC_MSG_RESULT(${build_device_manager}) |
| AM_CONDITIONAL([WEAVE_BUILD_DEVICE_MANAGER], [test "${build_device_manager}" = "yes"]) |
| |
| |
| # |
| # OpenWeave Python installable package (wheel) |
| # |
| |
| AC_MSG_CHECKING([whether to build installable Python package for OpenWeave]) |
| AC_ARG_ENABLE(installable_python_package, |
| [AS_HELP_STRING([--enable-installable-python-package],[Enable building of an installable Python package (wheel) for OpenWeave @<:@default=yes@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| build_installable_python_package=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-installable-python-package]) |
| ;; |
| |
| esac |
| ], |
| [ |
| # By default, enable building an installable Python package iff the setuptools and wheel packages |
| # are available. |
| if test "${have_python_package_setuptools}" == "yes" -a "${have_python_package_wheel}" == "yes"; then |
| build_installable_python_package=yes |
| else |
| build_installable_python_package=no |
| fi |
| ]) |
| |
| # Fail if requested to build an installable Python package but the setuptools and wheel packages |
| # are not available |
| if test "${build_installable_python_package}" = "yes"; then |
| if test "${have_python_package_setuptools}" != "yes"; then |
| AC_MSG_ERROR([The Python setuptools package must be installed in order to build an installable package for OpenWeave]) |
| fi |
| if test "${have_python_package_wheel}" != "yes"; then |
| AC_MSG_ERROR([The Python wheel package must be installed in order to build an installable package for OpenWeave]) |
| fi |
| fi |
| |
| AC_MSG_RESULT(${build_installable_python_package}) |
| AM_CONDITIONAL([WEAVE_BUILD_INSTALLABLE_PYTHON_PACKAGE], [test "${build_installable_python_package}" = "yes"]) |
| |
| |
| # |
| # Verhoeff support |
| # |
| AC_MSG_CHECKING([Verhoeff support]) |
| |
| AC_ARG_ENABLE(verhoeff, |
| [AS_HELP_STRING([--enable-verhoeff],[Enable Verhoeff support @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| enable_verhoeff=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-verhoeff]) |
| ;; |
| |
| esac |
| ], |
| [enable_verhoeff=yes]) |
| |
| AC_MSG_RESULT(${enable_verhoeff}) |
| |
| AM_CONDITIONAL([WEAVE_WITH_VERHOEFF], [test "${enable_verhoeff}" = "yes"]) |
| |
| |
| # |
| # Fuzzing support |
| # |
| AC_MSG_CHECKING([whether to enable fuzzing]) |
| |
| AC_ARG_ENABLE(fuzzing, |
| [AS_HELP_STRING([--enable-fuzzing],[Enable Fuzzing - Requires clang 6.0 or greater @<:@default=no@:>@.])], |
| [ |
| case "${enableval}" in |
| |
| no|yes) |
| enable_fuzzing=${enableval} |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${enableval} for --enable-fuzzing]) |
| ;; |
| |
| esac |
| ], |
| [enable_fuzzing=no]) |
| |
| |
| AC_MSG_RESULT(${enable_fuzzing}) |
| AM_CONDITIONAL([WEAVE_FUZZING_ENABLED], [test "${enable_fuzzing}" = "yes"]) |
| if test "${enable_fuzzing}" = "yes"; then |
| AC_DEFINE(WEAVE_FUZZING_ENABLED, 1, [Define to 1 if support for fuzzing enabled]) |
| fi |
| |
| AC_MSG_CHECKING([enhanced printf facilities]) |
| |
| AC_ARG_WITH(enhanced-printf, |
| [AS_HELP_STRING([--with-enhanced-printf=ENHANCEMENT], |
| [Specify enhancement as one of: none (will use malloc on platforms that support it, will truncate on platforms without malloc support), vcbnsprintf for callback-backed printf, or vsnprintf_ex for vsnprintf variant that skips over the initial portion of a string. @<:@default=none@:>@.])], |
| [ |
| case "${with_enhanced_printf}" in |
| auto|none|vcbprintf|vsnprintf_ex) |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Invalid value ${with_enhanced_printf} for --with-enhanced-printf]) |
| ;; |
| |
| esac |
| ], |
| [with_enhanced_printf=auto]) |
| |
| AC_MSG_CHECKING([enhanced printf facilities arg parsed]) |
| |
| CONFIG_HAVE_VCBPRINTF=0 |
| CONFIG_HAVE_VSNPRINTF_EX=0 |
| |
| if test "${with_enhanced_printf}" = "auto"; then |
| AC_MSG_CHECKING([enhanced printf is auto]) |
| |
| AC_CHECK_HEADERS([stdio.h]) |
| |
| AC_MSG_CHECKING([Does the system provide vsnprintf_ex]) |
| |
| AC_LINK_IFELSE([ |
| AC_LANG_PROGRAM( |
| [[ |
| #include <stdio.h> |
| ]], |
| [[ |
| const char format[] = "%d\n"; |
| const char expected = "1\n"; |
| const char buffer [20]; |
| snprintf_ex(buffer, 2, 1, format, 31); |
| ]])], |
| |
| [AC_MSG_RESULT([yes]) |
| AC_DEFINE(HAVE_VSNPRINTF_EX, 1, [Define to 1 if your libc exports vnsprintf_ex.]) |
| CONFIG_HAVE_VSNPRINTF_EX=1 |
| ], |
| |
| [ |
| AC_MSG_RESULT([no]) |
| AC_DEFINE(HAVE_VSNPRINTF_EX, 0, [Define to 1 if your libc exports vnsprintf_ex.]) |
| ]) |
| |
| AC_MSG_CHECKING([Does the system provide vcbprintf]) |
| |
| AC_LINK_IFELSE([ |
| AC_LANG_PROGRAM( |
| [[ |
| #include <stdarg.h> |
| #include <stdio.h> |
| static void private_callback(char c, void *appState) |
| { |
| (void)c; |
| (void)appState; |
| return; |
| } |
| ]], |
| [[ |
| const char format[] = "%d\n"; |
| const char expected = "1\n"; |
| const char buffer [20]; |
| va_list ap; |
| vcbprintf(private_callback, NULL, format, ap); |
| ]])], |
| |
| [AC_MSG_RESULT([yes]) |
| AC_DEFINE(HAVE_VCBPRINTF, 1, [Define to 1 if your libc exports vcbprintf.]) |
| CONFIG_HAVE_VCBPRINTF=1 |
| ], |
| |
| [ |
| AC_MSG_RESULT([no]) |
| AC_DEFINE(HAVE_VCBPRINTF, 0, [Define to 1 if your libc exports vcbprintf.]) |
| ]) |
| |
| fi |
| |
| WEAVE_ENHANCED_PRINTF=${with_enhanced_printf} |
| |
| case ${with_enhanced_printf} in |
| |
| vcbprintf) |
| CONFIG_HAVE_VCBPRINTF=1 |
| ;; |
| |
| vsnprintf_ex) |
| CONFIG_HAVE_VSNPRINTF_EX=1 |
| ;; |
| |
| esac |
| |
| AC_SUBST(CONFIG_HAVE_VCBPRINTF) |
| AM_CONDITIONAL([CONFIG_HAVE_VCBPRINTF], [test "${CONFIG_HAVE_VCBPRINTF}" = "1"]) |
| AC_DEFINE_UNQUOTED([CONFIG_HAVE_VCBPRINTF],[${CONFIG_HAVE_VCBPRINTF}],[Define to 1 if you want to use Weave with a system that supports callback-based vcbprintf]) |
| |
| AC_SUBST(CONFIG_HAVE_VSNPRINTF_EX) |
| AM_CONDITIONAL([CONFIG_HAVE_VSNPRINTF_EX], [test "${CONFIG_HAVE_VSNPRINTF_EX}" = "1"]) |
| AC_DEFINE_UNQUOTED([CONFIG_HAVE_VSNPRINTF_EX],[${CONFIG_HAVE_VSNPRINTF_EX}],[Define to 1 if you want to use Weave with a system that supports callback-based vcbprintf]) |
| |
| # |
| # Options for the user to specify project-specific configuration files |
| # for various OpenWeave components. |
| # |
| |
| AC_LANG_PUSH([C++]) |
| |
| # SystemLayer |
| |
| NL_CHECK_PROJECT_CONFIG_INCLUDES(weave-system-project-includes, SYSTEM_PROJECT_CONFIG_INCLUDE, SystemProjectConfig.h, Weave System Layer, ${ac_abs_confdir}/build/config/standalone) |
| |
| # BleLayer |
| |
| if test ${CONFIG_NETWORK_LAYER_BLE} = 1; then |
| NL_CHECK_PROJECT_CONFIG_INCLUDES(weave-ble-project-includes, BLE_PROJECT_CONFIG_INCLUDE, BleProjectConfig.h, Weave BLE Layer, ${ac_abs_confdir}/build/config/standalone) |
| fi |
| |
| # InetLayer |
| |
| if test ${CONFIG_NETWORK_LAYER_INET} = 1; then |
| NL_CHECK_PROJECT_CONFIG_INCLUDES(weave-inet-project-includes, INET_PROJECT_CONFIG_INCLUDE, InetProjectConfig.h, Weave Inet Layer, ${ac_abs_confdir}/build/config/standalone) |
| fi |
| |
| # Warm |
| |
| if test "${build_warm}" = "yes"; then |
| NL_CHECK_PROJECT_CONFIG_INCLUDES(weave-warm-project-includes, WARM_PROJECT_CONFIG_INCLUDE, WarmProjectConfig.h, WARM, ${ac_abs_confdir}/build/config/standalone) |
| fi |
| |
| # Core |
| |
| NL_CHECK_PROJECT_CONFIG_INCLUDES(weave-project-includes, WEAVE_PROJECT_CONFIG_INCLUDE, WeaveProjectConfig.h, Weave Core, ${ac_abs_confdir}/build/config/standalone) |
| |
| # Device Layer |
| |
| if test "${CONFIG_DEVICE_LAYER}" = 1; then |
| NL_CHECK_PROJECT_CONFIG_INCLUDES(weave-device-project-includes, WEAVE_DEVICE_PROJECT_CONFIG_INCLUDE, WeaveDeviceProjectConfig.h, Weave Device Layer,) |
| fi |
| |
| AC_LANG_POP([C++]) |
| |
| # |
| # Checks for libraries and packages. |
| # |
| # At minimum, the following are required: |
| # |
| # * nlassert |
| # * nlio |
| # |
| # The following are optional, depending on configuration: |
| # |
| # * curl |
| # * lwip |
| # * nlunit-test |
| # * openssl |
| # * nlfaultinjection |
| # |
| # Most of these are supplied "in package"; however, they may be also |
| # supplied out of package. |
| # |
| AC_MSG_NOTICE([checking package dependencies]) |
| |
| # Check if the build host has pkg-config |
| |
| AC_PATH_PROG([PKG_CONFIG],[pkg-config]) |
| |
| # |
| # CuRL |
| # |
| |
| NL_WITH_OPTIONAL_EXTERNAL_PACKAGE([CURL], |
| [CURL], |
| [libcurl], |
| [-lcurl], |
| [ |
| # Check for required CuRL headers. |
| |
| AC_CHECK_HEADERS([curl/curl.h], |
| [], |
| [ |
| AC_MSG_NOTICE(The CuRL header "$ac_header" is required but cannot be found.) |
| ]) |
| |
| # The header curl/easy.h cannot be included without curl/curl.h. |
| |
| AC_CHECK_HEADERS([curl/easy.h], |
| [], |
| [ |
| AC_MSG_NOTICE(The CuRL header "$ac_header" is required but cannot be found.) |
| ], |
| [ |
| #ifdef HAVE_CURL_CURL_H |
| #include <curl/curl.h> |
| #endif |
| ]) |
| |
| CURL_CPPFLAGS= |
| CURL_LDFLAGS= |
| CURL_LIBS="-lcurl" |
| ] |
| ) |
| |
| AM_CONDITIONAL([WEAVE_WITH_CURL], [test "${nl_with_libcurl}" != ""]) |
| |
| # |
| # OpenSSL |
| # |
| |
| NL_WITH_OPTIONAL_INTERNAL_PACKAGE([OpenSSL], |
| [OPENSSL], |
| [openssl], |
| [-lcrypto], |
| [ |
| # OpenSSL-specific compiler flags we would like to have. |
| # |
| # -fvisibility=hidden CC, CXX, OBJC, OBJCXX [openssl=internal] |
| # -fvisibility-inlines-hidden CXX, OBJCXX [openssl=internal] |
| # |
| # IMPORTANT: Because Weave requires, when --with-openssl=internal has |
| # been specified, a specially-compiled version of OpenSSL, |
| # -fvisibility=hidden is essential when building on linux to |
| # avoid conflicts between Weave's version of OpenSSL and the |
| # native system version. |
| |
| PROSPECTIVE_CFLAGS="-fvisibility=hidden" |
| PROSPECTIVE_CXXFLAGS="-fvisibility-inlines-hidden" |
| |
| AX_CHECK_COMPILER_OPTIONS([C], VISIBILITY_CFLAGS, ${PROSPECTIVE_CFLAGS}) |
| AX_CHECK_COMPILER_OPTIONS([C++], VISIBILITY_CXXFLAGS, ${PROSPECTIVE_CFLAGS} ${PROSPECTIVE_CXXFLAGS}) |
| AX_CHECK_COMPILER_OPTIONS([Objective C], VISIBILITY_OBJCFLAGS, ${PROSPECTIVE_CFLAGS}) |
| AX_CHECK_COMPILER_OPTIONS([Objective C++], VISIBILITY_OBJCXXFLAGS, ${PROSPECTIVE_CFLAGS} ${PROSPECTIVE_CXXFLAGS}) |
| |
| AC_SUBST(VISIBILITY_CFLAGS) |
| AC_SUBST(VISIBILITY_CXXFLAGS) |
| AC_SUBST(VISIBILITY_OBJCFLAGS) |
| AC_SUBST(VISIBILITY_OBJCXXCFLAGS) |
| |
| # At this point, the internal OpenSSL package will be neither |
| # configured nor built, so the normal checks we undertake for an |
| # external package cannot be run here. Simply set the appropriate |
| # variables and trust all will be well. |
| |
| openssl_buildstem=${target} |
| |
| AC_SUBST(openssl_buildstem) |
| |
| OPENSSL_CPPFLAGS="-DWEAVE_WITH_OPENSSL=1 -I${ac_pwd}/third_party/openssl/${openssl_buildstem}/include" |
| OPENSSL_LDFLAGS="-L${ac_pwd}/third_party/openssl/${openssl_buildstem}" |
| OPENSSL_LIBS="-lcrypto" |
| |
| # OpenSSL doesn't support non-colocated source and build |
| # directories. Consequently, we'll need to "shadow" the source |
| # tree. Figure out the best means to do this on the host (native |
| # lndir --slient, native cp -Rs, or our package-local cp -Rs). |
| |
| NL_PROG_LNDIR(${ac_abs_confdir}/${nlbuild_autotools_stem}/tools/host/${nl_filtered_build}/bin/cp, |
| \${top_srcdir}/${nlbuild_autotools_stem}/tools/host/${nl_filtered_build}/bin/cp) |
| |
| # Attempt to map the target system into a reasonable OpenSSL |
| # build configuration target. |
| # |
| # Weave uses a very restrictive, minimal 32-bit only configuration |
| # of OpenSSL, so collapse the specified or detected target down. |
| |
| AC_MSG_CHECKING([OpenSSL target configuration]) |
| |
| case "${target}" in |
| |
| ppc-apple-darwin*) |
| WEAVE_OPENSSL_TARGET=BSD-generic32 |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| ;; |
| |
| *apple-darwin-ios) |
| WEAVE_OPENSSL_TARGET=iphoneos-cross |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| CROSS_TOP="${CROSS_TOP}" |
| CROSS_SDK="${CROSS_SDK}" |
| ;; |
| |
| *86*-apple-darwin*) |
| WEAVE_OPENSSL_TARGET=BSD-generic32 |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| ;; |
| |
| aarch64-apple-darwin | arm*-apple-darwin*) |
| WEAVE_OPENSSL_TARGET=iphoneos-cross |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| CROSS_TOP="${CROSS_TOP}" |
| CROSS_SDK="${CROSS_SDK}" |
| ;; |
| |
| # Android should come before the generic Linux catch-all |
| # case. |
| |
| arm-*-android*) |
| WEAVE_OPENSSL_TARGET=android-armeabi |
| WEAVE_OPENSSL_TARGET_DEFINES="-D__ARM_MAX_ARCH__=8" |
| ;; |
| |
| armv7-*-android*) |
| WEAVE_OPENSSL_TARGET=android-armeabi |
| WEAVE_OPENSSL_TARGET_DEFINES="-march=armv7-a -D__ARM_MAX_ARCH__=8" |
| ;; |
| |
| arm64-*-android*) |
| WEAVE_OPENSSL_TARGET=android64-aarch64 |
| WEAVE_OPENSSL_TARGET_DEFINES="-D__ARM_MAX_ARCH__=8" |
| ;; |
| |
| i386-*-android*) |
| WEAVE_OPENSSL_TARGET=android-x86 |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| ;; |
| |
| x86_64-*-android*) |
| WEAVE_OPENSSL_TARGET=android64 |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| ;; |
| |
| *-*-linux*) |
| WEAVE_OPENSSL_TARGET=linux-generic32 |
| WEAVE_OPENSSL_TARGET_DEFINES="-DL_ENDIAN" |
| ;; |
| |
| arm*-none*) |
| WEAVE_OPENSSL_TARGET=embedded-armv7 |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| ;; |
| |
| *cygwin*) |
| WEAVE_OPENSSL_TARGET=Cygwin |
| WEAVE_OPENSSL_TARGET_DEFINES= |
| ;; |
| |
| *) |
| AC_MSG_ERROR([Unrecognized or unsupported target system ${target}. You may perhaps try an externally-built OpenSSL configuration using either the --with-openssl option or the --with-openssl-headers and --with-openssl-libs options.]) |
| |
| esac |
| |
| AC_MSG_RESULT([${WEAVE_OPENSSL_TARGET}]) |
| |
| AC_SUBST(CROSS_TOP) |
| AC_SUBST(CROSS_SDK) |
| AC_SUBST(WEAVE_OPENSSL_TARGET) |
| AC_SUBST(WEAVE_OPENSSL_TARGET_DEFINES) |
| ], |
| [ |
| # Check for required OpenSSL headers. |
| |
| AC_CHECK_HEADERS([openssl/aes.h] [openssl/bn.h] [openssl/ec.h] [openssl/err.h] [openssl/evp.h] [openssl/sha.h], |
| [], |
| [ |
| AC_MSG_ERROR(The OpenSSL header "$ac_header" is required but cannot be found.) |
| ]) |
| |
| ]) |
| |
| AM_CONDITIONAL([WEAVE_WITH_OPENSSL], [test "${nl_with_openssl}" != "no"]) |
| AM_CONDITIONAL([WEAVE_WITH_OPENSSL_INTERNAL], [test "${nl_with_openssl}" = "internal"]) |
| |
| if test "${nl_with_openssl}" = "no"; then |
| AC_DEFINE([WEAVE_WITH_OPENSSL], [0], [Define to 1 to build Weave with OpenSSL features]) |
| else |
| AC_DEFINE([WEAVE_WITH_OPENSSL], [1], [Define to 1 to build Weave with OpenSSL features]) |
| fi |
| |
| # |
| # LwIP |
| # |
| |
| NL_WITH_LWIP(${WEAVE_SYSTEM_CONFIG_USE_LWIP}) |
| |
| # |
| # Nlio |
| # |
| |
| NL_WITH_PACKAGE( |
| [Nlio], |
| [NLIO], |
| [nlio], |
| [], |
| [ |
| # At this point, the internal Nlio package will be neither |
| # configured nor built, so the normal checks we undertake for an |
| # external package cannot be run here. Simply set the appropriate |
| # variables and trust all will be well. |
| |
| NLIO_CPPFLAGS="-I\${abs_top_srcdir}/third_party/nlio/repo/include" |
| NLIO_LDFLAGS= |
| NLIO_LIBS= |
| ], |
| [ |
| # Check for required Nlio headers. |
| |
| AC_CHECK_HEADERS([nlbyteorder.h], |
| [], |
| [ |
| AC_MSG_ERROR(The nlio header "$ac_header" is required but cannot be found.) |
| ]) |
| ] |
| ) |
| |
| # Depending on whether nlio has been configured for an internal |
| # location, its directory stem within this package needs to be set |
| # accordingly. In addition, if the location is internal, then we need |
| # to attempt to pull it down using the bootstrap makefile. |
| |
| if test "${nl_with_nlio}" = "internal"; then |
| maybe_nlio_dirstem="nlio/repo" |
| nlio_dirstem="third_party/${maybe_nlio_dirstem}" |
| |
| AC_MSG_NOTICE([attempting to create internal ${nlio_dirstem}]) |
| |
| ${MAKE-make} --no-print-directory -C ${srcdir} -f Makefile-bootstrap ${nlio_dirstem} |
| |
| if test $? -ne 0; then |
| AC_MSG_ERROR([failed to create ${nlio_dirstem}. Please check your network connection or the correctness of 'repos.conf']) |
| fi |
| else |
| maybe_nlio_dirstem="" |
| fi |
| |
| AC_SUBST(NLIO_SUBDIRS, [${maybe_nlio_dirstem}]) |
| AM_CONDITIONAL([WEAVE_WITH_NLIO_INTERNAL], [test "${nl_with_nlio}" = "internal"]) |
| |
| # |
| # Nlassert |
| # |
| |
| NL_WITH_PACKAGE( |
| [Nlassert], |
| [NLASSERT], |
| [nlassert], |
| [], |
| [ |
| # At this point, the internal Nlassert package will be neither |
| # configured nor built, so the normal checks we undertake for an |
| # external package cannot be run here. Simply set the appropriate |
| # variables and trust all will be well. |
| |
| NLASSERT_CPPFLAGS="-I\${abs_top_srcdir}/third_party/nlassert/repo/include" |
| NLASSERT_LDFLAGS= |
| NLASSERT_LIBS= |
| ], |
| [ |
| # Check for required Nlassert headers. |
| |
| AC_CHECK_HEADERS([nlassert.h], |
| [], |
| [ |
| AC_MSG_ERROR(The nlassert header "$ac_header" is required but cannot be found.) |
| ]) |
| ] |
| ) |
| |
| # Depending on whether nlassert has been configured for an internal |
| # location, its directory stem within this package needs to be set |
| # accordingly. In addition, if the location is internal, then we need |
| # to attempt to pull it down using the bootstrap makefile. |
| |
| if test "${nl_with_nlassert}" = "internal"; then |
| maybe_nlassert_dirstem="nlassert/repo" |
| nlassert_dirstem="third_party/${maybe_nlassert_dirstem}" |
| |
| AC_MSG_NOTICE([attempting to create internal ${nlassert_dirstem}]) |
| |
| ${MAKE-make} --no-print-directory -C ${srcdir} -f Makefile-bootstrap ${nlassert_dirstem} |
| |
| if test $? -ne 0; then |
| AC_MSG_ERROR([failed to create ${nlassert_dirstem}. Please check your network connection or the correctness of 'repos.conf']) |
| fi |
| else |
| maybe_nlassert_dirstem="" |
| fi |
| |
| AC_SUBST(NLASSERT_SUBDIRS, [${maybe_nlassert_dirstem}]) |
| AM_CONDITIONAL([WEAVE_WITH_NLASSERT_INTERNAL], [test "${nl_with_nlassert}" = "internal"]) |
| |
| # |
| # Nlfaultinjection |
| # |
| |
| NL_WITH_OPTIONAL_INTERNAL_PACKAGE( |
| [Nlfaultinjection], |
| [NLFAULTINJECTION], |
| [nlfaultinjection], |
| [-lnlfaultinjection], |
| [ |
| # At this point, the internal nlfaultinjection package will be neither |
| # configured nor built, so the normal checks we undertake for an |
| # external package cannot be run here. Simply set the appropriate |
| # variables and trust all will be well. |
| |
| NLFAULTINJECTION_CPPFLAGS="-I\${abs_top_srcdir}/third_party/nlfaultinjection/repo/include" |
| NLFAULTINJECTION_LDFLAGS="-L${ac_pwd}/third_party/nlfaultinjection/repo/src" |
| NLFAULTINJECTION_LIBS="-lnlfaultinjection" |
| ], |
| [ |
| # Check for required nlfaultinjection headers. |
| |
| AC_LANG_PUSH([C++]) |
| AC_CHECK_HEADERS([nlfaultinjection.hpp], |
| [], |
| [ |
| AC_MSG_ERROR(The nlfaultinjection header "$ac_header" is required but cannot be found.) |
| ]) |
| AC_LANG_POP([C++]) |
| ] |
| ) |
| |
| # Depending on whether nlfaultinjection has been configured for an internal |
| # location, its directory stem within this package needs to be set |
| # accordingly. In addition, if the location is internal, then we need |
| # to attempt to pull it down using the bootstrap makefile. |
| |
| if test "${nl_with_nlfaultinjection}" = "internal"; then |
| maybe_nlfaultinjection_dirstem="nlfaultinjection/repo" |
| nlfaultinjection_dirstem="third_party/${maybe_nlfaultinjection_dirstem}" |
| |
| AC_MSG_NOTICE([attempting to create internal ${nlfaultinjection_dirstem}]) |
| |
| ${MAKE-make} --no-print-directory -C ${srcdir} -f Makefile-bootstrap ${nlfaultinjection_dirstem} |
| |
| if test $? -ne 0; then |
| AC_MSG_ERROR([failed to create ${nlfaultinjection_dirstem}. Please check your network connection or the correctness of 'repos.conf']) |
| fi |
| else |
| maybe_nlfaultinjection_dirstem="" |
| fi |
| |
| AC_SUBST(NLFAULTINJECTION_SUBDIRS, [${maybe_nlfaultinjection_dirstem}]) |
| AM_CONDITIONAL([WEAVE_WITH_NLFAULTINJECTION], [test "${nl_with_nlfaultinjection}" != "no"]) |
| AM_CONDITIONAL([WEAVE_WITH_NLFAULTINJECTION_INTERNAL], [test "${nl_with_nlfaultinjection}" = "internal"]) |
| |
| if test "${nl_with_nlfaultinjection}" = "no"; then |
| AC_DEFINE([WEAVE_WITH_NLFAULTINJECTION], [0], [Define to 1 to build Weave with nlFaultInjection features]) |
| else |
| AC_DEFINE([WEAVE_WITH_NLFAULTINJECTION], [1], [Define to 1 to build Weave with nlFaultInjection features]) |
| fi |
| |
| if test "${nl_cv_build_tests}" = "yes"; then |
| if test "${nl_with_nlfaultinjection}" = "no"; then |
| AC_MSG_ERROR(Weave tests require nlfaultinjection.) |
| fi |
| fi |
| |
| |
| # |
| # Nlunit-test |
| # |
| |
| if test "${nl_cv_build_tests}" = "yes"; then |
| NL_WITH_PACKAGE( |
| [Nlunit-test], |
| [NLUNIT_TEST], |
| [nlunit_test], |
| [-lnlunit-test], |
| [ |
| # At this point, the internal Nlunit-test package will be neither |
| # configured nor built, so the normal checks we undertake for an |
| # external package cannot be run here. Simply set the appropriate |
| # variables and trust all will be well. |
| |
| NLUNIT_TEST_CPPFLAGS="-I\${abs_top_srcdir}/third_party/nlunit-test/repo/src" |
| NLUNIT_TEST_LDFLAGS="-L${ac_pwd}/third_party/nlunit-test/repo/src" |
| NLUNIT_TEST_LIBS="-lnlunit-test" |
| ], |
| [ |
| # Check for required nlunit-test headers. |
| |
| AC_CHECK_HEADERS([nlunit-test.h], |
| [], |
| [ |
| AC_MSG_ERROR(The nlunit-test header "$ac_header" is required but cannot be found.) |
| ]) |
| ]) |
| fi |
| |
| # Depending on whether nlunit-test has been configured for an internal |
| # location, its directory stem within this package needs to be set |
| # accordingly. In addition, if the location is internal, then we need |
| # to attempt to pull it down using the bootstrap makefile. |
| |
| if test "${nl_with_nlunit_test}" = "internal"; then |
| maybe_nlunit_test_dirstem="nlunit-test/repo" |
| nlunit_test_dirstem="third_party/${maybe_nlunit_test_dirstem}" |
| |
| AC_MSG_NOTICE([attempting to create internal ${nlunit_test_dirstem}]) |
| |
| ${MAKE-make} --no-print-directory -C ${srcdir} -f Makefile-bootstrap ${nlunit_test_dirstem} |
| |
| if test $? -ne 0; then |
| AC_MSG_ERROR([failed to create ${nlunit_test_dirstem}. Please check your network connection or the correctness of 'repos.conf']) |
| fi |
| else |
| maybe_nlunit_test_dirstem="" |
| fi |
| |
| AC_SUBST(NLUNIT_TEST_SUBDIRS, [${maybe_nlunit_test_dirstem}]) |
| AM_CONDITIONAL([WEAVE_WITH_NLUNIT_TEST_INTERNAL], [test "${nl_with_nlunit_test}" = "internal"]) |
| |
| # |
| # Sockets |
| # |
| |
| # Influential external variables for BSD Sockets support |
| |
| AC_ARG_VAR(SOCKETS_CPPFLAGS, [BSD Sockets C preprocessor flags]) |
| AC_ARG_VAR(SOCKETS_LDFLAGS, [BSD Sockets linker flags]) |
| AC_ARG_VAR(SOCKETS_LIBS, [BSD Sockets linker libraries]) |
| |
| |
| # |
| # Check for headers |
| # |
| AC_HEADER_STDBOOL |
| AC_HEADER_STDC |
| |
| AC_CHECK_HEADERS([ctype.h]) |
| AC_CHECK_HEADERS([ifaddrs.h]) |
| AC_CHECK_HEADERS([stdint.h]) |
| AC_CHECK_HEADERS([stdlib.h]) |
| AC_CHECK_HEADERS([string.h]) |
| |
| # Check for netinet/icmp6.h for ICMP6_FILTER support. Both Android and |
| # Mac OS X fail to properly include both netinet/in.h and sys/types.h |
| # in netinet/icmp6.h, making the check fail unless it exists and these |
| # are both also included. |
| |
| AC_CHECK_HEADERS([netinet/in.h]) |
| AC_CHECK_HEADERS([sys/types.h]) |
| AC_CHECK_HEADERS([netinet/icmp6.h], [], [], |
| [ |
| #if HAVE_SYS_TYPES_H |
| # include <sys/types.h> |
| #endif |
| #if HAVE_NETINET_IN_H |
| # include <netinet/in.h> |
| #endif |
| ]) |
| |
| # But, wait, this still isn't enough. Even with all of that, Android |
| # may still not have the ICMP6_FILTER socket option defined. Check for |
| # that too. |
| |
| AC_MSG_CHECKING([whether netinet/icmp6.h declares ICMP6_FILTER]) |
| AC_COMPILE_IFELSE([ |
| AC_LANG_PROGRAM( |
| [[ |
| #if HAVE_SYS_TYPES_H |
| # include <sys/types.h> |
| #endif |
| #if HAVE_NETINET_IN_H |
| # include <netinet/in.h> |
| #endif |
| #if HAVE_NETINET_ICMP6_H |
| # include <netinet/icmp6.h> |
| #endif |
| ]], |
| [[ |
| #if !defined(ICMP6_FILTER) |
| # error "ICMP6_FILTER is not defined" |
| #endif |
| ]])], |
| [ |
| AC_MSG_RESULT([yes]) |
| AC_DEFINE(HAVE_ICMP6_FILTER, 1, [Define to 1 if your <netinet/icmp6.h> header file defines the ICMP6_FILTER socket option.]) |
| ], |
| [ |
| AC_MSG_RESULT([no]) |
| ]) |
| |
| # Check for sys/socket.h for SO_BINDTODEVICE support. |
| |
| AC_CHECK_HEADERS([sys/socket.h]) |
| |
| AC_MSG_CHECKING([whether sys/socket.h declares SO_BINDTODEVICE]) |
| AC_COMPILE_IFELSE([ |
| AC_LANG_PROGRAM( |
| [[ |
| #if HAVE_SYS_SOCKET_H |
| # include <sys/socket.h> |
| #endif |
| ]], |
| [[ |
| #if !defined(SO_BINDTODEVICE) |
| # error "SO_BINDTODEVICE is not defined" |
| #endif |
| ]])], |
| [ |
| AC_MSG_RESULT([yes]) |
| AC_DEFINE(HAVE_SO_BINDTODEVICE, 1, [Define to 1 if your <sys/socket.h> header file defines the SO_BINDTODEVICE socket option.]) |
| ], |
| [ |
| AC_MSG_RESULT([no]) |
| ]) |
| |
| # Check for sys/sockio.h |
| AC_CHECK_HEADERS([sys/sockio.h]) |
| |
| # |
| # Check for types and structures |
| # |
| AC_TYPE_INT8_T |
| AC_TYPE_INT16_T |
| AC_TYPE_INT32_T |
| AC_TYPE_INT64_T |
| AC_TYPE_UINT8_T |
| AC_TYPE_UINT16_T |
| AC_TYPE_UINT32_T |
| AC_TYPE_UINT64_T |
| |
| # |
| # Checks for library functions |
| # |
| |
| CONFIG_HAVE_HEAP=0 |
| |
| if test "${ac_no_link}" != "yes"; then |
| # Check for stdlib memory management functions. |
| AC_CHECK_FUNCS([malloc free realloc strdup], [CONFIG_HAVE_HEAP=1], [CONFIG_HAVE_HEAP=0]) |
| AC_CHECK_FUNCS([memchr memcmp memmove memset]) |
| AC_CHECK_FUNCS([strchr strcmp strlen]) |
| AC_CHECK_FUNCS([snprintf]) |
| |
| # Some versions of Android are missing getifaddrs and |
| # freeifaddrs. Check to see if the target system is such a version. |
| |
| AC_CHECK_FUNCS([getifaddrs freeifaddrs]) |
| |
| # Check for clock_gettime, gettimeofday, settimeofday and localtime. |
| # In some target environments, clock_gettime exists in librt. |
| |
| AC_SEARCH_LIBS([clock_gettime], [rt]) |
| AC_CHECK_FUNCS([clock_gettime gettimeofday localtime]) |
| AC_CHECK_HEADERS([time.h sys/time.h]) |
| AC_CHECK_TYPES([clockid_t], [], [], [[#include <time.h>]]) |
| |
| # Check for clock_settime. This function exists on iOS, however the compiler prevents |
| # reference to it via the use of an "unavailable" attribute. Unfortunately, this goes |
| # unnoticed by autoconf's AC_CHECK_FUNCS macro, hence the need for custom detection code. |
| |
| AC_SEARCH_LIBS([clock_settime], [rt]) |
| AC_MSG_CHECKING([clock_settime]) |
| AC_LINK_IFELSE( |
| [AC_LANG_SOURCE([[ |
| #include <stdlib.h> |
| #include <time.h> |
| int main(int argc, char *argv[]) |
| { |
| clock_settime(CLOCK_REALTIME, NULL); |
| return 0; |
| } |
| ]])], |
| [AC_DEFINE([HAVE_CLOCK_SETTIME], [1], [Define to 1 if you have the `clock_settime' function.]) AC_MSG_RESULT([yes])], |
| [AC_MSG_RESULT([no])] |
| ) |
| |
| # Note that different platforms have different APIs for monotonic timer with sleep time compensation. |
| # CLOCK_BOOTTIME is available in later versions of linux and Android |
| |
| AC_CHECK_DECLS([CLOCK_MONOTONIC, CLOCK_BOOTTIME], [], [], [[#include <time.h>]]) |
| fi |
| |
| AC_SUBST(CONFIG_HAVE_HEAP) |
| AM_CONDITIONAL([CONFIG_HAVE_HEAP], [test "${CONFIG_HAVE_HEAP}" = "1"]) |
| |
| # |
| # Check for POSIX thread (pthread) support |
| # |
| AX_PTHREAD([], []) |
| |
| AC_CHECK_DECL([PTHREAD_NULL], [], [AC_DEFINE([PTHREAD_NULL],[0], [Approximation of PTHREAD_NULL since pthread.h does not define one])], |
| [[#include <pthread.h>]]) |
| |
| # |
| # Check for <new> |
| # |
| AC_LANG_PUSH([C++]) |
| |
| AC_CHECK_HEADERS([new]) |
| |
| AC_LANG_POP([C++]) |
| |
| |
| # Add test enabled macro |
| if test "${nl_cv_build_tests}" = "yes"; then |
| CPPFLAGS="${CPPFLAGS} -DNL_WEAVE_WITH_TESTS" |
| CPPFLAGS="${CPPFLAGS} -DWEAVE_CONFIG_TEST=1" |
| CPPFLAGS="${CPPFLAGS} -DWEAVE_SYSTEM_CONFIG_TEST=1" |
| CPPFLAGS="${CPPFLAGS} -DWEAVE_SYSTEM_CONFIG_PROVIDE_STATISTICS=1" |
| if test ${CONFIG_NETWORK_LAYER_INET} = 1; then |
| CPPFLAGS="${CPPFLAGS} -DINET_CONFIG_TEST=1" |
| fi |
| fi |
| |
| # Add any OpenSSL CPPFLAGS, LDFLAGS, and LIBS |
| |
| CPPFLAGS="${CPPFLAGS} ${OPENSSL_CPPFLAGS}" |
| LDFLAGS="${LDFLAGS} ${OPENSSL_LDFLAGS}" |
| LIBS="${LIBS} ${OPENSSL_LIBS}" |
| |
| # Add any nlunit-test CPPFLAGS, LDFLAGS, and LIBS |
| |
| CPPFLAGS="${CPPFLAGS} ${NLUNIT_TEST_CPPFLAGS}" |
| LDFLAGS="${LDFLAGS} ${NLUNIT_TEST_LDFLAGS}" |
| LIBS="${LIBS} ${NLUNIT_TEST_LIBS}" |
| |
| # Add any nlio CPPFLAGS, LDFLAGS, and LIBS |
| |
| CPPFLAGS="${CPPFLAGS} ${NLIO_CPPFLAGS}" |
| LDFLAGS="${LDFLAGS} ${NLIO_LDFLAGS}" |
| LIBS="${LIBS} ${NLIO_LIBS}" |
| |
| # Add any nlassert CPPFLAGS, LDFLAGS, and LIBS |
| |
| CPPFLAGS="${CPPFLAGS} ${NLASSERT_CPPFLAGS}" |
| LDFLAGS="${LDFLAGS} ${NLASSERT_LDFLAGS}" |
| LIBS="${LIBS} ${NLASSERT_LIBS}" |
| |
| # Add any nlfaultinjection CPPFLAGS, LDFLAGS, and LIBS |
| |
| CPPFLAGS="${CPPFLAGS} ${NLFAULTINJECTION_CPPFLAGS}" |
| LDFLAGS="${LDFLAGS} ${NLFAULTINJECTION_LDFLAGS}" |
| LIBS="${LIBS} ${NLFAULTINJECTION_LIBS}" |
| |
| # Add any code coverage CPPFLAGS, LDFLAGS, and LIBS |
| |
| CPPFLAGS="${CPPFLAGS} ${NL_COVERAGE_CPPFLAGS}" |
| LDFLAGS="${LDFLAGS} ${NL_COVERAGE_LDFLAGS}" |
| LIBS="${LIBS} ${NL_COVERAGE_LIBS}" |
| |
| # Fold in the warning-as-errors flag, unless it was already in effect. |
| |
| if test "${nl_had_CPPFLAGS_werror}" = "no"; then |
| CPPFLAGS="${CPPFLAGS} ${NL_WERROR_CPPFLAGS}" |
| fi |
| |
| # At this point, we can restore the compiler flags to whatever the |
| # user passed in, now that we're clear of an -Werror issues by |
| # transforming -Wno-error back to -Werror. |
| |
| NL_RESTORE_WERROR |
| |
| # Coding Style |
| # |
| # Establish what tool to use and what arguments to pass for the |
| # pretty-check target. |
| |
| AC_SUBST(PRETTY_CHECK, ["\${PERL} \${abs_top_srcdir}/third_party/cstyle/repo/cstyle.pl"]) |
| AC_SUBST(PRETTY_CHECK_ARGS, ["\$(shell cat \${abs_top_srcdir}/build/cstyle/cstyle.options)"]) |
| |
| # Configure any autotools-based subdirectories |
| if test "${nl_with_nlunit_test}" = "internal"; then |
| AC_CONFIG_SUBDIRS([third_party/nlunit-test/repo]) |
| fi |
| |
| if test "${nl_with_nlio}" = "internal"; then |
| AC_CONFIG_SUBDIRS([third_party/nlio/repo]) |
| fi |
| |
| if test "${nl_with_nlassert}" = "internal"; then |
| AC_CONFIG_SUBDIRS([third_party/nlassert/repo]) |
| fi |
| |
| if test "${nl_with_nlfaultinjection}" = "internal"; then |
| AC_CONFIG_SUBDIRS([third_party/nlfaultinjection/repo]) |
| fi |
| |
| if test "${nl_with_bluez}" = "internal" && test "${enable_woble_bluez}" = "yes"; then |
| AC_CONFIG_SUBDIRS([third_party/bluez/repo]) |
| fi |
| |
| # |
| # Identify the various makefiles and auto-generated files for the package |
| # |
| AC_CONFIG_FILES([ |
| Makefile |
| third_party/Makefile |
| third_party/lwip/Makefile |
| third_party/android/platform-system/core-mincrypt/Makefile |
| third_party/micro-ecc/Makefile |
| third_party/openssl/Makefile |
| third_party/openssl-jpake/Makefile |
| src/Makefile |
| src/include/Makefile |
| src/ble/Makefile |
| src/lwip/Makefile |
| src/platform/ble/bluez/Makefile |
| src/system/Makefile |
| src/inet/Makefile |
| src/lib/Makefile |
| src/lib/support/Makefile |
| src/lib/support/verhoeff/Makefile |
| src/wrappers/jni/Makefile |
| src/wrappers/jni/jni-utils/Makefile |
| src/wrappers/jni/security-support/Makefile |
| src/device-manager/cocoa/Makefile |
| src/device-manager/java/Makefile |
| src/device-manager/python/Makefile |
| src/warm/Makefile |
| src/ra-daemon/Makefile |
| src/test-apps/Makefile |
| src/test-apps/wrapper-tests/jni/Makefile |
| src/test-apps/fuzz/Makefile |
| src/tools/weave/Makefile |
| src/tools/misc/Makefile |
| src/examples/Makefile |
| src/adaptations/device-layer/Makefile |
| doc/Makefile |
| ]) |
| |
| # |
| # Generate the auto-generated files for the package |
| # |
| AC_OUTPUT |
| |
| # |
| # Summarize the package configuration |
| # |
| |
| AC_MSG_NOTICE([ |
| |
| Configuration Summary |
| --------------------- |
| Package : ${PACKAGE_NAME} |
| Version : ${PACKAGE_VERSION} |
| Interface : ${LIBWEAVE_VERSION_INFO//:/.} |
| Build system : ${build} |
| Host system : ${host} |
| Target system : ${target} |
| Target architecture : ${target_cpu} |
| Target OS : ${target_os} |
| Target style : ${WEAVE_TARGET_STYLE} |
| Target network layer : ${with_network_layer} |
| Target network system(s) : ${CONFIG_TARGET_NETWORKS} |
| IPv4 enabled : ${enable_ipv4} |
| Internet endpoint(s) : ${INET_ENDPOINTS} |
| Printf enhancements : ${WEAVE_ENHANCED_PRINTF} |
| Android support : ${with_android} |
| Logging style : ${WEAVE_LOGGING_STYLE} |
| Cross compiling : ${cross_compiling} |
| Build shared libraries : ${enable_shared} |
| Build static libraries : ${enable_static} |
| Build debug libraries : ${nl_cv_build_debug} |
| Build profile libraries : ${build_profile} |
| Build optimized libraries : ${nl_cv_build_optimized} |
| Build coverage libraries : ${nl_cv_build_coverage} |
| Build coverage reports : ${nl_cv_build_coverage_reports} |
| Lcov : ${LCOV:--} |
| Genhtml : ${GENHTML:--} |
| Happy : ${with_happy} |
| Happy Path : ${happy_path} |
| Happy Services : ${with_happy_service} |
| Happy Services Test Suites : ${with_happy_test_suite} |
| Happy DNS Servers : ${with_happy_dns} |
| Schema : ${with_schema} |
| Treat warnings as errors : ${nl_cv_warnings_as_errors} |
| Build tests : ${nl_cv_build_tests} |
| Build long running tests : ${nl_cv_build_long_tests} |
| Build tools : ${build_tools} |
| Build Device Manager : ${build_device_manager} |
| Build WARM : ${build_warm} |
| Tunnel Failover support : ${build_tunnel_failover} |
| Build legacy WDM profile : ${build_legacy_wdm} |
| Prefix : ${prefix} |
| Shadow directory program : ${LNDIR} |
| Cocoa support : ${enable_cocoa} |
| Java support : ${enable_java} |
| Java home : ${JAVA_HOME:--} |
| Java Compiler : ${JAVAC:--} |
| Java Native Interface (JNI) compile flags : ${JNI_CPPFLAGS:--} |
| Java Archiver : ${JAR:--} |
| Python executable : ${PYTHON:--} |
| Python version : ${PYTHON_VERSION:--} |
| Python script directory : ${pythondir:--} |
| Python extension directory : ${pyexecdir:--} |
| Verhoeff support : ${enable_verhoeff} |
| Pairing code decoding support : ${enable_pairing_code_decoding} |
| Documentation support : ${nl_cv_build_docs} |
| Doxygen : ${DOXYGEN:--} |
| GraphViz dot : ${DOT:--} |
| PERL : ${PERL:--} |
| BlueZ peripheral support : ${enable_woble_bluez:--} |
| BlueZ source : ${nl_with_bluez:--} |
| BlueZ compile flags : ${BLUEZ_CPPFLAGS:--} |
| Bluez link flags : ${BLUEZ_LDFLAGS:--} |
| Bluez link libraries : ${BLUEZ_LIBS:--} |
| CURL source : ${nl_with_libcurl:--} |
| CURL compile flags : ${CURL_CPPFLAGS:--} |
| CURL link flags : ${CURL_LDFLAGS:--} |
| CURL link libraries : ${CURL_LIBS:--} |
| LwIP source : ${nl_with_lwip:--} |
| LwIP compile flags : ${LWIP_CPPFLAGS:--} |
| LwIP link flags : ${LWIP_LDFLAGS:--} |
| LwIP link libraries : ${LWIP_LIBS:--} |
| OpenSSL source : ${nl_with_openssl} |
| OpenSSL target : ${WEAVE_OPENSSL_TARGET:--} |
| OpenSSL compile flags : ${OPENSSL_CPPFLAGS:--} |
| OpenSSL link flags : ${OPENSSL_LDFLAGS:--} |
| OpenSSL link libraries : ${OPENSSL_LIBS:--} |
| Nlunit-test source : ${nl_with_nlunit_test:--} |
| Nlunit-test compile flags : ${NLUNIT_TEST_CPPFLAGS:--} |
| Nlunit-test link flags : ${NLUNIT_TEST_LDFLAGS:--} |
| Nlunit-test link libraries : ${NLUNIT_TEST_LIBS:--} |
| Nlio source : ${nl_with_nlio:--} |
| Nlio compile flags : ${NLIO_CPPFLAGS:--} |
| Nlio link flags : ${NLIO_LDFLAGS:--} |
| Nlio link libraries : ${NLIO_LIBS:--} |
| Nlassert source : ${nl_with_nlassert:--} |
| Nlassert compile flags : ${NLASSERT_CPPFLAGS:--} |
| Nlassert link flags : ${NLASSERT_LDFLAGS:--} |
| Nlassert link libraries : ${NLASSERT_LIBS:--} |
| Nlfaultinjection source : ${nl_with_nlfaultinjection:--} |
| Nlfaultinjection compile flags : ${NLFAULTINJECTION_CPPFLAGS:--} |
| Nlfaultinjection link flags : ${NLFAULTINJECTION_LDFLAGS:--} |
| Nlfaultinjection link libraries : ${NLFAULTINJECTION_LIBS:--} |
| Sockets compile flags : ${SOCKETS_CPPFLAGS:--} |
| Sockets link flags : ${SOCKETS_LDFLAGS:--} |
| Sockets link libraries : ${SOCKETS_LIBS:--} |
| PThreads compile flags : ${PTHREAD_CFLAGS:--} |
| PThreads link libraries : ${PTHREAD_LIBS:--} |
| C Preprocessor : ${CPP} |
| C Compiler : ${CC} |
| C++ Preprocessor : ${CXXCPP} |
| C++ Compiler : ${CXX} |
| Objective C Compiler : ${OBJC:--} |
| Objective C++ Compiler : ${OBJCXX:--} |
| Archiver : ${AR} |
| Archive Indexer : ${RANLIB} |
| Symbol Stripper : ${STRIP} |
| Object Copier : ${OBJCOPY} |
| C Preprocessor flags : ${CPPFLAGS:--} |
| C Compile flags : ${CFLAGS:--} |
| C++ Compile flags : ${CXXFLAGS:--} |
| Objective C Compile flags : ${OBJCFLAGS:--} |
| Objective C++ Compile flags : ${OBJCXXFLAGS:--} |
| Symbol Visibility C Compile flags : ${VISIBILITY_CFLAGS:--} |
| Symbol Visibility C++ Compile flags : ${VISIBILITY_CXXFLAGS:--} |
| Symbol Visibility Objective C Compile flags : ${VISIBILITY_OBJCFLAGS:--} |
| Symbol Visibility Objective C++ Compile flags : ${VISIBILITY_OBJCXXFLAGS:--} |
| Link flags : ${LDFLAGS:--} |
| Link libraries : ${LIBS} |
| Fuzzing Enabled : ${enable_fuzzing} |
| ]) |