configure.ac

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