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