"Fossies" - the Fresh Open Source Software Archive

Member "dbus-1.13.18/configure.ac" (2 Jul 2020, 63401 Bytes) of package /linux/misc/dbus-1.13.18.tar.xz:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. See also the latest Fossies "Diffs" side-by-side code changes report for "configure.ac": 1.13.16_vs_1.13.18.

    1 dnl -*- mode: m4 -*-
    2 AC_PREREQ([2.63])
    3 
    4 m4_define([dbus_major_version], [1])
    5 m4_define([dbus_minor_version], [13])
    6 m4_define([dbus_micro_version], [18])
    7 m4_define([dbus_version],
    8           [dbus_major_version.dbus_minor_version.dbus_micro_version])
    9 AC_INIT([dbus], [dbus_version], [https://gitlab.freedesktop.org/dbus/dbus/issues], [dbus])
   10 
   11 AC_CONFIG_AUX_DIR([build-aux])
   12 
   13 m4_pattern_forbid([^AX_(CHECK_ENABLE_DEBUG|CODE_COVERAGE|COMPILER_FLAGS|COMPILER_FLAGS_(CFLAGS|CXXFLAGS|LDFLAGS))\b],
   14   [Unexpanded AX_ macro found. Please install GNU autoconf-archive])
   15 
   16 AC_CANONICAL_HOST
   17 
   18 AC_CONFIG_HEADERS([config.h])
   19 AC_CONFIG_MACRO_DIR([m4])
   20 
   21 AM_INIT_AUTOMAKE([1.13 tar-ustar no-dist-gzip dist-xz -Wno-portability subdir-objects foreign])
   22 
   23 GETTEXT_PACKAGE=dbus-1
   24 AC_SUBST(GETTEXT_PACKAGE)
   25 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE",[The name of the gettext domain])
   26 
   27 # By default, rebuild autotools files on demand; only use ./missing if the
   28 # user says --disable-maintainer-mode (some distributions like to do this)
   29 AM_MAINTAINER_MODE([enable])
   30 
   31 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
   32 
   33 AC_DEFINE_UNQUOTED(DBUS_DAEMON_NAME,"dbus-daemon",[Name of executable])
   34 
   35 # libtool versioning - this applies to libdbus
   36 #
   37 # See http://sources.redhat.com/autobook/autobook/autobook_91.html#SEC91 for details
   38 #
   39 
   40 ## increment if the interface has additions, changes, removals.
   41 LT_CURRENT=32
   42 
   43 ## increment any time the source changes; set to
   44 ##  0 if you increment CURRENT
   45 LT_REVISION=0
   46 
   47 ## increment if any interfaces have been added; set to 0
   48 ## if any interfaces have been changed or removed. removal has
   49 ## precedence over adding, so set to 0 if both happened.
   50 LT_AGE=29
   51 
   52 AC_SUBST(LT_CURRENT)
   53 AC_SUBST(LT_REVISION)
   54 AC_SUBST(LT_AGE)
   55 SOVERSION=`expr ${LT_CURRENT} - ${LT_AGE}`
   56 AC_SUBST([SOVERSION])
   57 
   58 DBUS_MAJOR_VERSION=dbus_major_version
   59 DBUS_MINOR_VERSION=dbus_minor_version
   60 DBUS_MICRO_VERSION=dbus_micro_version
   61 DBUS_VERSION=dbus_major_version.dbus_minor_version.dbus_micro_version
   62 
   63 AC_SUBST(DBUS_MAJOR_VERSION)
   64 AC_SUBST(DBUS_MINOR_VERSION)
   65 AC_SUBST(DBUS_MICRO_VERSION)
   66 AC_SUBST(DBUS_VERSION)
   67 
   68 dnl
   69 dnl Build configuration
   70 dnl
   71 
   72 dnl This must come first: other options use this to set their defaults. Don't
   73 dnl enable developer mode on production builds.
   74 AC_ARG_ENABLE([developer],
   75   [AS_HELP_STRING([--enable-developer],
   76     [set defaults to be appropriate for a D-Bus developer instead of a distribution/end-user])],
   77   [enable_developer=$enableval],
   78   [enable_developer=no])
   79 
   80 dnl 'disable_developer' is the negation of 'enable_developer'. If
   81 dnl 'enable-developer' is set to 'no' (the default), the value of
   82 dnl 'disable_developer' is set to 'yes', and vice versa. It's used
   83 dnl for macros that require the opposite of 'enable_developer', such
   84 dnl as several AX_ macros.
   85 dnl See https://bugs.freedesktop.org/show_bug.cgi?id=97357
   86 AS_IF([test "x$enable_developer" = "xyes"],[
   87     disable_developer=no
   88   ],[
   89     disable_developer=yes
   90   ])
   91 
   92 # The debugging check must run before the compiler tests. Other command-line
   93 # options also use it to set their defaults. We disable debugging by default,
   94 # except for developer builds.
   95 AX_CHECK_ENABLE_DEBUG([$enable_developer])
   96 
   97 AC_PROG_CC
   98 AM_PROG_CC_C_O
   99 AC_PROG_CXX
  100 AC_USE_SYSTEM_EXTENSIONS
  101 AC_SYS_LARGEFILE
  102 AC_ISC_POSIX
  103 AC_HEADER_STDC
  104 AC_C_INLINE
  105 AM_PROG_LIBTOOL
  106 AC_PROG_MKDIR_P
  107 PKG_PROG_PKG_CONFIG
  108 
  109 # TAP test driver support
  110 AC_PROG_AWK
  111 AC_REQUIRE_AUX_FILE([tap-driver.sh])
  112 
  113 # This must come before we set up compiler warnings because it assumes
  114 # non-use of -Werror=missing-prototypes
  115 gl_VISIBILITY
  116 AM_CONDITIONAL([HAVE_VISIBILITY], [test "x$HAVE_VISIBILITY" = x1])
  117 
  118 # Initialize libtool
  119 LT_INIT([win32-dll])
  120 LT_LANG([Windows Resource])
  121 
  122 # Set some internal variables depending on the platform for later use.
  123 dbus_win=no
  124 dbus_cygwin=no
  125 dbus_unix=no
  126 case "${host}" in
  127     *-mingw32ce*)
  128         dbus_win=yes
  129         dbus_wince=yes
  130         ;;
  131     *-mingw32*)
  132         dbus_win=yes
  133         ;;
  134     *-cygwin*)
  135         dbus_cygwin=yes
  136         dbus_unix=yes
  137         ;;
  138     *)
  139         dbus_unix=yes
  140        ;;
  141 esac
  142 
  143 # Special defines for certain platforms
  144 if test "$dbus_win" = yes; then
  145     AC_DEFINE(DBUS_WIN,1,[Defined if we run on a W32 API based system])
  146     # Yes, on Windows it really does work like this.
  147     # http://support.microsoft.com/kb/111855
  148     AC_DEFINE(FD_SETSIZE,8192,[The maximum number of connections that can be handled at once])
  149     BUILD_TIMESTAMP=`date --iso-8601=minutes`
  150     AC_SUBST(BUILD_TIMESTAMP)
  151     # Assume DBUS_VERSION is always three numbers
  152     BUILD_FILEVERSION=`echo "$DBUS_VERSION" | sed -e 's/\./,/g'`,0
  153     AC_SUBST(BUILD_FILEVERSION)
  154     # In the CMake build system we generate multiple files, versioninfo-*.rc, with a
  155     # different "internal name" and "original filename", for embedding in multiple
  156     # executables. In the Autotools build system, we currently only generate
  157     # versioninfo.rc and embed it in libdbus-1-${SOVERSION}.dll.
  158     AC_SUBST([DBUS_VER_INTERNAL_NAME], [libdbus-1-${SOVERSION}])
  159     AC_SUBST([DBUS_VER_ORIGINAL_NAME], [libdbus-1-${SOVERSION}.dll])
  160     AC_SUBST([DBUS_VER_FILE_TYPE], [VFT_DLL])
  161     AS_IF([test -z "$RC"],
  162         [AC_MSG_ERROR([An implementation of windres is required])])
  163     if test "$dbus_wince" = yes; then
  164       AC_DEFINE(DBUS_WINCE,1,[Defined if we run on a W32 CE API based system])
  165       AC_DEFINE(_WIN32_WCE, 0x0502, [Defined to get newer W32 CE APIs])
  166     else
  167       AC_DEFINE([_WIN32_WINNT], [0x0600],
  168         [Define to the minimum supported Windows version (0x0600 is Vista)])
  169     fi
  170 else
  171     AC_DEFINE(DBUS_UNIX,1,[Defined if we run on a Unix-based system])
  172 fi
  173 if test "$dbus_cygwin" = yes; then
  174     AC_DEFINE(DBUS_CYGWIN,1,[Defined if we run on a cygwin API based system])
  175 fi
  176 
  177 # For best security, assume that all non-Windows platforms can do
  178 # credentials-passing.
  179 AS_IF([test "$dbus_win" = yes],
  180     [DBUS_SESSION_CONF_MAYBE_AUTH_EXTERNAL="<!--<auth>EXTERNAL</auth>-->"],
  181     [DBUS_SESSION_CONF_MAYBE_AUTH_EXTERNAL="<auth>EXTERNAL</auth>"])
  182 AC_SUBST([DBUS_SESSION_CONF_MAYBE_AUTH_EXTERNAL])
  183 
  184 AM_CONDITIONAL(DBUS_WIN, test "$dbus_win" = yes)
  185 AM_CONDITIONAL(DBUS_WINCE, test "$dbus_wince" = yes)
  186 AM_CONDITIONAL(DBUS_UNIX, test "$dbus_unix" = yes)
  187 AM_CONDITIONAL(DBUS_CYGWIN, test "$dbus_cygwin" = yes)
  188 
  189 DBUS_STATIC_BUILD_CPPFLAGS=
  190 if test "x$enable_shared" = xno; then
  191     # On Windows, linking against the static library requires special effort
  192     # to turn off DLL import/export processing. We normally link some things
  193     # against the dynamic library, but if we're not building that, we'll
  194     # have to link everything statically.
  195     DBUS_STATIC_BUILD_CPPFLAGS=-DDBUS_STATIC_BUILD
  196 fi
  197 AC_SUBST([DBUS_STATIC_BUILD_CPPFLAGS])
  198 
  199 AC_ARG_ENABLE(ansi, AS_HELP_STRING([--enable-ansi],[enable -ansi -pedantic gcc flags]),enable_ansi=$enableval,enable_ansi=no)
  200 AC_ARG_ENABLE(verbose-mode, AS_HELP_STRING([--enable-verbose-mode],[support verbose debug mode]),enable_verbose_mode=$enableval,enable_verbose_mode=$enable_developer)
  201 AC_ARG_ENABLE(asserts, AS_HELP_STRING([--enable-asserts],[include assertion checks]),enable_asserts=$enableval,enable_asserts=$enable_developer)
  202 AC_ARG_ENABLE(checks, AS_HELP_STRING([--enable-checks],[include sanity checks on public API]),enable_checks=$enableval,enable_checks=yes)
  203 AC_ARG_ENABLE(xml-docs, AS_HELP_STRING([--enable-xml-docs],[build XML documentation (requires xmlto)]),enable_xml_docs=$enableval,enable_xml_docs=auto)
  204 AC_ARG_ENABLE(doxygen-docs, AS_HELP_STRING([--enable-doxygen-docs],[build DOXYGEN documentation (requires Doxygen)]),enable_doxygen_docs=$enableval,enable_doxygen_docs=auto)
  205 AC_ARG_ENABLE([ducktype-docs],
  206               AS_HELP_STRING([--enable-ducktype-docs],
  207                              [build Ducktype documentation (requires Ducktype)]),
  208               [enable_ducktype_docs=$enableval], [enable_ducktype_docs=auto])
  209 AC_ARG_ENABLE(selinux, AS_HELP_STRING([--enable-selinux],[build with SELinux support]),enable_selinux=$enableval,enable_selinux=auto)
  210 AC_ARG_ENABLE([apparmor],
  211   [AS_HELP_STRING([--enable-apparmor], [build with AppArmor support])],
  212   [enable_apparmor=$enableval],
  213   [enable_apparmor=auto])
  214 AC_ARG_ENABLE(libaudit,AS_HELP_STRING([--enable-libaudit],[build audit daemon support for SELinux]),enable_libaudit=$enableval,enable_libaudit=auto)
  215 AC_ARG_ENABLE(inotify, AS_HELP_STRING([--enable-inotify],[build with inotify support (linux only)]),enable_inotify=$enableval,enable_inotify=auto)
  216 AC_ARG_ENABLE(kqueue, AS_HELP_STRING([--enable-kqueue],[build with kqueue support]),enable_kqueue=$enableval,enable_kqueue=auto)
  217 AC_ARG_ENABLE(console-owner-file, AS_HELP_STRING([--enable-console-owner-file],[enable console owner file]),enable_console_owner_file=$enableval,enable_console_owner_file=auto)
  218 AC_ARG_ENABLE(launchd, AS_HELP_STRING([--enable-launchd],[build with launchd auto-launch support]),enable_launchd=$enableval,enable_launchd=auto)
  219 AC_ARG_ENABLE(systemd, AS_HELP_STRING([--enable-systemd],[build with systemd at_console support]),enable_systemd=$enableval,enable_systemd=auto)
  220 AC_ARG_ENABLE(traditional-activation, AS_HELP_STRING([--disable-traditional-activation], [Do not build support for service activation without using SystemdService]), enable_traditional_activation="$enableval", enable_traditional_activation=yes)
  221 
  222 AC_ARG_WITH(session-socket-dir, AS_HELP_STRING([--with-session-socket-dir=[dirname]],[Where to put sockets for the per-login-session message bus]))
  223 AC_ARG_WITH(test-socket-dir, AS_HELP_STRING([--with-test-socket-dir=[dirname]],[Where to put sockets for make check]))
  224 AC_ARG_WITH(system-pid-file, AS_HELP_STRING([--with-system-pid-file=[pidfile]],[PID file for systemwide daemon]))
  225 AC_ARG_WITH(system-socket, AS_HELP_STRING([--with-system-socket=[filename]],[UNIX domain socket for systemwide daemon]))
  226 AC_ARG_WITH(console-auth-dir, AS_HELP_STRING([--with-console-auth-dir=[dirname]],[directory to check for console ownerhip]))
  227 AC_ARG_WITH(console-owner-file, AS_HELP_STRING([--with-console-owner-file=[filename]],[file whose owner determines current console owner]))
  228 AC_ARG_WITH(launchd-agent-dir, AS_HELP_STRING([--with-launchd-agent-dir=[dirname]],[directory to put the launchd agent (default: /Library/LaunchAgents)]))
  229 AC_ARG_WITH(dbus_user, AS_HELP_STRING([--with-dbus-user=<user>],[User for running the DBUS daemon (messagebus)]))
  230 AC_ARG_WITH([test_user],
  231   [AS_HELP_STRING([--with-test-user=<user>],
  232     [Unprivileged user for regression tests, other than root and the dbus_user (default: nobody)])])
  233 AC_ARG_WITH(dbus_daemondir, AS_HELP_STRING([--with-dbus-daemondir=[dirname]],[Directory for installing the DBUS daemon]))
  234 
  235 AC_ARG_ENABLE([embedded-tests],
  236   AS_HELP_STRING([--enable-embedded-tests],
  237     [enable unit test code in the library and binaries]),
  238   [], [enable_embedded_tests=$enable_developer])
  239 AC_ARG_ENABLE([modular-tests],
  240   AS_HELP_STRING([--enable-modular-tests],
  241     [enable modular regression tests (requires GLib)]),
  242   [], [enable_modular_tests=auto])
  243 # --enable-tests overrides both --enable-embedded-tests and
  244 # --enable-modular-tests
  245 AC_ARG_ENABLE([tests],
  246   AS_HELP_STRING([--enable-tests],
  247     [enable/disable all tests, overriding embedded-tests/modular-tests]),
  248   [
  249   if test "x$enableval" = xyes; then
  250     AC_MSG_NOTICE([Full test coverage was requested with --enable-tests=yes])
  251     AC_MSG_NOTICE([This requires GLib])
  252   fi
  253   enable_embedded_tests=$enableval
  254   enable_modular_tests=$enableval
  255   ],
  256   [])
  257 
  258 # DBUS_ENABLE_EMBEDDED_TESTS controls unit tests built in to .c files
  259 # and also some stuff in the test/ subdir.
  260 AM_CONDITIONAL([DBUS_ENABLE_EMBEDDED_TESTS],
  261   [test "x$enable_embedded_tests" = xyes])
  262 if test "x$enable_embedded_tests" = xyes; then
  263     AC_DEFINE([DBUS_ENABLE_EMBEDDED_TESTS], [1],
  264       [Define to build test code into the library and binaries])
  265 fi
  266 
  267 # DBUS_ENABLE_MODULAR_TESTS controls tests that work based on public API.
  268 # These use GTest, from GLib, because life's too short. They're enabled by
  269 # default (unless you don't have GLib), because they don't bloat the library
  270 # or binaries.
  271 
  272 dnl Don't do anything too subtle here, because the CMake build system
  273 dnl parses these lines with regular expressions. If necessary, adjust
  274 dnl cmake/modules/MacrosAutotools.cmake to compensate.
  275 AC_DEFINE([GLIB_VERSION_MIN_REQUIRED], [GLIB_VERSION_2_38], [Ignore post-2.38 deprecations])
  276 AC_DEFINE([GLIB_VERSION_MAX_ALLOWED], [G_ENCODE_VERSION(2,44)], [Prevent post-2.44 APIs])
  277 
  278 with_glib=yes
  279 
  280 AS_IF([test "x$enable_modular_tests" != xno],
  281   [
  282   PKG_CHECK_MODULES([GLIB], [glib-2.0 >= 2.40, gio-2.0 >= 2.40],
  283     [
  284       AS_IF([test "x$dbus_unix" = xyes],
  285         [PKG_CHECK_MODULES([GIO_UNIX], [gio-unix-2.0],
  286            [AC_DEFINE([HAVE_GIO_UNIX], [1], [Define if you have gio-unix-2.0])], [])])
  287     ],
  288     [if test "x$enable_modular_tests" = xyes; then
  289       AC_MSG_NOTICE([Full test coverage (--enable-modular-tests=yes or --enable-tests=yes) requires GLib])
  290       AC_MSG_ERROR([$GLIB_ERRORS])
  291     else # assumed to be "auto"
  292       with_glib=no
  293     fi])
  294   ],
  295   [with_glib=no])
  296 
  297 if test "x$enable_modular_tests" != xno; then
  298   AC_DEFINE([DBUS_ENABLE_MODULAR_TESTS], [1],
  299     [Define to build independent test binaries])
  300 fi
  301 AM_CONDITIONAL([DBUS_ENABLE_MODULAR_TESTS],
  302   [test "x$enable_modular_tests" != xno])
  303 
  304 if test "x$with_glib" != xno; then
  305   AC_DEFINE([DBUS_WITH_GLIB], [1],
  306     [Define if GLib, GObject, GIO are available])
  307 fi
  308 AM_CONDITIONAL([DBUS_WITH_GLIB], [test "x$with_glib" != xno])
  309 
  310 AC_ARG_ENABLE([installed-tests],
  311   AS_HELP_STRING([--enable-installed-tests],
  312     [enable unit test code in the library and binaries]),
  313   [], [enable_installed_tests=no])
  314 AM_CONDITIONAL([DBUS_ENABLE_INSTALLED_TESTS],
  315   [test "x$enable_installed_tests" = xyes])
  316 
  317 if test x$enable_verbose_mode = xyes; then
  318     AC_DEFINE(DBUS_ENABLE_VERBOSE_MODE,1,[Support a verbose mode])
  319 fi
  320 
  321 dnl Intentional:
  322 dnl - $DISABLE_WARNINGS disables unused-label warnings if not
  323 dnl   checking or not asserting (tested further below)
  324 dnl - missing field initializers being 0 is a C feature, not a bug
  325 dnl - unused-parameter is to make writing callbacks less annoying
  326 DISABLE_WARNINGS="$DISABLE_WARNINGS
  327                   -Wno-missing-field-initializers
  328                   -Wno-unused-parameter"
  329 
  330 if test x$enable_asserts = xno; then
  331     AC_DEFINE(DBUS_DISABLE_ASSERT,1,[Disable assertion checking])
  332     DISABLE_WARNINGS="$DISABLE_WARNINGS -Wno-unused-label"
  333     R_DYNAMIC_LDFLAG=""
  334     if test x$enable_embedded_tests = xyes; then
  335         DISABLE_WARNINGS="$DISABLE_WARNINGS
  336                           -Wno-unused-but-set-variable
  337                           -Wno-unused-variable
  338                           -Wno-unused-function"
  339     fi
  340 else
  341     # -rdynamic is needed for glibc's backtrace_symbols to work.
  342     # No clue how much overhead this adds, but it's useful
  343     # to do this on any assertion failure,
  344     # so for now it's enabled anytime asserts are (currently not
  345     # in production builds).
  346 
  347     # To get -rdynamic you pass -export-dynamic to libtool.
  348     AC_DEFINE(DBUS_BUILT_R_DYNAMIC,1,[whether -export-dynamic was passed to libtool])
  349     R_DYNAMIC_LDFLAG=-export-dynamic
  350 fi
  351 AC_SUBST(R_DYNAMIC_LDFLAG)
  352 
  353 if test x$enable_checks = xno; then
  354     AC_DEFINE(DBUS_DISABLE_CHECKS,1,[Disable public API sanity checking])
  355     AC_DEFINE(G_DISABLE_CHECKS,1,[Disable GLib public API sanity checking])
  356     DISABLE_WARNINGS="$DISABLE_WARNINGS -Wno-unused-label"
  357 fi
  358 
  359 AH_BOTTOM([
  360 /* explicitly define these macros to get less confusing conditions */
  361 #ifndef DBUS_DISABLE_ASSERT
  362 #  define DBUS_ENABLE_ASSERT 1
  363 #endif
  364 #ifndef DBUS_DISABLE_CHECKS
  365 #  define DBUS_ENABLE_CHECKS 1
  366 #endif])
  367 
  368 # Test for code-coverage tools if --enable-code-coverage
  369 AX_CODE_COVERAGE
  370 
  371 AS_IF([test x$enable_code_coverage = xyes],[
  372     AC_DEFINE_UNQUOTED(
  373       [DBUS_GCOV_ENABLED], [1],
  374       [Defined if gcov is enabled to force a rebuild due to config.h changing])
  375   ])
  376 
  377 #### Simple checks for things with no special dependencies
  378 
  379 # This construct is only suitable for functions that are in the system's
  380 # standard C library and do not have unusual dependencies. Other
  381 # functions need their own checks. Please keep sorted in LC_ALL=C order
  382 AC_CHECK_FUNCS_ONCE([
  383 accept4
  384 clearenv
  385 fpathconf
  386 getgrouplist
  387 getpeereid
  388 getpeerucred
  389 getrandom
  390 getresuid
  391 getrlimit
  392 inotify_init1
  393 issetugid
  394 localeconv
  395 nanosleep
  396 pipe2
  397 poll
  398 prctl
  399 prlimit
  400 raise
  401 setenv
  402 setlocale
  403 setresuid
  404 setrlimit
  405 socketpair
  406 strtoll
  407 strtoull
  408 unsetenv
  409 usleep
  410 ])
  411 
  412 # This construct is only suitable for headers that are self-contained
  413 # and do not require extra headers to be included first. More complex
  414 # headers need their own checks. Please keep sorted in LC_ALL=C order
  415 AC_CHECK_HEADERS_ONCE([
  416 alloca.h
  417 byteswap.h
  418 crt_externs.h
  419 dirent.h
  420 errno.h
  421 locale.h
  422 signal.h
  423 stdint.h
  424 sys/prctl.h
  425 sys/random.h
  426 sys/resource.h
  427 sys/syslimits.h
  428 sys/time.h
  429 unistd.h
  430 ws2tcpip.h
  431 ])
  432 
  433 #### Integer sizes
  434 
  435 AC_CHECK_SIZEOF(char)
  436 AC_CHECK_SIZEOF(short)
  437 AC_CHECK_SIZEOF(long)
  438 AC_CHECK_SIZEOF(int)
  439 AC_CHECK_SIZEOF(void *)
  440 AC_CHECK_SIZEOF(long long)
  441 AC_CHECK_SIZEOF(__int64)
  442 
  443 ### See what our 64 bit type is called
  444 AC_MSG_CHECKING([64-bit integer type])
  445 
  446 case 8 in
  447 $ac_cv_sizeof_int)
  448   dbusint64=int
  449   dbusint64_constant='(val)'
  450   dbusuint64_constant='(val)'
  451   ;;
  452 $ac_cv_sizeof_long)
  453   dbusint64=long
  454   dbusint64_constant='(val##L)'
  455   dbusuint64_constant='(val##UL)'
  456   ;;
  457 $ac_cv_sizeof_long_long)
  458   dbusint64='long long'
  459   dbusint64_constant='(val##LL)'
  460   dbusuint64_constant='(val##ULL)'
  461   ;;
  462 $ac_cv_sizeof___int64)
  463   dbusint64=__int64
  464   dbusint64_constant='(val##i64)'
  465   dbusuint64_constant='(val##ui64)'
  466   ;;
  467 esac
  468 
  469 AS_IF(
  470   [test -z "$dbusint64"],
  471   [AC_MSG_RESULT([not found])
  472   AC_MSG_ERROR([Could not find a 64-bit integer type.
  473 
  474 Please report a bug here with details of your platform and compiler:
  475 
  476     http://bugs.freedesktop.org/enter_bug.cgi?product=DBus&component=core])
  477   ],
  478   dnl else
  479   [
  480         DBUS_INT64_TYPE="$dbusint64"
  481         DBUS_INT64_CONSTANT="$dbusint64_constant"
  482         DBUS_UINT64_CONSTANT="$dbusuint64_constant"
  483         AC_MSG_RESULT($DBUS_INT64_TYPE)
  484   ])
  485 
  486 AC_SUBST(DBUS_INT64_TYPE)
  487 AC_SUBST(DBUS_INT64_CONSTANT)
  488 AC_SUBST(DBUS_UINT64_CONSTANT)
  489 
  490 ### see what 32-bit int is called
  491 AC_MSG_CHECKING([32-bit integer type])
  492 
  493 case 4 in
  494 $ac_cv_sizeof_short)
  495   dbusint32=short
  496   ;;
  497 $ac_cv_sizeof_int)
  498   dbusint32=int
  499   ;;
  500 $ac_cv_sizeof_long)
  501   dbusint32=long
  502   ;;
  503 esac
  504 
  505 if test -z "$dbusint32" ; then
  506         DBUS_INT32_TYPE="no_int32_type_detected"
  507         AC_MSG_ERROR([No 32-bit integer type found])
  508 else
  509         DBUS_INT32_TYPE="$dbusint32"
  510         AC_MSG_RESULT($DBUS_INT32_TYPE)
  511 fi
  512 
  513 AC_SUBST(DBUS_INT32_TYPE)
  514 
  515 ### see what 16-bit int is called
  516 AC_MSG_CHECKING([16-bit integer type])
  517 
  518 case 2 in
  519 $ac_cv_sizeof_short)
  520   dbusint16=short
  521   ;;
  522 $ac_cv_sizeof_int)
  523   dbusint16=int
  524   ;;
  525 esac
  526 
  527 if test -z "$dbusint16" ; then
  528         DBUS_INT16_TYPE="no_int16_type_detected"
  529         AC_MSG_ERROR([No 16-bit integer type found])
  530 else
  531         DBUS_INT16_TYPE="$dbusint16"
  532         AC_MSG_RESULT($DBUS_INT16_TYPE)
  533 fi
  534 
  535 AC_SUBST(DBUS_INT16_TYPE)
  536 
  537 ## byte order
  538 case $host_os in
  539 	darwin*)
  540 		# check at compile-time, so that it is possible to build universal
  541 		# (with multiple architectures at once on the compile line)
  542 		AH_VERBATIM([WORDS_BIGENDIAN_DARWIN], [
  543 			/* Use the compiler-provided endianness defines to allow universal compiling. */
  544 			#if defined(__BIG_ENDIAN__)
  545 			#define WORDS_BIGENDIAN 1
  546 			#endif
  547 		])
  548 		;;
  549 	*)
  550 		AC_C_BIGENDIAN
  551 		;;
  552 esac
  553 
  554 # As a GNU extension, glibc declares environ in unistd.h, which is one of
  555 # the AC_INCLUDES_DEFAULT.
  556 AC_CHECK_DECLS([environ])
  557 
  558 dnl **********************************
  559 dnl *** va_copy checks (from GLib) ***
  560 dnl **********************************
  561 dnl we currently check for all three va_copy possibilities, so we get
  562 dnl all results in config.log for bug reports.
  563 AC_CACHE_CHECK([for an implementation of va_copy()],dbus_cv_va_copy,[
  564 	AC_LINK_IFELSE([AC_LANG_SOURCE([#include <stdarg.h>
  565 #include <stdlib.h>
  566 	static void f (int i, ...) {
  567 	va_list args1, args2;
  568 	va_start (args1, i);
  569 	va_copy (args2, args1);
  570 	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
  571 	  exit (1);
  572 	va_end (args1); va_end (args2);
  573 	}
  574 	int main() {
  575 	  f (0, 42);
  576 	  return 0;
  577 	}])],
  578 	[dbus_cv_va_copy=yes],
  579 	[dbus_cv_va_copy=no])
  580 ])
  581 AC_CACHE_CHECK([for an implementation of __va_copy()],dbus_cv___va_copy,[
  582 	AC_LINK_IFELSE([AC_LANG_SOURCE([#include <stdarg.h>
  583 #include <stdlib.h>
  584 	static void f (int i, ...) {
  585 	va_list args1, args2;
  586 	va_start (args1, i);
  587 	__va_copy (args2, args1);
  588 	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
  589 	  exit (1);
  590 	va_end (args1); va_end (args2);
  591 	}
  592 	int main() {
  593 	  f (0, 42);
  594 	  return 0;
  595 	}])],
  596 	[dbus_cv___va_copy=yes],
  597 	[dbus_cv___va_copy=no])
  598 ])
  599 
  600 if test "x$dbus_cv_va_copy" = "xyes"; then
  601   dbus_va_copy_func=va_copy
  602 else if test "x$dbus_cv___va_copy" = "xyes"; then
  603   dbus_va_copy_func=__va_copy
  604 fi
  605 fi
  606 
  607 AS_IF([test -n "$dbus_va_copy_func"],
  608   [AC_DEFINE_UNQUOTED([DBUS_VA_COPY], [$dbus_va_copy_func], [A 'va_copy' style function])],
  609   [AC_MSG_ERROR([dbus requires an ISO C99-compatible va_copy() macro, or a compatible __va_copy(), or MSVC >= 2010 and CMake])])
  610 
  611 #### Atomic integers
  612 
  613 AC_CACHE_CHECK([whether $CC knows __sync_sub_and_fetch()],
  614   dbus_cv_sync_sub_and_fetch,
  615   [AC_LINK_IFELSE([
  616      AC_LANG_PROGRAM([[]], [[int a = 4; int b = __sync_sub_and_fetch(&a, 4); exit(b); ]])],
  617      [dbus_cv_sync_sub_and_fetch=yes],
  618      [dbus_cv_sync_sub_and_fetch=no])
  619   ])
  620 
  621 if test "x$dbus_cv_sync_sub_and_fetch" = "xyes" ; then
  622    have_sync=1
  623 else
  624    have_sync=0
  625 fi
  626 
  627 AC_DEFINE_UNQUOTED([DBUS_USE_SYNC], [$have_sync], [Use the gcc __sync extension])
  628 
  629 #### Various functions
  630 AC_SEARCH_LIBS(socket,[socket network])
  631 AC_CHECK_FUNC(gethostbyname,,[AC_CHECK_LIB(nsl,gethostbyname)])
  632 
  633 AC_CHECK_HEADERS([syslog.h])
  634 if test "x$ac_cv_header_syslog_h" = "xyes"; then
  635   AC_CHECK_DECLS([LOG_PERROR], [], [], [[#include <syslog.h>]])
  636 fi
  637 
  638 AC_MSG_CHECKING(for dirfd)
  639 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
  640 #include <sys/types.h>
  641 #include <dirent.h>
  642 ]], [[
  643 DIR *dirp;
  644 dirp = opendir(".");
  645 dirfd(dirp);
  646 closedir(dirp);
  647 ]])],
  648 [dbus_have_dirfd=yes],
  649 [dbus_have_dirfd=no])
  650 AC_MSG_RESULT($dbus_have_dirfd)
  651 if test "$dbus_have_dirfd" = yes; then
  652 	AC_DEFINE(HAVE_DIRFD,1,[Have dirfd function])
  653 else
  654 	AC_MSG_CHECKING(for DIR *dirp->dd_fd)
  655 	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
  656 #include <sys/types.h>
  657 #include <dirent.h>
  658 	]], [[
  659 DIR *dirp;
  660 int fd;
  661 dirp = opendir(".");
  662 fd = dirp->dd_fd;
  663 closedir(dirp);
  664         ]])],
  665         [dbus_have_ddfd=yes],
  666         [dbus_have_ddfd=no])
  667 	AC_MSG_RESULT($dbus_have_ddfd)
  668 	if test "$dbus_have_ddfd" = yes; then
  669 		AC_DEFINE(HAVE_DDFD,1,[Have the ddfd member of DIR])
  670 	fi
  671 fi
  672 
  673 AC_CHECK_HEADERS([execinfo.h],
  674 	[AC_SEARCH_LIBS([backtrace], [execinfo],
  675 		[AC_DEFINE([HAVE_BACKTRACE], [1],
  676 			[Define to 1 if you have backtrace().])])])
  677 
  678 # Add -D_POSIX_PTHREAD_SEMANTICS if on Solaris
  679 #
  680 case $host_os in
  681     solaris*)
  682        CFLAGS="$CFLAGS -D_POSIX_PTHREAD_SEMANTICS" ;;
  683 esac
  684 
  685 AC_CHECK_FUNCS_ONCE([getpwnam_r])
  686 
  687 dnl check for socklen_t
  688 AC_MSG_CHECKING(whether socklen_t is defined)
  689 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
  690 #include <sys/types.h>
  691 #include <sys/socket.h>
  692 #include <netdb.h>
  693 ]], [[
  694 socklen_t foo;
  695 foo = 1;
  696 ]])],
  697 [dbus_have_socklen_t=yes],
  698 [dbus_have_socklen_t=no])
  699 AC_MSG_RESULT($dbus_have_socklen_t)
  700 
  701 if test "x$dbus_have_socklen_t" = "xyes"; then
  702     AC_DEFINE(HAVE_SOCKLEN_T,1,[Have socklen_t type])
  703 fi
  704 
  705 dnl check for writev header and writev function so we're
  706 dnl good to go if HAVE_WRITEV gets defined.
  707 AC_CHECK_HEADERS(sys/uio.h, [AC_CHECK_FUNCS(writev)])
  708 
  709 dnl Make it easy to check if we have MSG_NOSIGNAL without actually having to include sys/socket.h
  710 AC_CHECK_DECLS([MSG_NOSIGNAL], [], [], [[ #include <sys/types.h>
  711 #include <sys/socket.h> ]])
  712 
  713 dnl Check for various credentials.
  714 AC_MSG_CHECKING(for struct cmsgcred)
  715 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
  716 #include <sys/types.h>
  717 #include <sys/socket.h>
  718 ]], [[
  719 struct cmsgcred cred;
  720 
  721 cred.cmcred_pid = 0;
  722 ]])],
  723 [dbus_have_struct_cmsgcred=yes],
  724 [dbus_have_struct_cmsgcred=no])
  725 AC_MSG_RESULT($dbus_have_struct_cmsgcred)
  726 
  727 if test x$dbus_have_struct_cmsgcred = xyes; then
  728     AC_DEFINE(HAVE_CMSGCRED,1,[Have cmsgcred structure])
  729 fi
  730 
  731 AC_CHECK_MEMBER([struct unpcbid.unp_pid],
  732                 [AC_DEFINE([HAVE_UNPCBID], 1, [Have unpcbid structure])],
  733                 [],
  734                 [[#include <sys/un.h>]])
  735 
  736 PKG_CHECK_MODULES([EXPAT], [expat])
  737 
  738 save_cflags="$CFLAGS"
  739 save_libs="$LIBS"
  740 CFLAGS="$CFLAGS $EXPAT_CFLAGS"
  741 LIBS="$LIBS $EXPAT_LIBS"
  742 AC_CHECK_FUNCS([XML_SetHashSalt])
  743 CFLAGS="$save_cflags"
  744 LIBS="$save_libs"
  745 
  746 # Thread lib detection
  747 AC_ARG_VAR([THREAD_LIBS])
  748 save_libs="$LIBS"
  749 LIBS="$LIBS $THREAD_LIBS"
  750 
  751 is_missing_pthread_function="is required when compiling D-Bus on Unix platforms, but is not in your libc or libpthread. Please open a bug on https://bugs.freedesktop.org/enter_bug.cgi?product=dbus with details of your platform."
  752 
  753 # Don't do these automatic checks if the user set THREAD_LIBS on the
  754 # configure command-line. If they did, we assume they're right.
  755 #
  756 # We also don't do these checks on Windows, because you don't need magical
  757 # linker flags to have threading support there.
  758 AS_IF([test "x$dbus_unix" = xyes && test "x$THREAD_LIBS" = x],
  759   [
  760     # Mandatory pthread functions. In principle, some of these could be made
  761     # optional if there are platforms that don't have them.
  762     #
  763     # Currently, we only look in -lpthread.
  764     # In principle we might need to look in -lpthreads, -lthreads, ...
  765     # as well - please file a bug if your platform needs this.
  766     AC_SEARCH_LIBS([pthread_cond_timedwait],
  767         [pthread],
  768         [THREAD_LIBS="$LIBS"],
  769         [AC_MSG_ERROR([pthread_cond_timedwait $is_missing_pthread_function])],
  770         [])
  771     AC_SEARCH_LIBS([pthread_mutexattr_init],
  772         [pthread],
  773         [THREAD_LIBS="$LIBS"],
  774         [AC_MSG_ERROR([pthread_mutexattr_init $is_missing_pthread_function])],
  775         [])
  776     AC_SEARCH_LIBS([pthread_mutexattr_settype],
  777         [pthread],
  778         [THREAD_LIBS="$LIBS"],
  779         [AC_MSG_ERROR([pthread_mutexattr_settype $is_missing_pthread_function])],
  780         [])
  781 
  782     # Optional, for monotonic clocks. Because it's optional, this check
  783     # is non-fatal if we don't find it.
  784     AC_SEARCH_LIBS([pthread_condattr_setclock],
  785         [pthread],
  786         [THREAD_LIBS="$LIBS"])
  787 
  788     AS_IF([test "x$ac_cv_search_pthread_condattr_setclock" != xno],
  789       [
  790         AC_SEARCH_LIBS([clock_getres], [rt], [THREAD_LIBS="$LIBS"])
  791         AC_MSG_CHECKING([for CLOCK_MONOTONIC])
  792         AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
  793 [[#include <time.h>
  794 #include <pthread.h>
  795 ]], [[
  796 struct timespec monotonic_timer;
  797 pthread_condattr_t attr;
  798 pthread_condattr_init (&attr);
  799 pthread_condattr_setclock (&attr, CLOCK_MONOTONIC);
  800 clock_getres (CLOCK_MONOTONIC,&monotonic_timer);
  801 ]])],
  802             [have_clock_monotonic=true],
  803             [have_clock_monotonic=false])
  804         AS_IF([test x$have_clock_monotonic = xtrue],
  805 	  [
  806             AC_MSG_RESULT([found])
  807             AC_DEFINE(HAVE_MONOTONIC_CLOCK, 1, [Define if we have CLOCK_MONOTONIC])
  808 	  ],
  809           [AC_MSG_RESULT([not found])])
  810       ]) dnl have pthread_condattr_setclock
  811   ]) dnl on Unix
  812 
  813 LIBS="$save_libs"
  814 
  815 AC_SUBST([THREAD_LIBS])
  816 
  817 # SELinux detection
  818 if test x$enable_selinux = xno ; then
  819     have_selinux=no;
  820 else
  821     # See if we have SELinux library
  822     PKG_CHECK_MODULES([SELINUX], [libselinux >= 2.0.86],
  823                  [have_selinux=yes], [have_selinux=no])
  824 
  825     if test x$enable_selinux = xauto ; then
  826         if test x$have_selinux = xno ; then
  827                 AC_MSG_WARN([Sufficiently new SELinux library not found])
  828         fi
  829     else
  830         if test x$have_selinux = xno ; then
  831                 AC_MSG_ERROR([SElinux explicitly required, and SELinux library not found])
  832         fi
  833     fi
  834 fi
  835 
  836 AM_CONDITIONAL(HAVE_SELINUX, test x$have_selinux = xyes)
  837 
  838 if test x$have_selinux = xyes ; then
  839     # the selinux code creates threads
  840     # which requires libpthread even on linux
  841     AC_CHECK_FUNC(pthread_create,,[AC_CHECK_LIB(pthread,pthread_create,
  842                                                 [SELINUX_THREAD_LIBS="-lpthread"])])
  843 
  844     SELINUX_LIBS="$SELINUX_LIBS $SELINUX_THREAD_LIBS"
  845     AC_DEFINE(HAVE_SELINUX,1,[SELinux support])
  846 else
  847     SELINUX_LIBS=
  848 fi
  849 
  850 # AppArmor detection
  851 AS_IF([test x$enable_apparmor = xno],
  852   [have_apparmor=no],
  853   [
  854   PKG_CHECK_MODULES([APPARMOR], [libapparmor >= 2.8.95],
  855                     [have_apparmor=yes], [have_apparmor=no])
  856   PKG_CHECK_MODULES([APPARMOR_2_10], [libapparmor >= 2.10],
  857                     [have_apparmor_2_10=yes], [have_apparmor_2_10=no])
  858 
  859   AS_IF([test x$enable_apparmor = xauto && test x$have_apparmor = xno],
  860         [AC_MSG_WARN([Sufficiently new AppArmor library not found])])
  861   AS_IF([test x$enable_apparmor != xauto && test x$have_apparmor = xno],
  862         [AC_MSG_ERROR([AppArmor explicitly required, and AppArmor library not found])])
  863   ])
  864 
  865 AS_IF([test x$have_apparmor = xyes],
  866       [AC_DEFINE([HAVE_APPARMOR], [1], [AppArmor Support])])
  867 AS_IF([test x$have_apparmor_2_10 = xyes],
  868       [AC_DEFINE([HAVE_APPARMOR_2_10], [1],
  869                  [Define if libapparmor is version 2.10 or later])])
  870 
  871 # inotify checks
  872 if test x$enable_inotify = xno ; then
  873     have_inotify=no;
  874 else
  875     AC_CHECK_HEADERS(sys/inotify.h, have_inotify=yes, have_inotify=no)
  876 fi
  877 
  878 dnl check if inotify backend is enabled
  879 if test x$have_inotify = xyes; then
  880    AC_DEFINE(DBUS_BUS_ENABLE_INOTIFY,1,[Use inotify])
  881 fi
  882 
  883 AM_CONDITIONAL(DBUS_BUS_ENABLE_INOTIFY, test x$have_inotify = xyes)
  884 
  885 # For simplicity, we require the userland API for epoll_create1 at
  886 # compile-time (glibc 2.9), but we'll run on kernels that turn out
  887 # not to have it at runtime.
  888 AC_ARG_ENABLE([epoll],
  889               [AS_HELP_STRING([--enable-epoll],[use epoll(4) on Linux])],
  890               [enable_epoll=$enableval], [enable_epoll=auto])
  891 if test x$enable_epoll = xno; then
  892     have_linux_epoll=no
  893 else
  894     AC_MSG_CHECKING([for Linux epoll(4)])
  895     AC_LINK_IFELSE([AC_LANG_PROGRAM(
  896         [
  897         #ifndef __linux__
  898         #error This is not Linux
  899         #endif
  900         #include <sys/epoll.h>
  901         ],
  902         [epoll_create1 (EPOLL_CLOEXEC);])],
  903         [have_linux_epoll=yes],
  904         [have_linux_epoll=no])
  905     AC_MSG_RESULT([$have_linux_epoll])
  906 fi
  907 if test x$enable_epoll,$have_linux_epoll = xyes,no; then
  908     AC_MSG_ERROR([epoll support explicitly enabled but not available])
  909 fi
  910 if test x$have_linux_epoll = xyes; then
  911   AC_DEFINE([DBUS_HAVE_LINUX_EPOLL], 1, [Define to use epoll(4) on Linux])
  912 fi
  913 AM_CONDITIONAL([DBUS_HAVE_LINUX_EPOLL], [test x$have_linux_epoll = xyes])
  914 
  915 # kqueue checks
  916 if test x$enable_kqueue = xno ; then
  917     have_kqueue=no
  918 else
  919     have_kqueue=yes
  920     AC_CHECK_HEADER(sys/event.h, , have_kqueue=no)
  921     AC_CHECK_FUNC(kqueue, , have_kqueue=no)
  922 
  923     if test x$enable_kqueue = xyes -a x$have_kqueue = xno; then
  924         AC_MSG_ERROR(kqueue support explicitly enabled but not available)
  925     fi
  926 fi
  927 
  928 dnl check if kqueue backend is enabled
  929 if test x$have_kqueue = xyes; then
  930    AC_DEFINE(DBUS_BUS_ENABLE_KQUEUE,1,[Use kqueue])
  931 fi
  932 
  933 AM_CONDITIONAL(DBUS_BUS_ENABLE_KQUEUE, test x$have_kqueue = xyes)
  934 
  935 # launchd checks
  936 if test x$enable_launchd = xno ; then
  937     have_launchd=no
  938 else
  939     have_launchd=yes
  940     AC_CHECK_HEADER([launch.h], , have_launchd=no)
  941     AC_PATH_PROG([LAUNCHCTL], [launchctl])
  942     if test "x$LAUNCHCTL" = "x"; then
  943         have_launchd=no
  944     fi
  945 
  946     if test x$enable_launchd = xyes && test x$have_launchd = xno ; then
  947         AC_MSG_ERROR([launchd support explicitly enabled but not available])
  948     fi
  949 fi
  950 
  951 dnl check if launchd is enabled
  952 if test x$have_launchd = xyes; then
  953     AC_DEFINE(DBUS_ENABLE_LAUNCHD,1,[Use launchd autolaunch])
  954 fi
  955 
  956 AM_CONDITIONAL(DBUS_ENABLE_LAUNCHD, test x$have_launchd = xyes)
  957 
  958 #### Directory to place launchd agent file
  959 if test "x$with_launchd_agent_dir" = "x"; then
  960    LAUNCHD_AGENT_DIR="/Library/LaunchAgents"
  961 else
  962    LAUNCHD_AGENT_DIR="$with_launchd_agent_dir"
  963 fi
  964 
  965 AC_SUBST(LAUNCHD_AGENT_DIR)
  966 
  967 dnl console owner file
  968 if test x$enable_console_owner_file = xno ; then
  969     have_console_owner_file=no;
  970 else
  971     case $host_os in
  972     solaris*)
  973         have_console_owner_file=yes;
  974         AC_DEFINE(HAVE_CONSOLE_OWNER_FILE,1,[Have console owner file])
  975         ;;
  976     *)
  977         have_console_owner_file=no;;
  978     esac
  979 fi
  980 
  981 AM_CONDITIONAL(HAVE_CONSOLE_OWNER_FILE, test x$have_console_owner_file = xyes)
  982 
  983 dnl systemd detection
  984 if test x$enable_systemd = xno ; then
  985     have_systemd=no;
  986 else
  987     PKG_CHECK_MODULES([SYSTEMD],
  988         [libsystemd >= 209],
  989         [have_systemd=yes],
  990         [PKG_CHECK_MODULES([SYSTEMD],
  991             [libsystemd-login >= 32, libsystemd-daemon >= 32, libsystemd-journal >= 32],
  992             [have_systemd=yes],
  993             [have_systemd=no])])
  994 fi
  995 
  996 if test x$have_systemd = xyes; then
  997     AC_DEFINE(HAVE_SYSTEMD,1,[Have systemd])
  998 fi
  999 
 1000 if test x$enable_systemd = xyes -a x$have_systemd != xyes ; then
 1001     AC_MSG_ERROR([Explicitly requested systemd support, but systemd not found])
 1002 fi
 1003 
 1004 AS_IF([test "x$enable_traditional_activation" = xyes],
 1005     AC_DEFINE(ENABLE_TRADITIONAL_ACTIVATION,[1], [Enable traditional activation without using systemd])
 1006     AS_IF([test "x$enable_systemd" = xno],
 1007        AC_MSG_WARN([Traditional activation and systemd activation are both disabled, so service activation (automatically starting services that receive messages) will not work])))
 1008 
 1009 AM_CONDITIONAL(ENABLE_TRADITIONAL_ACTIVATION, test x$enable_traditional_activation = xyes)
 1010 
 1011 # If not found in $PATH, we might still have systemd and systemctl at runtime
 1012 # (perhaps dbus is being compiled in a minimal chroot with no systemd).
 1013 # Assume the upstream-recommended location. Distributors with split /usr
 1014 # can override this with ./configure SYSTEMCTL=/bin/systemctl
 1015 AC_PATH_PROG([SYSTEMCTL], [systemctl], [/usr/bin/systemctl])
 1016 
 1017 # libaudit detection
 1018 if test x$enable_libaudit = xno ; then
 1019     have_libaudit=no;
 1020 else
 1021     # See if we have audit daemon & capabilities library
 1022     AC_CHECK_LIB(audit, audit_log_user_avc_message,
 1023                  have_libaudit=yes, have_libaudit=no)
 1024     if test x$have_libaudit = xyes ; then
 1025         AC_CHECK_LIB(cap-ng, capng_clear,
 1026                  have_libaudit=yes, have_libaudit=no)
 1027     fi
 1028 fi
 1029 
 1030 AM_CONDITIONAL(HAVE_LIBAUDIT, test x$have_libaudit = xyes)
 1031 
 1032 if test x$have_libaudit = xyes ; then
 1033     SELINUX_LIBS="$SELINUX_LIBS -laudit -lcap-ng"
 1034     AC_DEFINE(HAVE_LIBAUDIT,1,[audit daemon SELinux support])
 1035 fi
 1036 
 1037 AC_SUBST([SELINUX_LIBS])
 1038 
 1039 # Check for ADT API (Solaris Basic Security Mode auditing)
 1040 AC_MSG_CHECKING(for ADT API)
 1041 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 1042 #include <bsm/adt.h>
 1043 adt_user_context = ADT_USER;
 1044 ]], [[]])], [ check_adt_audit=yes ], [ check_adt_audit=no ])
 1045 
 1046 if test ${check_adt_audit} = yes
 1047 then
 1048    AC_DEFINE([HAVE_ADT], [], [Adt audit API])
 1049    ADT_LIBS="-lbsm"
 1050    LIBS="-lbsm $LIBS"
 1051    AC_MSG_RESULT(yes)
 1052 else
 1053    AC_MSG_RESULT(no)
 1054 fi
 1055 AC_SUBST([ADT_LIBS])
 1056 
 1057 # Check for SCM_RIGHTS
 1058 AC_MSG_CHECKING([for SCM_RIGHTS])
 1059 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 1060 #include <sys/types.h>
 1061 #include <sys/socket.h>
 1062 #include <sys/un.h>
 1063 static int x = SCM_RIGHTS;
 1064 ]], [[]])],
 1065 [ AC_MSG_RESULT([supported])
 1066   AC_DEFINE([HAVE_UNIX_FD_PASSING], [1], [Supports sending UNIX file descriptors]) ],
 1067 [ AC_MSG_RESULT([not supported]) ])
 1068 
 1069 NETWORK_libs=
 1070 if test x$dbus_win = xyes ; then
 1071   if test x$dbus_wince = xyes ; then
 1072     NETWORK_libs="-lws2"
 1073   else
 1074     NETWORK_libs="-lws2_32 -liphlpapi -ldbghelp"
 1075   fi
 1076 fi
 1077 
 1078 AC_SUBST([NETWORK_libs])
 1079 
 1080 AC_ARG_WITH([valgrind],
 1081   [AS_HELP_STRING([--with-valgrind],
 1082      [Add instrumentation to help valgrind to understand our allocator])],
 1083   [],
 1084   [with_valgrind=no])
 1085 
 1086 AS_IF([test "x$with_valgrind" = xauto],
 1087   [PKG_CHECK_EXISTS([valgrind >= 3.6],
 1088     [with_valgrind=yes], [with_valgrind=no])])
 1089 
 1090 if test x$with_valgrind != xno; then
 1091   PKG_CHECK_MODULES([VALGRIND], [valgrind >= 3.6])
 1092   AC_DEFINE([WITH_VALGRIND], [1], [Define to add Valgrind instrumentation])
 1093 fi
 1094 
 1095 #### Set up final flags
 1096 LIBDBUS_LIBS="$THREAD_LIBS $NETWORK_libs $SYSTEMD_LIBS"
 1097 AC_SUBST([LIBDBUS_LIBS])
 1098 
 1099 ### X11 detection
 1100 DBUS_X_LIBS=
 1101 DBUS_X_CFLAGS=
 1102 
 1103 AC_ARG_ENABLE([x11-autolaunch],
 1104   AS_HELP_STRING([--enable-x11-autolaunch], [build with X11 auto-launch support]),
 1105   [], [enable_x11_autolaunch=auto])
 1106 
 1107 if test "x$dbus_win" = xyes; then
 1108     if test "x$enable_x11_autolaunch" = xyes; then
 1109         AC_MSG_ERROR([X11 auto-launch is not supported on Windows])
 1110     fi
 1111 
 1112     enable_x11_autolaunch=no
 1113     have_x11=no
 1114 else
 1115     AC_PATH_XTRA
 1116 
 1117     if test "x$no_x" = xyes; then
 1118         have_x11=no
 1119     else
 1120         have_x11=yes
 1121         DBUS_X_LIBS="$X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
 1122         DBUS_X_CFLAGS="$X_CFLAGS"
 1123     fi
 1124 fi
 1125 
 1126 if test "x$enable_x11_autolaunch,$have_x11" = xyes,no; then
 1127     AC_MSG_ERROR([X11 auto-launch requires X headers/libraries])
 1128 else
 1129     # move from "auto" to "yes" or "no" if necessary
 1130     if test "x$enable_x11_autolaunch" != xno; then
 1131         enable_x11_autolaunch="$have_x11"
 1132     fi
 1133 fi
 1134 
 1135 if test "x$have_x11" = xyes ; then
 1136    AC_DEFINE([DBUS_BUILD_X11], [1], [Define to build X11 functionality])
 1137 fi
 1138 
 1139 if test "x$enable_x11_autolaunch" = xyes ; then
 1140    AC_DEFINE([DBUS_ENABLE_X11_AUTOLAUNCH], [1], [Define to enable X11 auto-launch])
 1141 fi
 1142 AM_CONDITIONAL([DBUS_ENABLE_X11_AUTOLAUNCH],
 1143   [test "x$enable_x11_autolaunch" = xyes])
 1144 
 1145 AC_SUBST([DBUS_X_CFLAGS])
 1146 AC_SUBST([DBUS_X_LIBS])
 1147 
 1148 # We're treating -fno-common like a warning: it makes the linker more
 1149 # strict, because on some systems the linker is *always* this strict
 1150 TEST_CFLAGS="$TEST_CFLAGS -fno-common"
 1151 
 1152 AS_IF([test "x$enable_ansi" = "xyes"],[
 1153     TEST_CFLAGS="$TEST_CFLAGS -ansi -pedantic"
 1154     AC_DEFINE([_POSIX_C_SOURCE],[199309L],[Define to enable POSIX features])
 1155     AC_DEFINE([_BSD_SOURCE],[1],[Define to enable BSD features])
 1156   ])
 1157 
 1158 dnl We are only calling this for its side-effect of setting up
 1159 dnl --enable-compile-warnings; the WARN_CFLAGS, etc. are ignored,
 1160 dnl to work around https://github.com/peti/autoconf-archive/pull/96
 1161 AX_COMPILER_FLAGS([], [], [$disable_developer])
 1162 
 1163 dnl Work around https://github.com/peti/autoconf-archive/pull/96 by using
 1164 dnl a non-default variable name here (in particular there is no way to tell
 1165 dnl AX_COMPILER_FLAGS to not use WARN_CXXFLAGS)
 1166 AX_COMPILER_FLAGS_CFLAGS([EXTRA_CFLAGS],
 1167                          [$disable_developer],
 1168                          [$TEST_CFLAGS],
 1169                          [-Wchar-subscripts \
 1170                           -Wfloat-equal \
 1171                           -Wpointer-sign \
 1172                           $DISABLE_WARNINGS])
 1173 dnl cc1plus: warning: command line option ‘-Wpointer-sign’ is valid for
 1174 dnl C/ObjC but not for C++
 1175 AX_COMPILER_FLAGS_CXXFLAGS([EXTRA_CXXFLAGS],
 1176                            [$disable_developer],
 1177                            [],
 1178                            [-Wchar-subscripts \
 1179                             -Wfloat-equal \
 1180                             $DISABLE_WARNINGS])
 1181 AX_COMPILER_FLAGS_LDFLAGS([EXTRA_LDFLAGS],
 1182                           [$disable_developer])
 1183 
 1184 dnl TODO: In principle we should put EXTRA_CFLAGS in each Makefile.am like
 1185 dnl telepathy-glib does, since CFLAGS is meant to be reserved for the user...
 1186 dnl but prepending to CFLAGS (so the user can override it with later CFLAGS)
 1187 dnl is the next best thing.
 1188 CFLAGS="$EXTRA_CFLAGS $CFLAGS"
 1189 CXXFLAGS="$EXTRA_CXXFLAGS $CXXFLAGS"
 1190 LDFLAGS="$EXTRA_LDFLAGS $LDFLAGS"
 1191 
 1192 AC_ARG_VAR([SANITIZE_CFLAGS],
 1193            [Extra CFLAGS for modules that are instrumented for error-checking])
 1194 
 1195 case $host_os in
 1196     solaris*)
 1197         # Solaris' C library apparently needs these runes to be threadsafe...
 1198         CFLAGS="$CFLAGS -D_POSIX_PTHREAD_SEMANTICS -D_REENTRANT"
 1199         # ... this opt-in to get sockaddr_in6 and sockaddr_storage...
 1200         CFLAGS="$CFLAGS -D__EXTENSIONS__"
 1201         # ... and this opt-in to get file descriptor passing support
 1202         CFLAGS="$CFLAGS -D_XOPEN_SOURCE=500"
 1203         ;;
 1204 esac
 1205 
 1206 ### Detect if ld supports --version-script
 1207 
 1208 gl_LD_VERSION_SCRIPT
 1209 AM_CONDITIONAL([HAVE_LD_VERSION_SCRIPT],
 1210                [test "x$have_ld_version_script" = xyes])
 1211 ### Doxygen Documentation
 1212 
 1213 AC_PATH_PROG(DOXYGEN, doxygen, no)
 1214 
 1215 AC_MSG_CHECKING([whether to build Doxygen documentation])
 1216 
 1217 if test x$DOXYGEN = xno ; then
 1218     have_doxygen=no
 1219 else
 1220     have_doxygen=yes
 1221 fi
 1222 
 1223 if test x$enable_doxygen_docs = xauto ; then
 1224     if test x$have_doxygen = xno ; then
 1225         enable_doxygen_docs=no
 1226     else
 1227         enable_doxygen_docs=yes
 1228     fi
 1229 fi
 1230 
 1231 if test x$enable_doxygen_docs = xyes; then
 1232     if test x$have_doxygen = xno; then
 1233 	AC_MSG_ERROR([Building Doxygen docs explicitly required, but Doxygen not found])
 1234     fi
 1235 fi
 1236 
 1237 if test x$dbus_win = xno; then
 1238     DBUS_GENERATE_MAN=YES
 1239 else
 1240     DBUS_GENERATE_MAN=NO
 1241 fi
 1242 AC_SUBST([DBUS_GENERATE_MAN])
 1243 
 1244 AM_CONDITIONAL(DBUS_DOXYGEN_DOCS_ENABLED, test x$enable_doxygen_docs = xyes)
 1245 AC_MSG_RESULT($enable_doxygen_docs)
 1246 
 1247 AC_ARG_WITH([qchdir],
 1248             AS_HELP_STRING([--with-qchdir=DIR], [Directory for installing Qt help file]),
 1249             [qchdir=$withval],
 1250             [qchdir="$docdir"])
 1251 AC_SUBST([qchdir])
 1252 
 1253 AC_ARG_ENABLE([qt-help],
 1254               [AS_HELP_STRING([--enable-qt-help=auto|yes|no], [Build Qt help documentation])],
 1255               [],
 1256               [enable_qt_help=auto])
 1257 AS_IF([test "x$enable_qt_help" != xno],
 1258       [AC_CHECK_PROGS([QHELPGENERATOR], [qhelpgenerator qhelpgenerator-qt5])],
 1259       [QHELPGENERATOR=])
 1260 AS_IF([test "x$QHELPGENERATOR" = x && test "x$enable_qt_help" != xno && test "x$enable_qt_help" != xauto],
 1261       [AC_MSG_ERROR([Building of Qt help requested, but qhelpgenerator not found])])
 1262 
 1263 AC_MSG_CHECKING([whether to build Qt help documentation])
 1264 AS_IF([test "x$enable_doxygen_docs" = xyes && test "x$QHELPGENERATOR" != x], [
 1265     enable_qthelp_docs=yes
 1266     DOXYGEN_GENERATE_QHP=YES
 1267     DOXYGEN_QHG_LOCATION="$QHELPGENERATOR"
 1268     DOXYGEN_QCH_FILE="$(pwd)/doc/api/qch/dbus-$VERSION.qch"
 1269   ], [
 1270     DOXYGEN_GENERATE_QHP=NO
 1271     enable_qthelp_docs=no
 1272   ])
 1273 AC_SUBST([DOXYGEN_GENERATE_QHP])
 1274 AC_SUBST([DOXYGEN_QHG_LOCATION])
 1275 AC_SUBST([DOXYGEN_QCH_FILE])
 1276 
 1277 AM_CONDITIONAL([DBUS_QTHELP_DOCS_ENABLED], [test "x$enable_qthelp_docs" = xyes])
 1278 AC_MSG_RESULT($enable_qthelp_docs)
 1279 
 1280 AC_CHECK_PROGS([XSLTPROC], [xsltproc])
 1281 AM_CONDITIONAL([DBUS_HAVE_XSLTPROC], [test "x$XSLTPROC" != "x"])
 1282 
 1283 ### Ducktype/Yelp documentation
 1284 
 1285 AC_PATH_PROG([DUCKTYPE],[ducktype],[no])
 1286 AC_PATH_PROG([YELP_BUILD],[yelp-build],[no])
 1287 
 1288 AC_MSG_CHECKING([whether to build Ducktype documentation])
 1289 
 1290 AS_IF([test "$DUCKTYPE" = "no"],[have_ducktype=no],[have_ducktype=yes])
 1291 AS_IF([test "$YELP_BUILD" = "no"],[have_yelp_build=no],[have_yelp_build=yes])
 1292 
 1293 AS_IF([test "$enable_ducktype_docs" = "auto"],[
 1294     AS_IF([test "$have_ducktype" = "no" || test "$have_yelp_build" = "no"],[
 1295         enable_ducktype_docs=no
 1296     ],[
 1297         enable_ducktype_docs=yes
 1298     ])
 1299 ])
 1300 
 1301 AS_IF([test "$enable_ducktype_docs" = "yes"],[
 1302     AS_IF([test "$have_ducktype" = "no"],[
 1303         AC_MSG_ERROR([Building Ducktype docs explicitly required, but ducktype not found])
 1304     ])
 1305     AS_IF([test "$have_yelp_build" = "no"],[
 1306         AC_MSG_ERROR([Building Ducktype docs explicitly required, but yelp-build not found])
 1307     ])
 1308 ])
 1309 
 1310 AM_CONDITIONAL([DBUS_DUCKTYPE_DOCS_ENABLED],[test "$enable_ducktype_docs" = "yes"])
 1311 AC_MSG_RESULT([$enable_ducktype_docs])
 1312 
 1313 ### XML Documentation
 1314 
 1315 AC_PATH_PROG(XMLTO, xmlto, no)
 1316 
 1317 AC_MSG_CHECKING([whether to build XML documentation])
 1318 
 1319 if test x$XMLTO = xno ; then
 1320     have_xmlto=no
 1321 else
 1322     have_xmlto=yes
 1323 fi
 1324 
 1325 if test x$enable_xml_docs = xauto ; then
 1326     if test x$have_xmlto = xno ; then
 1327         enable_xml_docs=no
 1328     else
 1329         enable_xml_docs=yes
 1330     fi
 1331 fi
 1332 
 1333 if test x$enable_xml_docs = xyes; then
 1334     if test x$have_xmlto = xno; then
 1335 	AC_MSG_ERROR([Building XML docs explicitly required, but xmlto not found])
 1336     fi
 1337 fi
 1338 
 1339 AM_CONDITIONAL(DBUS_XML_DOCS_ENABLED, test x$enable_xml_docs = xyes)
 1340 AC_MSG_RESULT($enable_xml_docs)
 1341 
 1342 AM_CONDITIONAL(DBUS_CAN_UPLOAD_DOCS,
 1343     [test x$enable_doxygen_docs = xyes && test x$enable_xml_docs = xyes &&
 1344      test x$enable_ducktype_docs = xyes])
 1345 
 1346 # Autoconf 2.70 will support this, and many distros patch this option in,
 1347 # but Autoconf 2.70 hasn't actually been released yet.
 1348 AS_IF([test -z "${runstatedir}"], [runstatedir='${localstatedir}/run'])
 1349 AC_SUBST([runstatedir])
 1350 
 1351 #### Have to go $localstatedir->$prefix/var->/usr/local/var
 1352 
 1353 #### find the actual value for $prefix that we'll end up with
 1354 ##   (I know this is broken and should be done in the Makefile, but
 1355 ##    that's a major pain and almost nobody actually seems to care)
 1356 AS_AC_EXPAND(EXPANDED_PREFIX, "$prefix")
 1357 AS_AC_EXPAND(EXPANDED_LOCALSTATEDIR, "$localstatedir")
 1358 AS_AC_EXPAND(EXPANDED_SYSCONFDIR, "$sysconfdir")
 1359 AS_AC_EXPAND(EXPANDED_BINDIR, "$bindir")
 1360 AS_AC_EXPAND(EXPANDED_LIBDIR, "$libdir")
 1361 AS_AC_EXPAND(EXPANDED_LIBEXECDIR, "$libexecdir")
 1362 AS_AC_EXPAND(EXPANDED_DATADIR, "$datadir")
 1363 AS_AC_EXPAND(EXPANDED_RUNSTATEDIR, "$runstatedir")
 1364 
 1365 ##### systemd unit files
 1366 AC_ARG_WITH([systemdsystemunitdir],
 1367 AS_HELP_STRING([--with-systemdsystemunitdir=DIR], [Directory for systemd service files]),
 1368     [],
 1369     [
 1370     PKG_CHECK_EXISTS([systemd],
 1371       [with_systemdsystemunitdir=$($PKG_CONFIG --variable=systemdsystemunitdir systemd)],
 1372       [with_systemdsystemunitdir=no])
 1373     ])
 1374 if test "x$with_systemdsystemunitdir" != xno; then
 1375    AC_SUBST([systemdsystemunitdir], [$with_systemdsystemunitdir])
 1376 fi
 1377 AM_CONDITIONAL(HAVE_SYSTEMD, [test "x$have_systemd" != "xno" -a -n "$with_systemdsystemunitdir" -a "x$with_systemdsystemunitdir" != xno ])
 1378 
 1379 AC_ARG_WITH([systemduserunitdir],
 1380 AS_HELP_STRING([--with-systemduserunitdir=DIR], [Directory for systemd user service files]),
 1381     [],
 1382     [
 1383     PKG_CHECK_EXISTS([systemd],
 1384       [with_systemduserunitdir=$($PKG_CONFIG --variable=systemduserunitdir systemd)],
 1385       [with_systemduserunitdir='${libdir}/systemd/user'])
 1386     ])
 1387 AC_SUBST([systemduserunitdir], [$with_systemduserunitdir])
 1388 
 1389 ##### Set up location for system bus socket
 1390 if ! test -z "$with_system_socket"; then
 1391    DBUS_SYSTEM_SOCKET=$with_system_socket
 1392 else
 1393    # We don't use runstatedir for this (yet?), because /var/run has been the
 1394    # interoperable system bus socket for 10+ years.
 1395    # See https://bugs.freedesktop.org/show_bug.cgi?id=101628
 1396    DBUS_SYSTEM_SOCKET=${EXPANDED_LOCALSTATEDIR}/run/dbus/system_bus_socket
 1397 fi
 1398 
 1399 AC_SUBST(DBUS_SYSTEM_SOCKET)
 1400 AC_DEFINE_UNQUOTED(DBUS_SYSTEM_SOCKET,"$DBUS_SYSTEM_SOCKET",[The name of the socket the system bus listens on by default])
 1401 
 1402 ## System bus only listens on local domain sockets, and never
 1403 ## on an abstract socket (so only root can create the socket).
 1404 ##
 1405 ## This won't work on Windows. It's not meant to - the system bus is
 1406 ## meaningless on Windows anyway.
 1407 ##
 1408 ## This has to be suitable for hard-coding in client libraries as well as
 1409 ## in the dbus-daemon's configuration, so it has to be valid to listen on
 1410 ## and also to connect to. If this ever changes, it'll need to be split into
 1411 ## two variables, one for the listening address and one for the connecting
 1412 ## address.
 1413 DBUS_SYSTEM_BUS_DEFAULT_ADDRESS="unix:path=$DBUS_SYSTEM_SOCKET"
 1414 AC_SUBST(DBUS_SYSTEM_BUS_DEFAULT_ADDRESS)
 1415 AC_DEFINE_UNQUOTED(DBUS_SYSTEM_BUS_DEFAULT_ADDRESS, "$DBUS_SYSTEM_BUS_DEFAULT_ADDRESS",[The default D-Bus address of the system bus])
 1416 
 1417 #### Set up the pid file
 1418 if ! test -z "$with_system_pid_file"; then
 1419    DBUS_SYSTEM_PID_FILE=$with_system_pid_file
 1420 else
 1421    DBUS_SYSTEM_PID_FILE="${EXPANDED_RUNSTATEDIR}/dbus/pid"
 1422 fi
 1423 
 1424 AC_SUBST(DBUS_SYSTEM_PID_FILE)
 1425 
 1426 #### Directory to check for console ownership
 1427 AS_IF([test -n "$with_console_auth_dir" && test "x$with_console_auth_dir" != xno],
 1428     [AC_DEFINE_UNQUOTED([DBUS_CONSOLE_AUTH_DIR], ["$with_console_auth_dir"],
 1429         [Directory to check for pam_console/pam_foreground flag files, or undefined])],
 1430     [with_console_auth_dir=])
 1431 
 1432 #### File to check for console ownership
 1433 if test x$have_console_owner_file = xyes; then
 1434    if ! test -z "$with_console_owner_file"; then
 1435       DBUS_CONSOLE_OWNER_FILE=$with_console_owner_file
 1436    else
 1437       DBUS_CONSOLE_OWNER_FILE=/dev/console
 1438    fi
 1439 else
 1440   DBUS_CONSOLE_OWNER_FILE=
 1441 fi
 1442 
 1443 AC_SUBST(DBUS_CONSOLE_OWNER_FILE)
 1444 AC_DEFINE_UNQUOTED(DBUS_CONSOLE_OWNER_FILE, "$DBUS_CONSOLE_OWNER_FILE", [File to check for console ownerhip])
 1445 
 1446 #### User to start the system bus as
 1447 if test -z "$with_dbus_user" ; then
 1448     DBUS_USER=messagebus
 1449 else
 1450     DBUS_USER=$with_dbus_user
 1451 fi
 1452 AC_SUBST(DBUS_USER)
 1453 AC_DEFINE_UNQUOTED(DBUS_USER,"$DBUS_USER", [User for running the system BUS daemon])
 1454 
 1455 #### User for regression tests
 1456 AS_IF([test -z "$with_test_user"], [with_test_user=nobody])
 1457 DBUS_TEST_USER="$with_test_user"
 1458 AC_SUBST([DBUS_TEST_USER])
 1459 AC_DEFINE_UNQUOTED([DBUS_TEST_USER], ["$DBUS_TEST_USER"],
 1460   [Unprivileged user used in some regression tests])
 1461 
 1462 #### Prefix to install into
 1463 DBUS_PREFIX=$EXPANDED_PREFIX
 1464 AC_SUBST(DBUS_PREFIX)
 1465 AC_DEFINE_UNQUOTED(DBUS_PREFIX,"$DBUS_PREFIX", [Prefix for installing DBUS])
 1466 
 1467 #### Direcotry to install data files into
 1468 DBUS_DATADIR=$EXPANDED_DATADIR
 1469 AC_SUBST(DBUS_DATADIR)
 1470 AC_DEFINE_UNQUOTED(DBUS_DATADIR,"$DBUS_DATADIR", [Directory for installing DBUS data files])
 1471 
 1472 #### Directory to install dbus-daemon
 1473 if test -z "$with_dbus_daemondir" ; then
 1474     DBUS_DAEMONDIR=$EXPANDED_BINDIR
 1475     dbus_daemondir='${bindir}'
 1476 else
 1477     DBUS_DAEMONDIR=$with_dbus_daemondir
 1478     dbus_daemondir=$with_dbus_daemondir
 1479 fi
 1480 AC_SUBST(DBUS_DAEMONDIR)
 1481 AC_SUBST(dbus_daemondir)
 1482 AC_DEFINE_UNQUOTED(DBUS_DAEMONDIR,"$DBUS_DAEMONDIR", [Directory for installing the DBUS daemon])
 1483 
 1484 #### Directory to install the other binaries
 1485 DBUS_BINDIR="$EXPANDED_BINDIR"
 1486 AC_SUBST(DBUS_BINDIR)
 1487 AC_DEFINE_UNQUOTED(DBUS_BINDIR,"$DBUS_BINDIR", [Directory for installing the binaries])
 1488 
 1489 #### Directory to install the libexec binaries
 1490 DBUS_LIBEXECDIR="$EXPANDED_LIBEXECDIR"
 1491 AC_SUBST(DBUS_LIBEXECDIR)
 1492 AC_DEFINE_UNQUOTED(DBUS_LIBEXECDIR,"$DBUS_LIBEXECDIR", [Directory for installing the libexec binaries])
 1493 
 1494 AC_ARG_ENABLE([relocation],
 1495   [AS_HELP_STRING([--enable-relocation[=yes/no/auto]],
 1496     [Make pkg-config metadata relocatable [default=auto]])],
 1497   [], [enable_relocation=auto])
 1498 
 1499 can_relocate=yes
 1500 
 1501 AS_CASE(["${exec_prefix}"],
 1502   ['NONE'|'${prefix}'|"${prefix}"],
 1503     [:],
 1504   [*],
 1505     [
 1506       can_relocate=no
 1507       # If the user said --enable-relocation but we can't do it, error out
 1508       AS_IF([test "x$enable_relocation" = xyes],
 1509         [AC_MSG_ERROR([Relocatable pkg-config metadata requires --exec-prefix='\${prefix}', not ${exec_prefix}])])
 1510     ])
 1511 
 1512 AS_CASE(["${libdir}"],
 1513   ['${prefix}/lib'|'${prefix}/lib64'|'${exec_prefix}/lib'|'${exec_prefix}/lib64'|"${prefix}/lib"|"${exec_prefix}/lib"|"${prefix}/lib64"|"${exec_prefix}/lib64"],
 1514     [:],
 1515   [*],
 1516     [
 1517       can_relocate=no
 1518       # If the user said --enable-relocation but we can't do it, error out
 1519       AS_IF([test "x$enable_relocation" = xyes],
 1520         [AC_MSG_ERROR([Relocatable pkg-config metadata requires default libdir, not ${libdir}])])
 1521     ])
 1522 
 1523 # By default, on Windows we are relocatable if possible
 1524 AS_IF([test "x$enable_relocation" = xauto && test "x$dbus_win" = xyes],
 1525   [enable_relocation="$can_relocate"])
 1526 
 1527 # By default, on non-Windows we are not relocatable because it can interfere
 1528 # with pkg-config's ability to filter out system include directories,
 1529 # resulting in linking an outdated system-wide library in preference to a
 1530 # newer version installed elsewhere
 1531 AS_IF([test "x$enable_relocation" = xauto],
 1532   [enable_relocation="no"])
 1533 
 1534 
 1535 AS_IF([test "x$enable_relocation" = xyes],
 1536   [AC_SUBST([pkgconfig_prefix], ['${pcfiledir}/../..'])],
 1537   [AC_SUBST([pkgconfig_prefix], ['${original_prefix}'])])
 1538 
 1539 #### Directory to source sysconfdir configuration from
 1540 
 1541 # On Windows this is relative to where we put the bus setup, in
 1542 # ${datadir}/dbus-1. For simplicity, we only do this if
 1543 # ${sysconfdir} = ${prefix}/etc and ${datadir} = ${prefix}/share.
 1544 #
 1545 # On Unix, or on Windows with weird install layouts, it's the absolute path.
 1546 AS_IF([test "${dbus_win}" = yes && \
 1547        test "$EXPANDED_SYSCONFDIR" = "$EXPANDED_PREFIX/etc" && \
 1548        test "$EXPANDED_DATADIR" = "$EXPANDED_PREFIX/share"],
 1549       [SYSCONFDIR_FROM_PKGDATADIR="../../etc"
 1550        DATADIR_FROM_PKGSYSCONFDIR="../../share"],
 1551       [SYSCONFDIR_FROM_PKGDATADIR="$EXPANDED_SYSCONFDIR"
 1552        DATADIR_FROM_PKGSYSCONFDIR="$EXPANDED_DATADIR"])
 1553 AC_SUBST([SYSCONFDIR_FROM_PKGDATADIR])
 1554 AC_SUBST([DATADIR_FROM_PKGSYSCONFDIR])
 1555 
 1556 #### Tell tests where to find certain stuff in builddir
 1557 
 1558 DBUS_PWD=`pwd`
 1559 # Useful in a cross-compilation environment, where the tests are run on the host system.
 1560 AC_ARG_WITH(dbus-test-dir, AS_HELP_STRING([--with-dbus-test-dir=[dirname]],[path where the tests tools are available]),
 1561 			   DBUS_PWD=$withval)
 1562 
 1563 DBUS_TEST_EXEC="$DBUS_PWD/test"
 1564 DBUS_TEST_DATA="$DBUS_PWD/test/data"
 1565 
 1566 AC_SUBST([DBUS_TEST_DATA])
 1567 AC_SUBST([DBUS_TEST_EXEC])
 1568 
 1569 AC_DEFINE_UNQUOTED([DBUS_EXEEXT], ["$EXEEXT"],
 1570                    [Extension for executables, typically empty or .exe])
 1571 
 1572 ## Export the non-setuid external helper
 1573 TEST_LAUNCH_HELPER_BINARY="$DBUS_TEST_EXEC/dbus-daemon-launch-helper-for-tests$EXEEXT"
 1574 AC_SUBST(TEST_LAUNCH_HELPER_BINARY)
 1575 AC_DEFINE_UNQUOTED(DBUS_TEST_LAUNCH_HELPER_BINARY, "$TEST_LAUNCH_HELPER_BINARY",
 1576                    [Full path to the launch helper test program in the builddir])
 1577 
 1578 #### Find socket directories
 1579 if ! test -z "$TMPDIR" ; then
 1580    DEFAULT_SOCKET_DIR=$TMPDIR
 1581 elif ! test -z "$TEMP" ; then
 1582    DEFAULT_SOCKET_DIR=$TEMP
 1583 elif ! test -z "$TMP" ; then
 1584    DEFAULT_SOCKET_DIR=$TMP
 1585 else
 1586    DEFAULT_SOCKET_DIR=/tmp
 1587 fi
 1588 
 1589 DEFAULT_SOCKET_DIR=`echo $DEFAULT_SOCKET_DIR | sed 's/+/%2B/g'`
 1590 
 1591 if ! test -z "$with_test_socket_dir" ; then
 1592    TEST_SOCKET_DIR="$with_test_socket_dir"
 1593 else
 1594    TEST_SOCKET_DIR=$DEFAULT_SOCKET_DIR
 1595 fi
 1596 AC_SUBST(TEST_SOCKET_DIR)
 1597 AC_DEFINE_UNQUOTED(DBUS_TEST_SOCKET_DIR, "$TEST_SOCKET_DIR", [Where to put test sockets])
 1598 
 1599 if test "x$dbus_unix" = xyes; then
 1600   TEST_LISTEN="unix:tmpdir=$TEST_SOCKET_DIR"
 1601 else
 1602   TEST_LISTEN="tcp:host=localhost"
 1603 fi
 1604 AC_SUBST([TEST_LISTEN])
 1605 AC_DEFINE_UNQUOTED([TEST_LISTEN], ["$TEST_LISTEN"],
 1606   [Listening address for regression tests])
 1607 
 1608 if ! test -z "$with_session_socket_dir" ; then
 1609    DBUS_SESSION_SOCKET_DIR="$with_session_socket_dir"
 1610 else
 1611    DBUS_SESSION_SOCKET_DIR=$DEFAULT_SOCKET_DIR
 1612 fi
 1613 AC_DEFINE_UNQUOTED(DBUS_SESSION_SOCKET_DIR, "$DBUS_SESSION_SOCKET_DIR", [Where per-session bus puts its sockets])
 1614 AC_SUBST(DBUS_SESSION_SOCKET_DIR)
 1615 
 1616 # This must be a listening address. It doesn't necessarily need to be an
 1617 # address you can connect to - it can be something vague like
 1618 # "nonce-tcp:".
 1619 #
 1620 # The default varies by platform.
 1621 AC_ARG_WITH([dbus_session_bus_listen_address],
 1622             AS_HELP_STRING([--with-dbus-session-bus-listen-address=[ADDRESS]],
 1623                            [default address for a session bus to listen on (see configure.ac)]),
 1624             [with_dbus_session_bus_listen_address=$withval],
 1625             [with_dbus_session_bus_listen_address=])
 1626 
 1627 if test "x$with_dbus_session_bus_listen_address" != "x"; then
 1628         # the user specified something, trust them
 1629         DBUS_SESSION_BUS_LISTEN_ADDRESS="$with_dbus_session_bus_listen_address"
 1630 elif test x$dbus_win = xyes; then
 1631         # On Windows, you can (and should) listen on autolaunch addresses,
 1632         # because autolaunching is different.
 1633         # See https://bugs.freedesktop.org/show_bug.cgi?id=38201
 1634         DBUS_SESSION_BUS_LISTEN_ADDRESS="autolaunch:"
 1635 elif test x$have_launchd = xyes; then
 1636         # Mac OS X default is to use launchd
 1637         DBUS_SESSION_BUS_LISTEN_ADDRESS="launchd:env=DBUS_LAUNCHD_SESSION_BUS_SOCKET"
 1638 else
 1639         # The default on all other Unix platforms (notably Linux)
 1640         # is to create a randomly named socket in /tmp or similar
 1641         DBUS_SESSION_BUS_LISTEN_ADDRESS="unix:tmpdir=$DBUS_SESSION_SOCKET_DIR"
 1642 fi
 1643 AC_SUBST([DBUS_SESSION_BUS_LISTEN_ADDRESS])
 1644 
 1645 # This must be an address you can connect to. It doesn't necessarily
 1646 # need to be an address you can listen on - it can be "autolaunch:",
 1647 # even on Unix.
 1648 #
 1649 # The default varies by platform.
 1650 AC_ARG_WITH([dbus_session_bus_connect_address],
 1651             AS_HELP_STRING([--with-dbus-session-bus-connect-address=[ADDRESS]],
 1652                            [fallback address for a session bus client to connect to (see configure.ac)]),
 1653             [with_dbus_session_bus_connect_address=$withval],
 1654             [with_dbus_session_bus_connect_address=])
 1655 
 1656 if test "x$with_dbus_session_bus_connect_address" != "x"; then
 1657         # the user specified something, trust them
 1658         DBUS_SESSION_BUS_CONNECT_ADDRESS="$with_dbus_session_bus_connect_address"
 1659 elif test x$dbus_win = xyes; then
 1660         # Windows autolaunching is a bit different; leaving it in its own
 1661         # branch of the conditional because the default might conceivably
 1662         # change (see #38201)
 1663         DBUS_SESSION_BUS_CONNECT_ADDRESS="autolaunch:"
 1664 else
 1665         # The default on all other Unix platforms (notably Linux)
 1666         # is to use auto-launching - this works a bit differently on Mac OS X
 1667         # but comes out basically the same in the end
 1668         DBUS_SESSION_BUS_CONNECT_ADDRESS="autolaunch:"
 1669 fi
 1670 AC_SUBST([DBUS_SESSION_BUS_CONNECT_ADDRESS])
 1671 AC_DEFINE_UNQUOTED([DBUS_SESSION_BUS_CONNECT_ADDRESS],
 1672   ["$DBUS_SESSION_BUS_CONNECT_ADDRESS"],
 1673   [Fallback address for session bus clients])
 1674 
 1675 # darwin needs this to initialize the environment
 1676 AC_CHECK_FUNC(_NSGetEnviron, [AC_DEFINE(HAVE_NSGETENVIRON, 1, [Define if your system needs _NSGetEnviron to set up the environment])])
 1677 AH_VERBATIM(_DARWIN_ENVIRON,
 1678 [
 1679 #if defined(HAVE_NSGETENVIRON) && defined(HAVE_CRT_EXTERNS_H)
 1680 # include <sys/time.h>
 1681 # include <crt_externs.h>
 1682 # define environ (*_NSGetEnviron())
 1683 #endif
 1684 ])
 1685 
 1686 AC_ARG_ENABLE([stats],
 1687   [AS_HELP_STRING([--disable-stats],
 1688     [disable bus daemon usage statistics])],
 1689   [], [enable_stats=yes])
 1690 if test "x$enable_stats" = xyes; then
 1691   AC_DEFINE([DBUS_ENABLE_STATS], [1],
 1692     [Define to enable bus daemon usage statistics])
 1693 fi
 1694 
 1695 AC_ARG_ENABLE([user-session],
 1696   [AS_HELP_STRING([--enable-user-session],
 1697     [enable user-session semantics for session bus under systemd])],
 1698   [], [enable_user_session=no])
 1699 AM_CONDITIONAL([DBUS_ENABLE_USER_SESSION],
 1700   [test "x$enable_user_session" = xyes])
 1701 
 1702 AC_ARG_ENABLE([containers],
 1703   [AS_HELP_STRING([--enable-containers],
 1704     [enable restricted servers for app containers])],
 1705   [], [enable_containers=no])
 1706 AS_IF([test "x$enable_containers" = xyes && test "x$dbus_unix" != xyes],
 1707   [AC_MSG_ERROR([Restricted servers for app containers require Unix])])
 1708 AS_IF([test "x$enable_containers" = xyes],
 1709   [AC_DEFINE([DBUS_ENABLE_CONTAINERS], [1],
 1710     [Define to enable restricted servers for app containers])])
 1711 
 1712 AC_CONFIG_FILES([
 1713 Doxyfile
 1714 dbus/Version
 1715 dbus/versioninfo.rc
 1716 dbus/dbus-arch-deps.h
 1717 bus/system.conf
 1718 bus/session.conf
 1719 bus/legacy-config/system.conf
 1720 bus/legacy-config/session.conf
 1721 bus/example-system-enable-stats.conf
 1722 bus/example-session-disable-stats.conf
 1723 bus/org.freedesktop.dbus-session.plist
 1724 bus/dbus.service
 1725 bus/dbus.socket
 1726 bus/systemd-user/dbus.service
 1727 bus/systemd-user/dbus.socket
 1728 bus/sysusers.d/dbus.conf
 1729 bus/tmpfiles.d/dbus.conf
 1730 Makefile
 1731 dbus/Makefile
 1732 bus/Makefile
 1733 tools/Makefile
 1734 test/Makefile
 1735 test/name-test/Makefile
 1736 doc/Makefile
 1737 doc/dbus-cleanup-sockets.1.xml
 1738 doc/dbus-daemon.1.xml
 1739 doc/dbus-launch.1.xml
 1740 doc/dbus-monitor.1.xml
 1741 doc/dbus-run-session.1.xml
 1742 doc/dbus-send.1.xml
 1743 doc/dbus-test-tool.1.xml
 1744 doc/dbus-update-activation-environment.1.xml
 1745 doc/dbus-uuidgen.1.xml
 1746 doc/index.html
 1747 dbus-1.pc
 1748 dbus-1-uninstalled.pc
 1749 cmake/DBus1Config.cmake:cmake/DBus1Config.pkgconfig.in
 1750 cmake/DBus1ConfigVersion.cmake
 1751 ])
 1752 AC_OUTPUT
 1753 
 1754 dnl ==========================================================================
 1755 echo "
 1756                     D-Bus $VERSION
 1757                   ==============
 1758 
 1759 	prefix:                   ${EXPANDED_PREFIX}
 1760 	exec_prefix:              ${exec_prefix}
 1761         libdir:                   ${EXPANDED_LIBDIR}
 1762         libexecdir:               ${EXPANDED_LIBEXECDIR}
 1763         bindir:                   ${EXPANDED_BINDIR}
 1764         sysconfdir:               ${EXPANDED_SYSCONFDIR}
 1765         localstatedir:            ${EXPANDED_LOCALSTATEDIR}
 1766         runstatedir:              ${EXPANDED_RUNSTATEDIR}
 1767 	datadir:                  ${EXPANDED_DATADIR}
 1768 	source code location:	  ${srcdir}
 1769 	compiler:		  ${CC}
 1770 	cflags:		          ${CFLAGS}
 1771 	cppflags:		  ${CPPFLAGS}
 1772 	cxxflags:		  ${CXXFLAGS}
 1773 	ldflags:		  ${LDFLAGS}
 1774 	64-bit int:		  ${DBUS_INT64_TYPE}
 1775 	32-bit int:		  ${DBUS_INT32_TYPE}
 1776 	16-bit int:		  ${DBUS_INT16_TYPE}
 1777         Doxygen:                  ${DOXYGEN:-not found}
 1778         xmlto:                    ${XMLTO:-not found}
 1779         ducktype:                 ${DUCKTYPE:-not found}
 1780         yelp-build:               ${YELP_BUILD:-not found}"
 1781 
 1782 echo "
 1783         Rebuilding generated files: ${USE_MAINTAINER_MODE}
 1784         gcc coverage profiling:   ${enable_code_coverage}
 1785         Building embedded tests:  ${enable_embedded_tests}
 1786         Building modular tests:   ${enable_modular_tests}
 1787             - with GLib:          ${with_glib}
 1788         Installing tests:         ${enable_installed_tests}
 1789         Building verbose mode:    ${enable_verbose_mode}
 1790         Building assertions:      ${enable_asserts}
 1791         Building checks:          ${enable_checks}
 1792         Building bus stats API:   ${enable_stats}
 1793         Building container API:   ${enable_containers}
 1794         Building SELinux support: ${have_selinux}
 1795         Building AppArmor support: ${have_apparmor}
 1796         Building inotify support: ${have_inotify}
 1797         Building kqueue support:  ${have_kqueue}
 1798         Building systemd support: ${have_systemd}
 1799         Traditional activation:   ${enable_traditional_activation}
 1800         Building X11 code:        ${have_x11}
 1801         Building Doxygen docs:    ${enable_doxygen_docs}
 1802         Building Qt help file:    ${enable_qthelp_docs}
 1803         Building Ducktype docs:   ${enable_ducktype_docs}
 1804         Building XML docs:        ${enable_xml_docs}
 1805         Building launchd support: ${have_launchd}
 1806         System bus socket:        ${DBUS_SYSTEM_SOCKET}
 1807         System bus address:       ${DBUS_SYSTEM_BUS_DEFAULT_ADDRESS}
 1808         System bus PID file:      ${DBUS_SYSTEM_PID_FILE}
 1809         Session bus listens on:   ${DBUS_SESSION_BUS_LISTEN_ADDRESS}
 1810         Session clients connect to: ${DBUS_SESSION_BUS_CONNECT_ADDRESS}
 1811         pam_console auth dir:     ${with_console_auth_dir:-(none)}
 1812         Console owner file:       ${have_console_owner_file}
 1813         Console owner file path:  ${DBUS_CONSOLE_OWNER_FILE}
 1814 	System bus user:          ${DBUS_USER}
 1815 	Session bus services dir: ${EXPANDED_DATADIR}/dbus-1/services
 1816         'make check' socket dir:  ${TEST_SOCKET_DIR}
 1817 "
 1818 if test x$have_launchd = xyes; then
 1819         echo "        launchd agent dir:        ${LAUNCHD_AGENT_DIR}"
 1820 fi
 1821 echo
 1822 
 1823 if test x$enable_embedded_tests = xyes; then
 1824         echo "NOTE: building with unit tests increases the size of the installed library and renders it insecure."
 1825 fi
 1826 if test x$enable_embedded_tests = xyes -a x$enable_asserts = xno; then
 1827         echo "NOTE: building with embedded tests but without assertions means tests may not properly report failures (this configuration is only useful when doing something like profiling the tests)"
 1828 fi
 1829 AS_IF([test x$enable_code_coverage = xyes],[
 1830     AC_MSG_WARN([Building with coverage profiling is definitely for developers only.])
 1831   ])
 1832 if test x$enable_verbose_mode = xyes; then
 1833         echo "NOTE: building with verbose mode increases library size, may slightly increase security risk, and decreases performance."
 1834 fi
 1835 if test x$enable_asserts = xyes; then
 1836         echo "NOTE: building with assertions increases library size and decreases performance."
 1837 fi
 1838 if test x$enable_checks = xno; then
 1839         echo "NOTE: building without checks for arguments passed to public API makes it harder to debug apps using D-Bus, but will slightly decrease D-Bus library size and _very_ slightly improve performance."
 1840 fi