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