dnl Process this file with autoconf to produce a configure script.

# If porting the hal tarball to work well on a distribution search
# for the string "(distro-tweaks required)" for what to tweak.
#
# Patches for that is welcome.
#

AC_PREREQ(2.59c)
AC_INIT(hal, 0.5.9.1, david@fubar.dk)
AM_INIT_AUTOMAKE(hal, 0.5.9.1)
AM_CONFIG_HEADER(config.h)
AM_MAINTAINER_MODE

glib_module="glib-2.0 >= 2.6.0 gobject-2.0 > 2.6.0 dbus-glib-1 >= 0.61"
dbus_module="dbus-1 >= 0.61"
volume_id_module="libvolume_id >= 0.61"
polkit_module="polkit >= 0.2"

# libtool versioning - this applies to libhal and libhal-storage
#
# See http://sources.redhat.com/autobook/autobook/autobook_91.html#SEC91 for details
#
LT_CURRENT=1
LT_REVISION=0
LT_AGE=0
AC_SUBST(LT_CURRENT)
AC_SUBST(LT_REVISION)
AC_SUBST(LT_AGE)

AC_ISC_POSIX
AC_PROG_CC
AM_PROG_CC_STDC
AM_PROG_CC_C_O
AC_HEADER_STDC
AM_PROG_LIBTOOL
AC_PROG_MAKE_SET
AC_PROG_LN_S
AC_SYS_LARGEFILE
PKG_PROG_PKG_CONFIG

AM_PATH_PYTHON(, have_python=yes,
  [have_python=no
  AC_WARN([No python found. Skipping device-manager.])])
AM_CONDITIONAL(HAVE_PYTHON, test x$have_python = xyes)

AC_CHECK_HEADERS([sys/ioccom.h sys/inotify.h])

AC_ARG_WITH(os-type,     [  --with-os-type=<os>     Distribution or OS (redhat)])
AC_ARG_WITH(pid-file,    [  --with-pid-file=<file>  PID file for HAL daemon])

AC_ARG_WITH(hwdata, AC_HELP_STRING([--with-hwdata=<dir>], [Where PCI and USB IDs are found]))
AC_ARG_WITH(pci-ids, AC_HELP_STRING([--with-pci-ids=<dir>], [Where PCI IDs are found (overrides --with-hwdata)]))
AC_ARG_WITH(usb-ids, AC_HELP_STRING([--with-usb-ids=<dir>], [Where USB IDs are found (overrides --with-hwdata)]))
AC_ARG_ENABLE([pci-ids], AC_HELP_STRING([--disable-pci-ids], [Do not build with PCI IDs support]), [enable_pci_ids=$enableval], [enable_pci_ids=yes])
AC_ARG_ENABLE([usb-ids], AC_HELP_STRING([--disable-usb-ids], [Do not build with USB IDs support]), [enable_usb_ids=$enableval], [enable_usb_ids=yes])
AC_ARG_ENABLE([pnp-ids], AC_HELP_STRING([--disable-pnp-ids], [Do not build with PNP IDs support]), [enable_pnp_ids=$enableval], [enable_pnp_ids=yes])

AC_ARG_WITH(socket-dir,[  --with-socket-dir=<dir>  Location of the HAL D-BUS listening sockets (auto)])
AC_ARG_WITH(socket-dir,[  --with-socket-dir=<dir>  Location of the HAL D-BUS listening sockets (auto)])
if ! test -z "$with_hwdata" ; then
  PCI_IDS_DIR="$with_hwdata"
  USB_IDS_DIR="$with_hwdata"
fi
if ! test -z "$with_pci_ids" ; then
  PCI_IDS_DIR="$with_pci_ids"
fi
if ! test -z "$with_usb_ids" ; then
  USB_IDS_DIR="$with_usb_ids"
fi

if test "x$enable_pci_ids" = "xno" ; then
  USE_PCI_IDS=no
else
   if test -z "$PCI_IDS_DIR"; then
     for dir in /usr/share/hwdata /usr/share/misc /usr/share /var/lib/misc; do
       AC_CHECK_FILE($dir/pci.ids,PCI_IDS_DIR=$dir)
     done
     if test -z "$PCI_IDS_DIR"; then
       AC_ERROR([cannot find pci.ids. Use --with-pci-ids to specify location])
     else
       AC_WARN([Autodetected pci.ids in $PCI_IDS_DIR])
     fi
   fi
   USE_PCI_IDS=yes
   AC_DEFINE(USE_PCI_IDS,1,[Whether pci.ids is to be used])
fi

if test "x$enable_usb_ids" = "xno" ; then
  USE_USB_IDS=no
else 
   if test -z "$USB_IDS_DIR"; then
     for dir in /usr/share/hwdata /usr/share/misc /usr/share /var/lib/misc; do
       AC_CHECK_FILE($dir/usb.ids,USB_IDS_DIR=$dir)
     done
     if test -z "$USB_IDS_DIR"; then
       AC_ERROR([cannot find usb.ids. Use --with-usb-ids to specify location])
     else
       AC_WARN([Autodetected usb.ids in $USB_IDS_DIR])
     fi
   fi
   USE_USB_IDS=yes
   AC_DEFINE(USE_USB_IDS,1,[Whether usb.ids is to be used])
