configure.ac

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