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