fi

if test "x$enable_pnp_ids" = "xno" ; then
  USE_PNP_IDS=no
else
  USE_PNP_IDS=yes
  AC_DEFINE(USE_PNP_IDS,1,[Whether builtin PNP IDs are to be used])
fi

AC_SUBST(PCI_IDS_DIR)
AC_SUBST(USB_IDS_DIR)
AC_SUBST(USE_PCI_IDS)
AC_SUBST(USE_USB_IDS)
AC_SUBST(USE_PNP_IDS)


AC_ARG_WITH(hal_user,[  --with-hal-user=<user>  User for running the HAL daemon (haldaemon)])
if test -z "$with_hal_user" ; then
    HAL_USER=haldaemon
else
    HAL_USER=$with_hal_user
fi
AC_SUBST(HAL_USER)
AC_DEFINE_UNQUOTED(HAL_USER,"$HAL_USER", [User for running the HAL daemon])

AC_ARG_WITH(hal_group,[  --with-hal-group=<grp>  Group for HAL (haldaemon)])
if test -z "$with_hal_group" ; then
    HAL_GROUP=haldaemon
else
    HAL_GROUP=$with_hal_group
fi
AC_SUBST(HAL_GROUP)
AC_DEFINE_UNQUOTED(HAL_GROUP,"$HAL_GROUP", [Group for HAL])


# Taken from dbus
AC_ARG_ENABLE(ansi,             [  --enable-ansi           enable -ansi -pedantic gcc flags],enable_ansi=$enableval,enable_ansi=no)
AC_ARG_ENABLE(verbose-mode,     [  --enable-verbose-mode   support verbose debug mode],enable_verbose_mode=$enableval,enable_verbose_mode=$USE_MAINTAINER_MODE)
AC_ARG_ENABLE(docbook-docs,     [  --enable-docbook-docs   build documentation (requires xmlto)],enable_docbook_docs=$enableval,enable_docbook_docs=no)
AC_ARG_ENABLE(man-pages,        [  --enable-man-pages      build manual pages],enable_man_pages=$enableval,enable_man_pages=yes)
AM_CONDITIONAL(MAN_PAGES_ENABLED, test x$enable_man_pages = xyes)
AC_SUBST(MAN_PAGES_ENABLED)

## eject 
AC_ARG_WITH(eject,              [  --with-eject=<path>     Specify eject program. (default /usr/bin/eject)])
if test -z "$with_eject"; then
  EJECT_PROGRAM=/usr/bin/eject
else
  EJECT_PROGRAM=$with_eject
fi
AC_SUBST(EJECT_PROGRAM)
AC_DEFINE_UNQUOTED(EJECT_PROGRAM, "$EJECT_PROGRAM", [Eject program to use])

GTK_DOC_CHECK([1.3])

# ACPI event source
AC_ARG_ENABLE([acpi-acpid], AC_HELP_STRING([--disable-acpi-acpid], [Do not use ACPI daemon event source]), [acpi_acpid=$enableval], [acpi_acpid=yes])
if test "x$acpi_acpid" = "xyes" ; then
   AC_DEFINE(ACPI_ACPID,1,[Common event source of ACPI events])
fi
AC_SUBST(ACPI_ACPID)
AM_CONDITIONAL(ACPI_ACPID, test x$acpi_acpid != xyes)

AC_ARG_ENABLE([acpi-proc], AC_HELP_STRING([--disable-acpi-proc], [Do not use ACPI kernel-interface directly]), [acpi_proc=$enableval], [acpi_proc=yes])
if test "x$acpi_proc" = "xyes" ; then
   AC_DEFINE(ACPI_PROC,1,[Direct kernel connection for ACPI events, the kernel interface is exclusive to one user only])
fi
AC_SUBST(ACPI_PROC)
AM_CONDITIONAL(ACPI_PROC, test x$acpi_proc = xyes)

AC_ARG_ENABLE([acpi-ibm], AC_HELP_STRING([--enable-acpi-ibm], [Forward IBM ACPI events]), [acpi_ibm=$enableval], [acpi_ibm=no])
BUILD_ACPI_IBM=no
if test "x$acpi_ibm" = "xyes" ; then
  AC_DEFINE(BUILD_ACPI_IBM,1,[catch and forward IBM ACPI hotkey and button events])
  BUILD_ACPI_IBM=yes
fi
AC_SUBST(BUILD_ACPI_IBM)
AM_CONDITIONAL(BUILD_ACPI_IBM, test x$acpi_ibm = xyes)

AC_ARG_ENABLE([acpi-toshiba], AC_HELP_STRING([--enable-acpi-toshiba], [Forward Toshiba ACPI events]), [acpi_toshiba=$enableval], [acpi_toshiba=no])
BUILD_ACPI_TOSHIBA=no
if test "x$acpi_toshiba" = "xyes" ; then
  AC_DEFINE(BUILD_ACPI_TOSHIBA,1,[catch and forward Toshiba ACPI hotkey and button events])
  BUILD_ACPI_TOSHIBA=yes
