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