1: dnl -*- mode: m4 -*-
    2: AC_PREREQ(2.52)
    3: 
    4: AC_INIT(dbus/dbus.h)
    5: 
    6: AC_CANONICAL_TARGET
    7: 
    8: AM_INIT_AUTOMAKE(dbus, 1.0.2)
    9: 
   10: AM_CONFIG_HEADER(config.h)
   11: 
   12: # Honor aclocal flags
   13: ACLOCAL="$ACLOCAL $ACLOCAL_FLAGS"
   14: 
   15: GETTEXT_PACKAGE=dbus-1
   16: AC_SUBST(GETTEXT_PACKAGE)
   17: AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE",[The name of the gettext domain])
   18: 
   19:  ## must come before we use the $USE_MAINTAINER_MODE variable later
   20: AM_MAINTAINER_MODE
   21: 
   22: # libtool versioning - this applies to libdbus
   23: #
   24: # See http://sources.redhat.com/autobook/autobook/autobook_91.html#SEC91 for details
   25: #
   26: 
   27: ## increment if the interface has additions, changes, removals.
   28: LT_CURRENT=5
   29: 
   30: ## increment any time the source changes; set to
   31: ##  0 if you increment CURRENT
   32: LT_REVISION=0
   33: 
   34: ## increment if any interfaces have been added; set to 0
   35: ## if any interfaces have been changed or removed. removal has
   36: ## precedence over adding, so set to 0 if both happened.
   37: LT_AGE=2
   38: 
   39: AC_SUBST(LT_CURRENT)
   40: AC_SUBST(LT_REVISION)
   41: AC_SUBST(LT_AGE)
   42: 
   43: 
   44: AC_PROG_CC
   45: AC_PROG_CXX
   46: AC_ISC_POSIX
   47: AC_HEADER_STDC
   48: 
   49: AC_ARG_ENABLE(tests, AS_HELP_STRING([--enable-tests],[enable unit test code]),enable_tests=$enableval,enable_tests=$USE_MAINTAINER_MODE)
   50: AC_ARG_ENABLE(ansi, AS_HELP_STRING([--enable-ansi],[enable -ansi -pedantic gcc flags]),enable_ansi=$enableval,enable_ansi=no)
   51: AC_ARG_ENABLE(verbose-mode, AS_HELP_STRING([--enable-verbose-mode],[support verbose debug mode]),enable_verbose_mode=$enableval,enable_verbose_mode=$USE_MAINTAINER_MODE)
   52: AC_ARG_ENABLE(asserts, AS_HELP_STRING([--enable-asserts],[include assertion checks]),enable_asserts=$enableval,enable_asserts=$USE_MAINTAINER_MODE)
   53: AC_ARG_ENABLE(checks, AS_HELP_STRING([--enable-checks],[include sanity checks on public API]),enable_checks=$enableval,enable_checks=yes)
   54: AC_ARG_ENABLE(xml-docs, AS_HELP_STRING([--enable-xml-docs],[build XML documentation (requires xmlto)]),enable_xml_docs=$enableval,enable_xml_docs=auto)
   55: AC_ARG_ENABLE(doxygen-docs, AS_HELP_STRING([--enable-doxygen-docs],[build DOXYGEN documentation (requires Doxygen)]),enable_doxygen_docs=$enableval,enable_doxygen_docs=auto)
   56: AC_ARG_ENABLE(gcov, AS_HELP_STRING([--enable-gcov],[compile with coverage profiling instrumentation (gcc only)]),enable_gcov=$enableval,enable_gcov=no)
   57: 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)
   58: AC_ARG_ENABLE(selinux, AS_HELP_STRING([--enable-selinux],[build with SELinux support]),enable_selinux=$enableval,enable_selinux=auto)
   59: AC_ARG_ENABLE(dnotify, AS_HELP_STRING([--enable-dnotify],[build with dnotify support (linux only)]),enable_dnotify=$enableval,enable_dnotify=auto)
   60: AC_ARG_ENABLE(kqueue, AS_HELP_STRING([--enable-kqueue],[build with kqueue support]),enable_kqueue=$enableval,enable_kqueue=auto)
   61: 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)
   62: 
   63: AC_ARG_WITH(xml, AS_HELP_STRING([--with-xml=[libxml/expat]],[XML library to use]))
   64: AC_ARG_WITH(init-scripts, AS_HELP_STRING([--with-init-scripts=[redhat]],[Style of init scripts to install]))
   65: 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]))
   66: AC_ARG_WITH(test-socket-dir, AS_HELP_STRING([--with-test-socket-dir=[dirname]],[Where to put sockets for make check]))
   67: AC_ARG_WITH(system-pid-file, AS_HELP_STRING([--with-system-pid-file=[pidfile]],[PID file for systemwide daemon]))
   68: AC_ARG_WITH(system-socket, AS_HELP_STRING([--with-system-socket=[filename]],[UNIX domain socket for systemwide daemon]))
   69: AC_ARG_WITH(console-auth-dir, AS_HELP_STRING([--with-console-auth-dir=[dirname]],[directory to check for console ownerhip]))
   70: AC_ARG_WITH(console-owner-file, AS_HELP_STRING([--with-console-owner-file=[filename]],[file whose owner determines current console owner]))
   71: AC_ARG_WITH(dbus_user, AS_HELP_STRING([--with-dbus-user=<user>],[User for running the DBUS daemon (messagebus)]))
   72: AC_ARG_WITH(dbus_daemondir, AS_HELP_STRING([--with-dbus-daemondir=[dirname]],[Directory for installing the DBUS daemon]))
   73: 
   74: 
   75: dnl DBUS_BUILD_TESTS controls unit tests built in to .c files 
   76: dnl and also some stuff in the test/ subdir
   77: AM_CONDITIONAL(DBUS_BUILD_TESTS, test x$enable_tests = xyes)
   78: if test x$enable_tests = xyes; then
   79:     AC_DEFINE(DBUS_BUILD_TESTS,1,[Build test code])
   80: fi
   81: 
   82: if test x$enable_verbose_mode = xyes; then
   83:     AC_DEFINE(DBUS_ENABLE_VERBOSE_MODE,1,[Support a verbose mode])
   84: fi
   85: 
   86: if test x$enable_asserts = xno; then
   87:     AC_DEFINE(DBUS_DISABLE_ASSERT,1,[Disable assertion checking])
   88:     AC_DEFINE(G_DISABLE_ASSERT,1,[Disable GLib assertion macros])
   89:     R_DYNAMIC_LDFLAG=""
   90: else
   91:     # -rdynamic is needed for glibc's backtrace_symbols to work.
   92:     # No clue how much overhead this adds, but it's useful 
   93:     # to do this on any assertion failure,
   94:     # so for now it's enabled anytime asserts are (currently not
   95:     # in production builds).
   96: 
   97:     # To get -rdynamic you pass -export-dynamic to libtool.
   98:     AC_DEFINE(DBUS_BUILT_R_DYNAMIC,1,[whether -export-dynamic was passed to libtool])
   99:     R_DYNAMIC_LDFLAG=-export-dynamic
  100: fi
  101: AC_SUBST(R_DYNAMIC_LDFLAG)
  102: 
  103: if test x$enable_checks = xno; then
  104:     AC_DEFINE(DBUS_DISABLE_CHECKS,1,[Disable public API sanity checking])
  105:     AC_DEFINE(G_DISABLE_CHECKS,1,[Disable GLib public API sanity checking])
  106: fi
  107: 
  108: #### gcc warning flags
  109: 
  110: cc_supports_flag() {
  111:   AC_MSG_CHECKING(whether $CC supports "$@")
  112:   Cfile=/tmp/foo${$}
  113:   touch ${Cfile}.c
  114:   $CC -c "$@" ${Cfile}.c -o ${Cfile}.o >/dev/null 2>&1
  115:   rc=$?
  116:   rm -f ${Cfile}.c ${Cfile}.o
  117:   case $rc in
  118:     0) AC_MSG_RESULT(yes);;
  119:     *) AC_MSG_RESULT(no);;
  120:   esac
  121:   return $rc
  122: }
  123: 
  124: if test "x$GCC" = "xyes"; then
  125:   changequote(,)dnl
  126:   case " $CFLAGS " in
  127:   *[\ \ ]-Wall[\ \      ]*) ;;
  128:   *) CFLAGS="$CFLAGS -Wall" ;;
  129:   esac
  130: 
  131:   case " $CFLAGS " in
  132:   *[\ \ ]-Wchar-subscripts[\ \  ]*) ;;
  133:   *) CFLAGS="$CFLAGS -Wchar-subscripts" ;;
  134:   esac
  135: 
  136:   case " $CFLAGS " in
  137:   *[\ \ ]-Wmissing-declarations[\ \     ]*) ;;
  138:   *) CFLAGS="$CFLAGS -Wmissing-declarations" ;;
  139:   esac
  140: 
  141:   case " $CFLAGS " in
  142:   *[\ \ ]-Wmissing-prototypes[\ \       ]*) ;;
  143:   *) CFLAGS="$CFLAGS -Wmissing-prototypes" ;;
  144:   esac
  145: 
  146:   case " $CFLAGS " in
  147:   *[\ \ ]-Wnested-externs[\ \   ]*) ;;
  148:   *) CFLAGS="$CFLAGS -Wnested-externs" ;;
  149:   esac
  150: 
  151:   case " $CFLAGS " in
  152:   *[\ \ ]-Wpointer-arith[\ \    ]*) ;;
  153:   *) CFLAGS="$CFLAGS -Wpointer-arith" ;;
  154:   esac
  155: 
  156:   case " $CFLAGS " in
  157:   *[\ \ ]-Wcast-align[\ \       ]*) ;;
  158:   *) CFLAGS="$CFLAGS -Wcast-align" ;;
  159:   esac
  160: 
  161:   case " $CFLAGS " in
  162:   *[\ \ ]-Wfloat-equal[\ \      ]*) ;;
  163:   *) if cc_supports_flag -Wfloat-equals; then
  164:         CFLAGS="$CFLAGS -Wfloat-equal" 
  165:      fi
  166:      ;;
  167:   esac
  168: 
  169:   case " $CFLAGS " in
  170:   *[\ \ ]-Wsign-compare[\ \     ]*) ;;
  171:   *) CFLAGS="$CFLAGS -Wsign-compare" ;;
  172:   esac
  173: 
  174:   case " $CFLAGS " in
  175:   *[\ \ ]-Wdeclaration-after-statement[\ \      ]*) ;;
  176:   *) if cc_supports_flag -Wdeclaration-after-statement; then
  177:         CFLAGS="$CFLAGS -Wdeclaration-after-statement"
  178:      fi
  179:      ;;
  180:   esac
  181: 
  182:   case " $CFLAGS " in
  183:   *[\ \ ]-fno-common[\ \        ]*) ;;
  184:   *) if cc_supports_flag -fno-common; then
  185:         CFLAGS="$CFLAGS -fno-common"
  186:      fi
  187:      ;;
  188:   esac
  189: 
  190:   case " $CFLAGS " in
  191:   *[\ \ ]-fPIC[\ \      ]*) ;;
  192:   *) if cc_supports_flag -fPIC; then
  193:         CFLAGS="$CFLAGS -fPIC"
  194:      fi
  195:      ;;
  196:   esac
  197: 
  198:   if test "x$enable_ansi" = "xyes"; then
  199:     case " $CFLAGS " in
  200:     *[\ \       ]-ansi[\ \    ]*) ;;
  201:     *) CFLAGS="$CFLAGS -ansi" ;;
  202:     esac
  203: 
  204:     case " $CFLAGS " in
  205:     *[\ \       ]-D_POSIX_C_SOURCE*) ;;
  206:     *) CFLAGS="$CFLAGS -D_POSIX_C_SOURCE=199309L" ;;
  207:     esac
  208: 
  209:     case " $CFLAGS " in
  210:     *[\ \       ]-D_BSD_SOURCE[\ \    ]*) ;;
  211:     *) CFLAGS="$CFLAGS -D_BSD_SOURCE" ;;
  212:     esac
  213: 
  214:     case " $CFLAGS " in
  215:     *[\ \       ]-pedantic[\ \        ]*) ;;
  216:     *) CFLAGS="$CFLAGS -pedantic" ;;
  217:     esac
  218:   fi
  219:   if test x$enable_gcov = xyes; then
  220:     case " $CFLAGS " in
  221:     *[\ \       ]-fprofile-arcs[\ \   ]*) ;;
  222:     *) CFLAGS="$CFLAGS -fprofile-arcs" ;;
  223:     esac
  224:     case " $CFLAGS " in
  225:     *[\ \       ]-ftest-coverage[\ \  ]*) ;;
  226:     *) CFLAGS="$CFLAGS -ftest-coverage" ;;
  227:     esac
  228: 
  229:     ## remove optimization
  230:     CFLAGS=`echo "$CFLAGS" | sed -e 's/-O[0-9]*//g'`
  231:   fi
  232:   changequote([,])dnl
  233: else
  234:   if test x$enable_gcov = xyes; then
  235:     AC_MSG_ERROR([--enable-gcov can only be used with gcc])
  236:   fi
  237: fi
  238: 
  239: # Add -D_POSIX_PTHREAD_SEMANTICS if on Solaris
  240: #
  241: case $target_os in
  242:     solaris*)
  243:        CFLAGS="$CFLAGS -D_POSIX_PTHREAD_SEMANTICS" ;;
  244: esac
  245:     
  246: AM_PROG_LIBTOOL
  247: 
  248: changequote(,)dnl
  249: # compress spaces in flags
  250: CFLAGS=`echo "$CFLAGS" | sed -e 's/ +/ /g'`
  251: CXXFLAGS=`echo "$CXXFLAGS" | sed -e 's/ +/ /g'`
  252: CPPFLAGS=`echo "$CPPFLAGS" | sed -e 's/ +/ /g'`
  253: changequote([,])dnl
  254: 
  255: if test x$enable_gcov = xyes; then
  256:      ## so that config.h changes when you toggle gcov support
  257:      AC_DEFINE_UNQUOTED(DBUS_GCOV_ENABLED, 1, [Defined if gcov is enabled to force a rebuild due to config.h changing])
  258: 
  259:      AC_MSG_CHECKING([for gcc 3.3 version of gcov file format])
  260:      have_gcc33_gcov=no
  261:      AC_RUN_IFELSE( [AC_LANG_PROGRAM( , [[ if (__GNUC__ >=3 && __GNUC_MINOR__ >= 3) exit (0); else exit (1); ]])],  
  262:                    have_gcc33_gcov=yes)
  263:      if test x$have_gcc33_gcov = xyes ; then
  264:          AC_DEFINE_UNQUOTED(DBUS_HAVE_GCC33_GCOV, 1, [Defined if we have gcc 3.3 and thus the new gcov format])
  265:      fi
  266:      AC_MSG_RESULT($have_gcc33_gcov)
  267: fi
  268: AM_CONDITIONAL(DBUS_GCOV_ENABLED, test x$enable_gcov = xyes)
  269: 
  270: #### Integer sizes 
  271: 
  272: AC_CHECK_SIZEOF(char)
  273: AC_CHECK_SIZEOF(short)
  274: AC_CHECK_SIZEOF(long)
  275: AC_CHECK_SIZEOF(int)
  276: AC_CHECK_SIZEOF(void *)
  277: AC_CHECK_SIZEOF(long long)
  278: AC_CHECK_SIZEOF(__int64)
  279: 
  280: ### See what our 64 bit type is called
  281: AC_MSG_CHECKING([64-bit integer type])
  282: 
  283: case 8 in
  284: $ac_cv_sizeof_int)
  285:   dbusint64=int
  286:   dbusint64_constant='(val)'
  287:   dbusuint64_constant='(val)'
  288:   ;;
  289: $ac_cv_sizeof_long)
  290:   dbusint64=long
  291:   dbusint64_constant='(val##L)'
  292:   dbusuint64_constant='(val##UL)'
  293:   ;;
  294: $ac_cv_sizeof_long_long)
  295:   dbusint64='long long'
  296:   dbusint64_constant='(val##LL)'
  297:   dbusuint64_constant='(val##ULL)'
  298:   ;;
  299: $ac_cv_sizeof___int64)
  300:   dbusint64=__int64
  301:   dbusint64_constant='(val##i64)'
  302:   dbusuint64_constant='(val##ui64)'
  303:   ;;
  304: esac
  305: 
  306: if test -z "$dbusint64" ; then
  307:         DBUS_INT64_TYPE="no_int64_type_detected"
  308:         DBUS_HAVE_INT64=0
  309:         DBUS_INT64_CONSTANT=
  310:         DBUS_UINT64_CONSTANT=
  311:         AC_MSG_RESULT([none found])
  312: else
  313:         DBUS_INT64_TYPE="$dbusint64"
  314:         DBUS_HAVE_INT64=1
  315:         DBUS_INT64_CONSTANT="$dbusint64_constant"
  316:         DBUS_UINT64_CONSTANT="$dbusuint64_constant"
  317:         AC_MSG_RESULT($DBUS_INT64_TYPE)
  318: fi
  319: 
  320: AC_SUBST(DBUS_INT64_TYPE)
  321: AC_SUBST(DBUS_INT64_CONSTANT)
  322: AC_SUBST(DBUS_UINT64_CONSTANT)
  323: AC_SUBST(DBUS_HAVE_INT64)
  324: 
  325: ### see what 32-bit int is called
  326: AC_MSG_CHECKING([32-bit integer type])
  327: 
  328: case 4 in
  329: $ac_cv_sizeof_short)
  330:   dbusint32=int
  331:   ;;
  332: $ac_cv_sizeof_int)
  333:   dbusint32=int
  334:   ;;
  335: $ac_cv_sizeof_long)
  336:   dbusint32=long
  337:   ;;
  338: esac
  339: 
  340: if test -z "$dbusint32" ; then
  341:         DBUS_INT32_TYPE="no_int32_type_detected"
  342:         AC_MSG_ERROR([No 32-bit integer type found])
  343: else
  344:         DBUS_INT32_TYPE="$dbusint32"
  345:         AC_MSG_RESULT($DBUS_INT32_TYPE)
  346: fi
  347: 
  348: AC_SUBST(DBUS_INT32_TYPE)
  349: 
  350: ### see what 16-bit int is called
  351: AC_MSG_CHECKING([16-bit integer type])
  352: 
  353: case 2 in
  354: $ac_cv_sizeof_short)
  355:   dbusint16=short
  356:   ;;
  357: $ac_cv_sizeof_int)
  358:   dbusint16=int
  359:   ;;
  360: esac
  361: 
  362: if test -z "$dbusint16" ; then
  363:         DBUS_INT16_TYPE="no_int16_type_detected"
  364:         AC_MSG_ERROR([No 16-bit integer type found])
  365: else
  366:         DBUS_INT16_TYPE="$dbusint16"
  367:         AC_MSG_RESULT($DBUS_INT16_TYPE)
  368: fi
  369: 
  370: AC_SUBST(DBUS_INT16_TYPE)
  371: 
  372: ## byte order
  373: case $host_os in
  374:         darwin*)
  375:                 # check at compile-time, so that it is possible to build universal
  376:                 # (with multiple architectures at once on the compile line)
  377:                 AH_VERBATIM([WORDS_BIGENDIAN_DARWIN], [
  378:                         /* Use the compiler-provided endianness defines to allow universal compiling. */
  379:                         #if defined(__BIG_ENDIAN__)
  380:                         #define WORDS_BIGENDIAN 1
  381:                         #endif
  382:                 ])
  383:                 ;;
  384:         *)
  385:                 AC_C_BIGENDIAN
  386:                 ;;
  387: esac
  388: 
  389: dnl **********************************
  390: dnl *** va_copy checks (from GLib) ***
  391: dnl **********************************
  392: dnl we currently check for all three va_copy possibilities, so we get
  393: dnl all results in config.log for bug reports.
  394: AC_CACHE_CHECK([for an implementation of va_copy()],dbus_cv_va_copy,[
  395:         AC_LINK_IFELSE([#include <stdarg.h>
  396:         void f (int i, ...) {
  397:         va_list args1, args2;
  398:         va_start (args1, i);
  399:         va_copy (args2, args1);
  400:         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
  401:           exit (1);
  402:         va_end (args1); va_end (args2);
  403:         }
  404:         int main() {
  405:           f (0, 42);
  406:           return 0;
  407:         }],
  408:         [dbus_cv_va_copy=yes],
  409:         [dbus_cv_va_copy=no])
  410: ])
  411: AC_CACHE_CHECK([for an implementation of __va_copy()],dbus_cv___va_copy,[
  412:         AC_LINK_IFELSE([#include <stdarg.h>
  413:         void f (int i, ...) {
  414:         va_list args1, args2;
  415:         va_start (args1, i);
  416:         __va_copy (args2, args1);
  417:         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
  418:           exit (1);
  419:         va_end (args1); va_end (args2);
  420:         }
  421:         int main() {
  422:           f (0, 42);
  423:           return 0;
  424:         }],
  425:         [dbus_cv___va_copy=yes],
  426:         [dbus_cv___va_copy=no])
  427: ])
  428: 
  429: if test "x$dbus_cv_va_copy" = "xyes"; then
  430:   dbus_va_copy_func=va_copy
  431: else if test "x$dbus_cv___va_copy" = "xyes"; then
  432:   dbus_va_copy_func=__va_copy
  433: fi
  434: fi
  435: 
  436: if test -n "$dbus_va_copy_func"; then
  437:   AC_DEFINE_UNQUOTED(DBUS_VA_COPY,$dbus_va_copy_func,[A 'va_copy' style function])
  438: fi
  439: 
  440: AC_LANG_PUSH(C)
  441: AC_CACHE_CHECK([whether va_lists can be copied by value],
  442:         dbus_cv_va_val_copy,
  443:         [AC_RUN_IFELSE([AC_LANG_PROGRAM(
  444: [[
  445:         #include <stdarg.h>
  446: ]],
  447: [[
  448:         void f (int i, ...) {
  449:         va_list args1, args2;
  450:         va_start (args1, i);
  451:         args2 = args1;
  452:         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
  453:           exit (1);
  454:         va_end (args1); va_end (args2);
  455:         }
  456:         int main() {
  457:           f (0, 42);
  458:           return 0;
  459:         }
  460: ]])],
  461:         [dbus_cv_va_val_copy=yes],
  462:         [dbus_cv_va_val_copy=no],
  463:         [dbus_cv_va_val_copy=yes])
  464: ])
  465: AC_LANG_POP(C)
  466: 
  467: if test "x$dbus_cv_va_val_copy" = "xno"; then
  468:   AC_DEFINE(DBUS_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
  469: fi
  470: 
  471: 
  472: #### Atomic integers (checks by Sebastian Wilhelmi for GLib)
  473: AC_MSG_CHECKING([whether to use inline assembler routines for atomic integers])
  474: have_atomic_inc=no
  475: if test x"$GCC" = xyes; then
  476:   if test "x$enable_ansi" = "xyes"; then
  477:     AC_MSG_RESULT([no])
  478:   else
  479:     case $host_cpu in
  480:       i386)
  481:         AC_MSG_RESULT([no])
  482:         ;;
  483:       i?86)
  484:         case $host_os in
  485:           darwin*)
  486:             AC_MSG_RESULT([darwin])
  487:             # check at compile-time, so that it is possible to build universal
  488:             # (with multiple architectures at once on the compile line)
  489:             AH_VERBATIM([DBUS_USE_ATOMIC_INT_486_DARWIN], [
  490:               #if (defined(__i386__) || defined(__x86_64__))
  491:               # define DBUS_USE_ATOMIC_INT_486 1
  492:               #endif
  493:             ])
  494:             ;;
  495:           *)
  496:             AC_MSG_RESULT([i486])
  497:             AC_DEFINE_UNQUOTED(DBUS_USE_ATOMIC_INT_486, 1, [Use atomic integer implementation for 486])
  498:             ;;
  499:         esac
  500:         have_atomic_inc=yes
  501:         ;;
  502:       *)
  503:         AC_MSG_RESULT([no])
  504:         ;;
  505:     esac
  506:   fi
  507: fi
  508: if test x$have_atomic_inc = xyes ; then
  509:   case $host_os in
  510:     darwin*)
  511:       AH_VERBATIM([DBUS_HAVE_ATOMIC_INT_DARWIN], [
  512:         #if (defined(__i386__) || defined(__x86_64__))
  513:         # define DBUS_HAVE_ATOMIC_INT 1
  514:         #endif
  515:       ])
  516:       ;;
  517:     *)
  518:       AC_DEFINE_UNQUOTED(DBUS_HAVE_ATOMIC_INT, 1, [Some atomic integer implementation present])
  519:       ;;
  520:   esac
  521: fi
  522: 
  523: #### Various functions
  524: AC_CHECK_LIB(socket,socket)
  525: AC_CHECK_FUNC(gethostbyname,,[AC_CHECK_LIB(nsl,gethostbyname)])
  526: 
  527: AC_CHECK_FUNCS(vsnprintf vasprintf nanosleep usleep poll setenv unsetenv socketpair getgrouplist fpathconf)
  528: 
  529: AC_MSG_CHECKING(for dirfd)
  530: AC_TRY_LINK([
  531: #include <sys/types.h>
  532: #include <dirent.h>
  533: ],[
  534: DIR *dirp;
  535: dirp = opendir(".");
  536: dirfd(dirp);
  537: closedir(dirp);
  538: ], 
  539: dbus_have_dirfd=yes, dbus_have_dirfd=no)
  540: AC_MSG_RESULT($dbus_have_dirfd)
  541: if test "$dbus_have_dirfd" = yes; then
  542:         AC_DEFINE(HAVE_DIRFD,1,[Have dirfd function])
  543: else
  544:         AC_MSG_CHECKING(for DIR *dirp->dd_fd)    
  545:         AC_TRY_LINK([
  546: #include <sys/types.h>
  547: #include <dirent.h>
  548:         ],[
  549: DIR *dirp;
  550: int fd;
  551: dirp = opendir(".");
  552: fd = dirp->dd_fd;
  553: closedir(dirp);
  554:         ],
  555:         dbus_have_ddfd=yes, dbus_have_ddfd=no)
  556:         AC_MSG_RESULT($dbus_have_ddfd)
  557:         if test "$dbus_have_ddfd" = yes; then
  558:                 AC_DEFINE(HAVE_DDFD,1,[Have the ddfd member of DIR])
  559:         fi
  560: fi
  561: 
  562: AC_CHECK_HEADERS(execinfo.h, [AC_CHECK_FUNCS(backtrace)])
  563: 
  564: AC_CHECK_HEADERS(errno.h)
  565: 
  566: # checking for a posix version of getpwnam_r
  567: # if we are cross compiling and can not run the test
  568: # assume getpwnam_r is the posix version
  569: # it is up to the person cross compiling to change
  570: # this behavior if desired
  571: AC_LANG_PUSH(C)
  572: AC_CACHE_CHECK([for posix getpwnam_r],
  573:                 ac_cv_func_posix_getpwnam_r,
  574:                 [AC_RUN_IFELSE([AC_LANG_PROGRAM(
  575: [[
  576: #include <errno.h>
  577: #include <pwd.h>
  578: ]],
  579: [[
  580:     char buffer[10000];
  581:     struct passwd pwd, *pwptr = &pwd;
  582:     int error;
  583:     errno = 0;
  584:     error = getpwnam_r ("", &pwd, buffer, 
  585:                         sizeof (buffer), &pwptr);
  586:    return (error < 0 && errno == ENOSYS) 
  587:            || error == ENOSYS; 
  588: ]])],
  589:         [ac_cv_func_posix_getpwnam_r=yes],
  590:         [ac_cv_func_posix_getpwnam_r=no],
  591:         [ac_cv_func_posix_getpwnam_r=yes]
  592: )])
  593: AC_LANG_POP(C)
  594: 
  595: if test "$ac_cv_func_posix_getpwnam_r" = yes; then
  596:         AC_DEFINE(HAVE_POSIX_GETPWNAM_R,1,
  597:                 [Have POSIX function getpwnam_r])
  598: else
  599:         AC_CACHE_CHECK([for nonposix getpwnam_r],
  600:                 ac_cv_func_nonposix_getpwnam_r,
  601:                 [AC_TRY_LINK([#include <pwd.h>],
  602:                         [char buffer[10000];
  603:                         struct passwd pwd;
  604:                         getpwnam_r ("", &pwd, buffer, 
  605:                                         sizeof (buffer));],
  606:                         [ac_cv_func_nonposix_getpwnam_r=yes],
  607:                         [ac_cv_func_nonposix_getpwnam_r=no])])
  608:                 if test "$ac_cv_func_nonposix_getpwnam_r" = yes; then
  609:                 AC_DEFINE(HAVE_NONPOSIX_GETPWNAM_R,1,
  610:                         [Have non-POSIX function getpwnam_r])
  611:         fi
  612: fi
  613: 
  614: dnl check for socklen_t
  615: AC_MSG_CHECKING(whether socklen_t is defined)
  616: AC_TRY_COMPILE([
  617: #include <sys/types.h>
  618: #include <sys/socket.h>
  619: #include <netdb.h>
  620: ],[
  621: socklen_t foo;
  622: foo = 1;
  623: ],dbus_have_socklen_t=yes,dbus_have_socklen_t=no)
  624: AC_MSG_RESULT($dbus_have_socklen_t)
  625: 
  626: if test "x$dbus_have_socklen_t" = "xyes"; then
  627:     AC_DEFINE(HAVE_SOCKLEN_T,1,[Have socklen_t type])
  628: fi
  629: 
  630: dnl check for writev header and writev function so we're 
  631: dnl good to go if HAVE_WRITEV gets defined.
  632: AC_CHECK_HEADERS(sys/uio.h, [AC_CHECK_FUNCS(writev)])
  633: 
  634: dnl needed on darwin for NAME_MAX
  635: AC_CHECK_HEADERS(sys/syslimits.h)
  636: 
  637: dnl check for flavours of varargs macros (test from GLib)
  638: AC_MSG_CHECKING(for ISO C99 varargs macros in C)
  639: AC_TRY_COMPILE([],[
  640: int a(int p1, int p2, int p3);
  641: #define call_a(...) a(1,__VA_ARGS__)
  642: call_a(2,3);
  643: ],dbus_have_iso_c_varargs=yes,dbus_have_iso_c_varargs=no)
  644: AC_MSG_RESULT($dbus_have_iso_c_varargs)
  645: 
  646: AC_MSG_CHECKING(for GNUC varargs macros)
  647: AC_TRY_COMPILE([],[
  648: int a(int p1, int p2, int p3);
  649: #define call_a(params...) a(1,params)
  650: call_a(2,3);
  651: ],dbus_have_gnuc_varargs=yes,dbus_have_gnuc_varargs=no)
  652: AC_MSG_RESULT($dbus_have_gnuc_varargs)
  653: 
  654: dnl Output varargs tests
  655: if test x$dbus_have_iso_c_varargs = xyes; then
  656:     AC_DEFINE(HAVE_ISO_VARARGS,1,[Have ISO C99 varargs macros])
  657: fi
  658: if test x$dbus_have_gnuc_varargs = xyes; then
  659:     AC_DEFINE(HAVE_GNUC_VARARGS,1,[Have GNU-style varargs macros])
  660: fi
  661: 
  662: dnl Check for various credentials.
  663: AC_MSG_CHECKING(for struct cmsgcred)
  664: AC_TRY_COMPILE([
  665: #include <sys/types.h>
  666: #include <sys/socket.h>
  667: ],[
  668: struct cmsgcred cred;
  669: 
  670: cred.cmcred_pid = 0;
  671: ],dbus_have_struct_cmsgcred=yes,dbus_have_struct_cmsgcred=no)
  672: AC_MSG_RESULT($dbus_have_struct_cmsgcred)
  673: 
  674: if test x$dbus_have_struct_cmsgcred = xyes; then
  675:     AC_DEFINE(HAVE_CMSGCRED,1,[Have cmsgcred structure])
  676: fi
  677: 
  678: AC_CHECK_FUNCS(getpeerucred getpeereid)
  679: 
  680: #### Abstract sockets
  681: 
  682: AC_LANG_PUSH(C)
  683: AC_CACHE_CHECK([abstract socket namespace],
  684:                 ac_cv_have_abstract_sockets,
  685:                 [AC_RUN_IFELSE([AC_LANG_PROGRAM(
  686: [[
  687: #include <sys/types.h>
  688: #include <stdlib.h>
  689: #include <string.h>
  690: #include <stdio.h>
  691: #include <sys/socket.h>
  692: #include <sys/un.h>
  693: #include <errno.h>
  694: ]],
  695: [[
  696:   int listen_fd;
  697:   struct sockaddr_un addr;
  698:   
  699:   listen_fd = socket (PF_UNIX, SOCK_STREAM, 0);
  700:   
  701:   if (listen_fd < 0)
  702:     {
  703:       fprintf (stderr, "socket() failed: %s\n", strerror (errno));
  704:       exit (1);
  705:     }
  706: 
  707:   memset (&addr, '\0', sizeof (addr));
  708:   addr.sun_family = AF_UNIX;
  709:   strcpy (addr.sun_path, "X/tmp/dbus-fake-socket-path-used-in-configure-test");
  710:   addr.sun_path[0] = '\0'; /* this is what makes it abstract */
  711:   
  712:   if (bind (listen_fd, (struct sockaddr*) &addr, SUN_LEN (&addr)) < 0)
  713:     {
  714:        fprintf (stderr, "Abstract socket namespace bind() failed: %s\n", 
  715:                 strerror (errno));
  716:        exit (1);
  717:     }
  718:   else 
  719:     exit (0);
  720: ]])],
  721:               [ac_cv_have_abstract_sockets=yes],
  722:               [ac_cv_have_abstract_sockets=no]
  723: )])
  724: AC_LANG_POP(C)
  725: 
  726: if test x$enable_abstract_sockets = xyes; then
  727:     if test x$ac_cv_have_abstract_sockets = xno; then
  728:         AC_MSG_ERROR([Abstract sockets explicitly required, and support not detected.])
  729:     fi
  730: fi
  731: 
  732: if test x$enable_abstract_sockets = xno; then
  733:    ac_cv_have_abstract_sockets=no;
  734: fi
  735: 
  736: if test x$ac_cv_have_abstract_sockets = xyes ; then
  737:    DBUS_PATH_OR_ABSTRACT=abstract
  738:    AC_DEFINE(HAVE_ABSTRACT_SOCKETS,1,[Have abstract socket namespace])
  739: else
  740:    DBUS_PATH_OR_ABSTRACT=path
  741: fi
  742: 
  743: # this is used in addresses to prefer abstract, e.g. 
  744: # unix:path=/foo or unix:abstract=/foo 
  745: AC_SUBST(DBUS_PATH_OR_ABSTRACT)
  746: 
  747: #### Sort out XML library
  748: 
  749: # see what we have
  750: AC_CHECK_LIB(expat, XML_ParserCreate_MM,
  751:              [ AC_CHECK_HEADERS(expat.h, have_expat=true, have_expat=false) ],
  752:              have_expat=false)
  753: 
  754: PKG_CHECK_MODULES(LIBXML, libxml-2.0 >= 2.6.0, have_libxml=true, have_libxml=false)
  755: 
  756: # see what we want to use
  757: dbus_use_libxml=false
  758: dbus_use_expat=false
  759: if test x$with_xml = xexpat; then
  760:         dbus_use_expat=true
  761:         if ! $have_expat ; then
  762:            AC_MSG_ERROR([Explicitly requested expat but expat not found])
  763:         fi
  764: elif test x$with_xml = xlibxml; then
  765:         dbus_use_libxml=true
  766:         if ! $have_libxml ; then
  767:            AC_MSG_ERROR([Explicitly requested libxml but libxml not found])
  768:         fi
  769: else
  770:         ### expat is the default because libxml can't currently survive 
  771:         ### our brutal OOM-handling unit test setup.
  772:         ### http://bugzilla.gnome.org/show_bug.cgi?id=109368
  773:         if $have_expat ; then
  774:                 with_xml=expat
  775:                 dbus_use_expat=true
  776:         elif $have_libxml ; then
  777:                 with_xml=libxml
  778:                 dbus_use_libxml=true
  779:         else
  780:                 AC_MSG_ERROR([No XML library found, check config.log for failed attempts])
  781:         fi
  782: fi
  783: 
  784: AM_CONDITIONAL(DBUS_USE_EXPAT, $dbus_use_expat)
  785: AM_CONDITIONAL(DBUS_USE_LIBXML, $dbus_use_libxml)
  786: 
  787: if $dbus_use_expat; then
  788:    XML_LIBS=-lexpat
  789:    XML_CFLAGS=
  790: fi
  791: if $dbus_use_libxml; then
  792:    XML_LIBS=$LIBXML_LIBS
  793:    XML_CFLAGS=$LIBXML_CFLAGS
  794: fi
  795: 
  796: # Thread lib detection
  797: AC_CHECK_FUNC(pthread_cond_timedwait,,[AC_CHECK_LIB(pthread,pthread_cond_timedwait,
  798:                                                     [THREAD_LIBS="-lpthread"])])
  799: 
  800: # SELinux detection
  801: if test x$enable_selinux = xno ; then
  802:     have_selinux=no;
  803: else
  804:     # See if we have SELinux library
  805:     AC_CHECK_LIB(selinux, is_selinux_enabled, 
  806:                  have_selinux=yes, have_selinux=no)
  807: 
  808:     # see if we have the SELinux header with the new D-Bus stuff in it
  809:     if test x$have_selinux = xyes ; then
  810:         AC_MSG_CHECKING([for DBUS Flask permissions in selinux/av_permissions.h])
  811:         AC_TRY_COMPILE([#include <selinux/av_permissions.h>],
  812:                         [#ifdef DBUS__ACQUIRE_SVC return 0;
  813:                          #else
  814:                          #error DBUS__ACQUIRE_SVC not defined
  815:                          #endif],
  816:                         have_selinux=yes, have_selinux=no)
  817:         AC_MSG_RESULT($have_selinux)
  818:     fi
  819: 
  820:     if test x$enable_selinux = xauto ; then
  821:         if test x$have_selinux = xno ; then
<