fi
AC_SUBST(BUILD_ACPI_TOSHIBA)
AM_CONDITIONAL(BUILD_ACPI_TOSHIBA, test x$acpi_toshiba = xyes)


dnl libparted
AC_ARG_ENABLE([parted], AC_HELP_STRING([--enable-parted], [Use libparted]), [use_parted=$enableval], [use_parted=no])
if test "x$use_parted" = "xyes" ; then
   USE_PARTED=yes
   AC_DEFINE(USE_PARTED,1,[Whether libparted is to be used])
   AC_CHECK_LIB(uuid, uuid_generate, [], AC_MSG_ERROR([*** uuid library (libuuid) not found]))
   AC_CHECK_LIB(dl, dlopen,          [], AC_MSG_ERROR([*** dl library (libdl) not found]))
   AC_MSG_CHECKING([for libparted == 1.7.1, 1.8.0, 1.8.1, 1.8.2, 1.8.6])
   LDFLAGS=-lparted
   AC_TRY_RUN(
   #include <stdio.h>
   #include <parted/parted.h>
   int main ()
   {  
	int major ;
	int minor ;
	int micro ;

	if ( sscanf( ped_get_version(), "%d.%d.%d", &major, &minor, &micro ) == 3 )
		printf( "Found libparted %s", ped_get_version() ) ;

	if ((major == 1 && minor == 7 && micro == 1) ||
	    (major == 1 && minor == 8 && micro == 0) ||
	    (major == 1 && minor == 8 && micro == 1) ||
	    (major == 1 && minor == 8 && micro == 2) ||
	    (major == 1 && minor == 8 && micro == 6))
	   return 0;

	return 1;
    }
	,AC_MSG_RESULT( ),AC_MSG_ERROR([*** Requires libparted == 1.7.1/1.8.0/1.8.1/1.8.2 or 1.8.6]) )
    PARTED_LIBS=-lparted
    AC_SUBST(PARTED_LIBS)
    LDFLAGS=
else
   USE_PARTED=no
fi
AC_SUBST(USE_PARTED)
AM_CONDITIONAL(USE_PARTED, test x$use_parted == xyes)


#### gcc linker flags

if test "x$GCC" = "xyes"; then
  LDFLAGS="-Wl,--as-needed $LDFLAGS"
fi

#### gcc warning flags

if test "x$GCC" = "xyes"; then
  changequote(,)dnl
  case " $CFLAGS " in
  *[\ \	]-Wall[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wall" ;;
  esac

  case " $CFLAGS " in
  *[\ \	]-Wchar-subscripts[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wchar-subscripts" ;;
  esac

  case " $CFLAGS " in
  *[\ \	]-Wmissing-declarations[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wmissing-declarations" ;;
  esac

  case " $CFLAGS " in
  *[\ \	]-Wnested-externs[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wnested-externs" ;;
  esac

  case " $CFLAGS " in
  *[\ \	]-Wpointer-arith[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wpointer-arith" ;;
  esac

  case " $CFLAGS " in
  *[\ \	]-Wcast-align[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wcast-align" ;;
  esac

  case " $CFLAGS " in
  *[\ \	]-Wsign-compare[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wsign-compare" ;;
  esac

  if test "x$enable_ansi" = "xyes"; then
    case " $CFLAGS " in
    *[\ \	]-ansi[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -ansi" ;;
    esac

    case " $CFLAGS " in
    *[\ \	]-D_POSIX_C_SOURCE*) ;;
    *) CFLAGS="$CFLAGS -D_POSIX_C_SOURCE=199309L" ;;
    esac

    case " $CFLAGS " in
    *[\ \	]-D_BSD_SOURCE[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -D_BSD_SOURCE" ;;
    esac

    case " $CFLAGS " in
    *[\ \	]-pedantic[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -pedantic" ;;
    esac
  fi
  if test x$enable_gcov = xyes; then
    case " $CFLAGS " in
    *[\ \	]-fprofile-arcs[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -fprofile-arcs" ;;
    esac
    case " $CFLAGS " in
    *[\ \	]-ftest-coverage[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -ftest-coverage" ;;
    esac

    ## remove optimization
    CFLAGS=`echo "$CFLAGS" | sed -e 's/-O[0-9]*//g'`
  fi
  changequote([,])dnl
else
  if test x$enable_gcov = xyes; then
    AC_MSG_ERROR([--enable-gcov can only be used with gcc])
  fi
fi

AM_CONDITIONAL(GCOV, test x$enable_gcov = xyes)


EXPAT_LIB=""
AC_ARG_WITH(expat, [  --with-expat=<dir>      Use expat from here],
                      [
                      expat=$withval
                      CPPFLAGS="$CPPFLAGS -I$withval/include"
                      LDFLAGS="$LDFLAGS -L$withval/lib"
                      ]
                      )
AC_CHECK_HEADERS(expat.h, [AC_DEFINE(HAVE_EXPAT_H)], 
		 [AC_MSG_ERROR([Can't find expat.h. Please install expat.])])
AC_CHECK_LIB(expat,XML_ParserCreate,[EXPAT_LIB="-lexpat"],
	     [AC_MSG_ERROR([Can't find expat library. Please install expat.])])
AC_SUBST(EXPAT_LIB)

dnl Check libusb
AC_PATH_PROG(LIBUSB_CONFIG, libusb-config)
if test -n "${LIBUSB_CONFIG}"; then
	USE_LIBUSB=yes
	AM_CONDITIONAL(HAVE_LIBUSB,true)
else
	USE_LIBUSB=no
	AM_CONDITIONAL(HAVE_LIBUSB,false)
fi

dnl Check for libsmbios
AC_LANG_PUSH([C++])
AC_CHECK_LIB(smbios, SMBIOSFreeMemory, LIB_SMBIOS=yes , LIB_SMBIOS=no )
AC_LANG_POP([C++])
if test "$LIB_SMBIOS" = "yes" ; then
   AC_MSG_CHECKING([for libsmbios >= 0.13.4])
   AC_TRY_RUN(
   #include <smbios/version.h>
   int main ()
   {
        int major ;
        int minor ;
        int micro ;

        if ( sscanf( LIBSMBIOS_RELEASE_VERSION , "%d.%d.%d", &major, &minor, &micro ) == 3 ) {
	    if ((major == 0 && minor == 13 && micro >= 4) ||
               (major >= 0 && minor > 13)) {
		return 0;
	    }
	}
	return 1;
   } , [USE_SMBIOS=yes; AC_MSG_RESULT(yes); AM_CONDITIONAL(HAVE_SMBIOS,true)],
       [USE_SMBIOS=no; AC_MSG_RESULT(failed); AM_CONDITIONAL(HAVE_SMBIOS,false)])
else
  USE_SMBIOS=no
  AM_CONDITIONAL(HAVE_SMBIOS,false)
fi

AC_ARG_WITH([libpci],
  [AS_HELP_STRING([--without-libpci],
    [Compile without pci support])],
  [],
  [with_libpci=yes])

USE_LIBPCI="no"
if test "x$with_libpci" != xno ; then
  dnl check for libpci
  AC_CHECK_HEADERS([pci/pci.h], [AC_CHECK_LIB([pci], [pci_init], [USE_LIBPCI="yes"], , [-lz ]) ])
fi 
AM_CONDITIONAL([HAVE_LIBPCI], [test "x$USE_LIBPCI" = "xyes"])

AC_ARG_WITH(backend, [  --with-backend=<name>   backend to use (linux/solaris/freebsd/dummy)], [ backend=$withval ])
if ! test -z "$with_backend" ; then
    HALD_BACKEND="$with_backend"
else
    case "$host" in
        *-*-solaris*)
		   HALD_BACKEND="solaris"
		   ;;
        *-*-freebsd*)
                   HALD_BACKEND="freebsd"
                   ;;
	*-linux*)
		   HALD_BACKEND="linux"
      		   ;;
        *)
		   HALD_BACKEND="dummy"
		   ;;
    esac
fi
AM_CONDITIONAL(HALD_COMPILE_DUMMY, test x$HALD_BACKEND = xdummy, [Compiling for Dummy backend])
AM_CONDITIONAL(HALD_COMPILE_LINUX, test x$HALD_BACKEND = xlinux, [Compiling for Linux])
AM_CONDITIONAL(HALD_COMPILE_FREEBSD, test x$HALD_BACKEND = xfreebsd, [Compiling for FreeBSD])
AM_CONDITIONAL(HALD_COMPILE_SOLARIS, test x$HALD_BACKEND = xsolaris, [Compiling for Solaris])
AC_SUBST(HALD_BACKEND)

dnl DBUS API is subject to changes
AC_DEFINE_UNQUOTED(DBUS_API_SUBJECT_TO_CHANGE, ,DBUS API is subject to change)

# check for PolicyKit
AM_CONDITIONAL(HAVE_POLKIT, false)
AC_ARG_ENABLE(policy-kit, [  --enable-policy-kit     Use PolicyKit],enable_policy_kit=$enableval,enable_policy_kit=no)
msg_polkit=no
if test "x$enable_policy_kit" != "xno"; then
	PKG_CHECK_MODULES(POLKIT, polkit >= 0.2,
		  	[AM_CONDITIONAL(HAVE_POLKIT, true)
		   	AC_DEFINE(HAVE_POLKIT, [], [Set if we use PolicyKit])]
                        msg_polkit=yes,
	          	[AM_CONDITIONAL(HAVE_POLKIT, false)])
	AC_SUBST(POLKIT_CFLAGS)
	AC_SUBST(POLKIT_LIBS)
	if test "x$msg_polkit" != "xyes"; then
	   AC_MSG_ERROR([PolicyKit not explicitly disabled and no PolicyKit found])
	fi
fi

# check for ConsoleKit
AM_CONDITIONAL(HAVE_CONKIT, false)
AC_ARG_ENABLE(console-kit, [  --enable-console-kit    Use ConsoleKit],enable_console_kit=$enableval,enable_console_kit=no)
msg_conkit=no
if test "x$enable_console_kit" != "xno"; then
   AM_CONDITIONAL(HAVE_CONKIT, true)
   AC_DEFINE(HAVE_CONKIT, [], [Set if we use ConsoleKit])
   msg_conkit=yes
fi

# check for ACL handling
AM_CONDITIONAL(HAVE_ACLMGMT, false)
AC_ARG_ENABLE(acl-management, [  --enable-acl-management ACL management],enable_acl_management=$enableval,enable_acl_management=no)
msg_aclmgmt=no
if test "x$enable_acl_management" != "xno"; then
   AM_CONDITIONAL(HAVE_ACLMGMT, true)
   AC_DEFINE(HAVE_ACLMGMT, [], [Set if we manage ACL's])
   msg_aclmgmt=yes
fi

# check for umount.hal
AM_CONDITIONAL(HAVE_UMOUNT_HAL, false)
AC_ARG_ENABLE(umount-helper,  [  --enable-umount-helper  Provide umount.hal helper],enable_umount_hal=$enableval,enable_umount_hal=no)
msg_umount_hal=no
if test "x$enable_umount_hal" != "xno"; then
   AM_CONDITIONAL(HAVE_UMOUNT_HAL, true)
   AC_DEFINE(HAVE_UMOUNT_HAL, [], [Set if we should provide and use the /sbin/umount.hal helper ])
   msg_umount_hal=yes
fi

# what extra hotplug backends to use (ACPI, APM, PMU etc)
AC_ARG_ENABLE(have_acpi, [  --disable-acpi          Build without ACPI support])
msg_acpi=no
if test "x$enable_acpi" != "xno"; then
	msg_acpi=yes
  	AC_DEFINE(HAVE_ACPI, [], [Set if we have ACPI support])
fi
AM_CONDITIONAL(HAVE_ACPI, test x$msg_acpi = xyes, [Compiling ACPI])
AC_ARG_ENABLE(have_apm, [  --disable-apm           Build without APM support])
msg_apm=no
if test "x$enable_apm" != "xno"; then
	msg_apm=yes
  	AC_DEFINE(HAVE_APM, [], [Set if we have APM support])
fi
AM_CONDITIONAL(HAVE_APM, test x$msg_apm = xyes, [Compiling APM])
AC_ARG_ENABLE(have_pmu, [  --disable-pmu           Build without PMU support])
msg_pmu=no
if test "x$enable_pmu" != "xno"; then
	msg_pmu=yes
  	AC_DEFINE(HAVE_PMU, [], [Set if we have PMU support])
fi
AM_CONDITIONAL(HAVE_PMU, test x$msg_pmu = xyes, [Compiling PMU])

AC_ARG_ENABLE(have_pci, [  --disable-pci           Build without PCI support])
msg_pci=no
if test "x$enable_pci" != "xno"; then
	msg_pci=yes
 	AC_DEFINE(HAVE_PCI, [], [Set if we have PCI support])
fi

# D-Bus libs
PKG_CHECK_MODULES(DBUS, [$dbus_module])
AC_SUBST(DBUS_CFLAGS)
AC_SUBST(DBUS_LIBS)

# glib libs
PKG_CHECK_MODULES(GLIB, [$glib_module])
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)

# volume_id
case "$host" in
*-*-solaris*)
	;;
*)
	PKG_CHECK_MODULES(VOLUME_ID, [$volume_id_module])
	AC_SUBST(VOLUME_ID_CFLAGS)
	AC_SUBST(VOLUME_ID_LIBS)
esac

# OS specific libs
case "$host" in
*-*-solaris*)
	HALD_OS_LIBS="-lsysevent -lnvpair -ldevinfo"
	AC_SUBST(HALD_OS_LIBS)
	;;
esac

# Check for BLKGETSIZE64
AC_CHECK_TYPE(pgoff_t, ,
              [AC_DEFINE(pgoff_t, unsigned long, [Index into the pagecache])],
               /usr/include/sys/types.h)
AC_MSG_CHECKING([for BLKGETSIZE64])
AC_TRY_COMPILE(
[#include <sys/types.h>
#include <linux/ioctl.h>
#include <linux/fs.h>],
[int main(int argc, char *argv[])
{
	int fd = 0;
	unsigned long long int n;
	ioctl (fd, BLKGETSIZE64, &n);
	return 0;
}
], have_size64=yes, have_size64=no)
AC_MSG_RESULT($have_size64)
if test x$have_size64 = xno; then
  case "$host" in
        *-*-linux*)
	     AC_MSG_ERROR([BLKGETSIZE64 is not defined])
		;;
        *)
		;;
  esac
fi

AC_CHECK_FUNCS(getgrouplist)
AC_CHECK_FUNCS(asprintf)
AC_CHECK_FUNCS(mallopt)
AC_CHECK_FUNCS(strndup)

# DocBook Documentation

AC_PATH_PROG(XMLTO, xmlto, no)
AC_MSG_CHECKING([whether to build DocBook documentation])

if test x$XMLTO = xno ; then
    have_xmlto=no
else
    have_xmlto=yes
fi

AC_PATH_PROG(XMLLINT, xmllint, no)

if test x$XMLLINT = xno ; then
    have_xmllint=no
else
    have_xmllint=yes
fi

if test x$enable_docbook_docs = xauto ; then
    if test x$have_xmlto = xno || test x$have_xmllint = xno ; then
        enable_docbook_docs=no
    else
        enable_docbook_docs=yes
    fi
fi

if test x$enable_docbook_docs = xyes; then
    if test x$have_xmlto = xno; then
        AC_MSG_ERROR([Building DocBook docs explicitly required, but xmlto not found])
    fi
    if test x$ve_xmllint = xno; then
        AC_MSG_ERROR([Building DocBook docs explicitly required, but xmllint not found])
    fi
fi

AM_CONDITIONAL(DOCBOOK_DOCS_ENABLED, test x$enable_docbook_docs = xyes)
AC_MSG_RESULT(yes)


AC_ARG_WITH(dbus-sys, [  --with-dbus-sys=<dir>   where D-BUS system.d directory is])

if ! test -z "$with_dbus_sys" ; then
    DBUS_SYS_DIR="$with_dbus_sys"
else
    DBUS_SYS_DIR="$sysconfdir/dbus-1/system.d"
fi
AC_SUBST(DBUS_SYS_DIR)

#### Check our operating system (distro-tweaks required)
operating_system=unknown
if test -f /etc/redhat-release || test -f SYSCONFDIR/redhat-release ; then
   operating_system=redhat
fi

#### Sort out OS (distro-tweaks required)

if test x$with_os_type = x; then
    if test x$operating_system = xredhat ; then
        with_os_type=redhat
    else
        with_os_type=unknown
    fi
fi

# (distro-tweaks required)
AM_CONDITIONAL(OS_TYPE_UNKNOWN, test x$with_os_type = xunknown, [Running on unknown OS])
AM_CONDITIONAL(OS_TYPE_RED_HAT, test x$with_os_type = xredhat, [Running on Red Hat OS'es])

#### Set up the pid file (distro-tweaks required)
if ! test -z "$with_pid_file"; then
   HALD_PID_FILE=$with_pid_file
elif test x$with_os_type = xredhat ; then
   HALD_PID_FILE=${localstatedir}/run/haldaemon.pid
else
   HALD_PID_FILE=${localstatedir}/run/hald/pid
fi

AC_SUBST(HALD_PID_FILE)

if ! test -z "$with_socket_dir"; then
    HALD_SOCKET_DIR=$with_socket_dir
else
    HALD_SOCKET_DIR=${localstatedir}/run/hald
fi

AC_SUBST(HALD_SOCKET_DIR)


ALL_LINGUAS="ca cs da de el es et eu fi fr hu it ja km ko lt nb nl pa pl pt_BR pt ru sl_SI sv tr uk zh_CN zh_TW"
AC_SUBST(ALL_LINGUAS)

GETTEXT_PACKAGE=AC_PACKAGE_NAME
AC_SUBST(GETTEXT_PACKAGE)
AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, "$GETTEXT_PACKAGE", [Name of the gettext package])

AC_PROG_INTLTOOL([0.22])
AM_GLIB_GNU_GETTEXT

dnl
dnl SUBSETTING START
dnl

dnl macbookpro utils
AC_ARG_WITH(macbookpro,     [  --with-macbookpro       Whether to build Macbook Pro utils (auto)])
BUILD_MACBOOKPRO=no
if test "x$with_macbookpro" = "xyes" ; then
   BUILD_MACBOOKPRO=yes
elif test "x$with_macbookpro" = "x" ; then
  if test "x$USE_LIBPCI" != "xno" ; then
    case "${HALD_BACKEND}" in
      linux)
        case "${host}" in
	  i[[3456]]86-*-*)
            BUILD_MACBOOKPRO=yes
	    ;;
	  *)
	    ;;
	esac
        ;;
      *)
        ;;
    esac
   fi
fi
AM_CONDITIONAL(BUILD_MACBOOKPRO, test x$BUILD_MACBOOKPRO = xyes)

dnl macbook backlight support
AC_ARG_WITH(macbook,     [  --with-macbook          Include support for Macbook backlight (auto)])
BUILD_MACBOOK=no
if test "x$with_macbook" = "xyes" ; then
   BUILD_MACBOOK=yes
elif test "x$with_macbook" = "x" ; then
  if test "x$USE_LIBPCI" != "xno" ; then
    case "${HALD_BACKEND}" in
      linux)
        case "${host}" in
	  i[[3456]]86-*-*)
            BUILD_MACBOOK=yes
	    ;;
	  *)
	    ;;
	esac
        ;;
      *)
        ;;
    esac
   fi
fi
AM_CONDITIONAL(BUILD_MACBOOK, test x$BUILD_MACBOOK = xyes)

AC_ARG_WITH([omap],
	    [AS_HELP_STRING([--with-omap],
			    [Whether to build OMAP utils (auto)])])
BUILD_OMAP=no
if test "x$with_omap" = "xyes" ; then
    BUILD_OMAP=yes
elif test "x$with_omap" = "x" ; then
    case "${HALD_BACKEND}" in
    linux)
	case "${host}" in
	arm*-*-*)
	    BUILD_OMAP=yes
	    ;;
	*)
	    ;;
	esac
	;;
    *)
	;;
    esac
fi
AM_CONDITIONAL(BUILD_OMAP, [test x$BUILD_OMAP = xyes])

dnl cpufreq
AC_ARG_WITH(cpufreq,        [  --with-cpufreq          Whether to build cpufreq utils (auto)])
BUILD_CPUFREQ=no
if test "x$with_cpufreq" = "xyes" ; then
   BUILD_CPUFREQ=yes
elif test "x$with_cpufreq" = "x" ; then
  case "${HALD_BACKEND}" in
    linux)
      BUILD_CPUFREQ=yes
      ;;
    *)
      ;;
  esac
fi
AM_CONDITIONAL(BUILD_CPUFREQ, test x$BUILD_CPUFREQ = xyes)

dnl USB CSR (for reading battery of USB wireless mice)
AC_ARG_WITH(usb-csr,        [  --with-usb-csr          Whether to build addon for wireless USB mice (auto)])
BUILD_USBCSR=no
if test "x${USE_LIBUSB}" == "xyes" ; then
   if test "x$with_usb_csr" = "xyes" ; then
      BUILD_USBCSR=yes
   elif test "x$with_usb_csr" = "x" ; then
      #only automatically build for Linux
      if test "${HALD_BACKEND}" = "linux" ; then
         BUILD_USBCSR=yes
      fi
   fi
fi
AM_CONDITIONAL(BUILD_USBCSR, test x$BUILD_USBCSR = xyes)

dnl Dell backlight 
AC_ARG_WITH(dell-backlight,     [  --with-dell-backlight   Whether to build Dell backlight support (auto)])
BUILD_DELL=no
if test "x$with_dell_backlight" = "xyes" ; then
   BUILD_DELL=yes
elif test "x$with_dell_backlight" = "x" ; then
  if test "$USE_SMBIOS" = "yes" ; then
    case "${HALD_BACKEND}" in
      linux)
        case "${host}" in
	  i*86-*-*|x86_64-*-*)
            BUILD_DELL=yes
	    ;;
	  *)
	    ;;
	esac
        ;;
      *)
        ;;
    esac
   fi
fi
AM_CONDITIONAL(BUILD_DELL, test x$BUILD_DELL = xyes)

dnl Sony PIC support
AC_ARG_ENABLE(sonypic,
		AC_HELP_STRING([--enable-sonypic],[Build with Sony PIC support]),
		[case "${enableval}" in
		yes) ENABLE_SONYPIC=yes ;;
		no) ENABLE_SONYPIC=no ;;
	        *) AC_MSG_ERROR(bad value ${enableval} for --enable-sonypic) ;;
		esac],
		[ENABLE_SONYPIC=auto]) dnl Default value

have_sonypic=no
if test x$ENABLE_SONYPIC != "xno" ; then
	AC_COMPILE_IFELSE([
		#include <linux/sonypi.h>
		int main(int argc,char **argv) {
			return 0;
		}
	],
	have_sonypic=yes
	)
	AC_MSG_CHECKING([for Sony PIC headers])
	AC_MSG_RESULT([$have_sonypic])

	if test "x$ENABLE_SONYPIC" = "xyes" && test "x$have_sonypic" != "xyes" ; then
		AC_MSG_ERROR([Sony PIC support explicitly requested but no support found])
	fi
fi
if test x"$have_sonypic" = "xyes" ; then
        AC_DEFINE(HAVE_SONYPIC, 1, [Set if we have Sony PIC support])
fi
msg_sonypic=$have_sonypic
AM_CONDITIONAL(HAVE_SONYPIC, test x$msg_sonypic = xyes, [Compiling Sony PIC])

dnl
dnl SUBSETTING END
dnl


AC_OUTPUT([
hal.pc
hal-storage.pc
hal.conf
Makefile
hald/Makefile
hald/dummy/Makefile
hald/linux/Makefile
hald/linux/probing/Makefile
hald/linux/addons/Makefile
hald/solaris/Makefile
hald/solaris/probing/Makefile
hald/solaris/addons/Makefile
hald/freebsd/Makefile
hald/freebsd/probing/Makefile
hald/freebsd/libprobe/Makefile
hald/freebsd/addons/Makefile
hald-runner/Makefile
libhal/Makefile
libhal-storage/Makefile
tools/Makefile
tools/freebsd/Makefile
tools/linux/Makefile
tools/device-manager/Makefile
partutil/Makefile
privileges/Makefile
fdi/Makefile
fdi/information/Makefile
fdi/information/10freedesktop/Makefile
fdi/information/20thirdparty/Makefile
fdi/policy/Makefile
fdi/policy/10osvendor/Makefile
fdi/policy/20thirdparty/Makefile
fdi/preprobe/Makefile
fdi/preprobe/10freedesktop/Makefile
fdi/preprobe/20thirdparty/Makefile
doc/Makefile
doc/api/Makefile
doc/api/libhal/Makefile
doc/api/libhal/version.xml
doc/api/libhal-storage/Makefile
doc/api/libhal-storage/version.xml
doc/spec/Makefile
doc/spec/hal-spec.xml.in
doc/man/Makefile
po/Makefile.in
])

dnl ==========================================================================
echo "
                    HAL $VERSION
                  ==============

        prefix:                      ${prefix}
        libdir:                      ${libdir}
        libexecdir:                  ${libexecdir}
        bindir:                      ${bindir}
        sbindir:                     ${sbindir}
        datadir:                     ${datadir}
        sysconfdir:                  ${sysconfdir}
        localstatedir:               ${localstatedir}
        docdir:                      ${docdir}
        dbus-1 system.d dir:         ${DBUS_SYS_DIR}
        pci.ids dir:                 ${PCI_IDS_DIR}
        usb.ids dir:                 ${USB_IDS_DIR}

        compiler:                    ${CC}
        cflags:                      ${CFLAGS}
        ldflags:                     ${LDFLAGS}
        cppflags:                    ${CPPFLAGS}
        xmlto:                       ${XMLTO}
	xmllint:                     ${XMLLINT}
        User for HAL:                ${HAL_USER}
        Group for HAL:               ${HAL_GROUP}
        hald pidfile:                ${HALD_PID_FILE}
        hald socket dir:             ${HALD_SOCKET_DIR}
        eject program:               ${EJECT_PROGRAM}

        OS backend:                  ${HALD_BACKEND}

        use acpi kernel interface:   ${acpi_proc}
        use acpid interface:         ${acpi_acpid}
        use libusb:                  ${USE_LIBUSB}
        use libpci:                  ${USE_LIBPCI}
        use libparted:               ${USE_PARTED}
        use PolicyKit:               ${msg_polkit}
        use ConsoleKit:              ${msg_conkit}
        use ACL management:          ${msg_aclmgmt}
        use umount.hal helper:       ${msg_umount_hal}
        use ACPI:                    ${msg_acpi}
        use PMU:                     ${msg_pmu}
        use APM:                     ${msg_apm}
        use Sony PIC:                ${msg_sonypic}

	Device Manager:              ${have_python}
        Macbook backlight support:   ${BUILD_MACBOOK} (Linux only, x86 only, requires libpci)
        Macbook Pro utils:           ${BUILD_MACBOOKPRO} (Linux only, x86 only, requires libpci)
        OMAP utils:                  ${BUILD_OMAP} (Linux only, arm only)
        CPU frequency scaling:       ${BUILD_CPUFREQ} (Linux only)
        Forward IBM ACPI events:     ${BUILD_ACPI_IBM} (Linux only)
        Forward Toshiba ACPI events: ${BUILD_ACPI_TOSHIBA} (Linux only)
	USB wireless mouse power:    ${BUILD_USBCSR} (Linux only, requires libusb)
	Dell Backlight:              ${BUILD_DELL} (Linux only, requires libsmbios >= 0.13.4)

        Maintainer mode:             ${USE_MAINTAINER_MODE}
        Building verbose mode:       ${enable_verbose_mode}
        Building api docs:           ${enable_gtk_doc}
        Building docs:               ${enable_docbook_docs}
        Building man pages:          ${enable_man_pages}
"

if test x$BUILD_ACPI_IBM = xyes; then
   echo "NOTE: Future Linux kernels may provide IBM ACPI events via a kernel."
   echo "      input device resulting in HAL emitting twice as many events as it"
   echo "      should. Make sure to rebuild HAL without --enable-acpi-ibm if"
   echo "      you use such a kernel."
   echo
fi

if test x$BUILD_ACPI_TOSHIBA = xyes; then
   echo "NOTE: Future Linux kernels may provide Toshiba ACPI events via a kernel."
   echo "      input device resulting in HAL emitting twice as many events as it"
   echo "      should. Make sure to rebuild HAL without --enable-acpi-toshiba if"
   echo "      you use such a kernel."
   echo
fi


if test x$enable_umount_hal = xyes; then
   echo "NOTE: Without a patched umount(8) --enable-umount-helper have no effect."
   echo "      See https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=188193"
   echo "      for a suitable patch for util-linux. "
   echo
fi

if test x$enable_verbose_mode = xyes; then
   echo "NOTE: building with verbose mode increases library size, may slightly "
   echo "      increase security risk, and decreases performance."
   echo
fi

# (distro-tweaks required)
if test x$with_os_type = xredhat; then
   echo "NOTE: Red Hat style init scripts and policy will be installed"
else
   echo "NOTE: You have to install init scripts yourself and tweak your own policy"
fi
echo

echo "NOTE: Remember to create user ${HAL_USER} and group ${HAL_GROUP} before make install"
echo

echo "NOTE: For development, use run-hald.sh and debug-hald.sh scripts in hald/ to "
echo "      use programs (callouts, probers, addons) and device information files "
echo "      from build directories. You may still need 'make install' to"
echo "      install the udev rule to receive events from udev."
echo