mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-11-09 23:10:08 +00:00
4779e0bcb2
* src/openvz_conf.c: fix compilation with new XPath interface signatures * configure.in: build OpenVZ and LXC support by default Daniel
1088 lines
36 KiB
Plaintext
1088 lines
36 KiB
Plaintext
dnl Process this file with autoconf to produce a configure script.
|
|
|
|
AC_INIT([libvirt], [0.4.4])
|
|
AC_CONFIG_SRCDIR([src/libvirt.c])
|
|
AC_CONFIG_AUX_DIR([build-aux])
|
|
AM_CONFIG_HEADER([config.h])
|
|
dnl Make automake keep quiet about wildcards & other GNUmake-isms
|
|
AM_INIT_AUTOMAKE([-Wno-portability])
|
|
AC_CANONICAL_HOST
|
|
|
|
LIBVIRT_MAJOR_VERSION=`echo $VERSION | awk -F. '{print $1}'`
|
|
LIBVIRT_MINOR_VERSION=`echo $VERSION | awk -F. '{print $2}'`
|
|
LIBVIRT_MICRO_VERSION=`echo $VERSION | awk -F. '{print $3}'`
|
|
LIBVIRT_VERSION=$LIBVIRT_MAJOR_VERSION.$LIBVIRT_MINOR_VERSION.$LIBVIRT_MICRO_VERSION$LIBVIRT_MICRO_VERSION_SUFFIX
|
|
LIBVIRT_VERSION_INFO=`expr $LIBVIRT_MAJOR_VERSION + $LIBVIRT_MINOR_VERSION`:$LIBVIRT_MICRO_VERSION:$LIBVIRT_MINOR_VERSION
|
|
LIBVIRT_VERSION_NUMBER=`expr $LIBVIRT_MAJOR_VERSION \* 1000000 + $LIBVIRT_MINOR_VERSION \* 1000 + $LIBVIRT_MICRO_VERSION`
|
|
|
|
AC_SUBST([LIBVIRT_MAJOR_VERSION])
|
|
AC_SUBST([LIBVIRT_MINOR_VERSION])
|
|
AC_SUBST([LIBVIRT_MICRO_VERSION])
|
|
AC_SUBST([LIBVIRT_VERSION])
|
|
AC_SUBST([LIBVIRT_VERSION_INFO])
|
|
AC_SUBST([LIBVIRT_VERSION_NUMBER])
|
|
|
|
dnl Required minimum versions of all libs we depend on
|
|
LIBXML_REQUIRED="2.5.0"
|
|
GNUTLS_REQUIRED="1.0.25"
|
|
AVAHI_REQUIRED="0.6.0"
|
|
POLKIT_REQUIRED="0.6"
|
|
PARTED_REQUIRED="1.8.0"
|
|
|
|
dnl Checks for C compiler.
|
|
AC_PROG_CC
|
|
AC_PROG_INSTALL
|
|
AC_PROG_CPP
|
|
|
|
dnl gl_INIT uses m4_foreach_w, yet that is not defined in autoconf-2.59.
|
|
dnl In order to accommodate developers with such old tools, here's a
|
|
dnl replacement definition.
|
|
m4_ifndef([m4_foreach_w],
|
|
[m4_define([m4_foreach_w],
|
|
[m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3])])])
|
|
|
|
gl_EARLY
|
|
gl_INIT
|
|
|
|
AM_PROG_CC_STDC
|
|
AC_C_CONST
|
|
|
|
dnl Make sure we have an ANSI compiler
|
|
AM_C_PROTOTYPES
|
|
test "x$U" != "x" && AC_MSG_ERROR([Compiler not ANSI compliant])
|
|
|
|
dnl Support building Win32 DLLs (must appear *before* AM_PROG_LIBTOOL)
|
|
AC_LIBTOOL_WIN32_DLL
|
|
|
|
AM_PROG_LIBTOOL
|
|
|
|
AM_PROG_CC_C_O
|
|
|
|
LIBVIRT_COMPILE_WARNINGS([maximum])
|
|
|
|
dnl Support large files / 64 bit seek offsets.
|
|
dnl Use --disable-largefile if you don't want this.
|
|
AC_SYS_LARGEFILE
|
|
|
|
dnl Availability of various common functions (non-fatal if missing).
|
|
AC_CHECK_FUNCS([cfmakeraw regexec uname sched_getaffinity])
|
|
|
|
dnl Availability of various common headers (non-fatal if missing).
|
|
AC_CHECK_HEADERS([pwd.h paths.h sys/syslimits.h sys/utsname.h sys/wait.h winsock2.h sched.h])
|
|
|
|
dnl Where are the XDR functions?
|
|
dnl If portablexdr is installed, prefer that.
|
|
dnl Otherwise try -lrpc (Cygwin) -lxdr (some MinGW) or none (most Unix)
|
|
AC_CHECK_LIB([portablexdr],[xdrmem_create],[],[
|
|
AC_SEARCH_LIBS([xdrmem_create],[rpc xdr])
|
|
])
|
|
|
|
dnl Do we have rpcgen?
|
|
AC_PATH_PROG([RPCGEN], [rpcgen], [no])
|
|
AM_CONDITIONAL([RPCGEN], [test "x$ac_cv_path_RPCGEN" != "xno"])
|
|
dnl Is this GLIBC's buggy rpcgen?
|
|
AM_CONDITIONAL([GLIBC_RPCGEN],
|
|
[test "x$ac_cv_path_RPCGEN" != "xno" &&
|
|
$ac_cv_path_RPCGEN -t </dev/null >/dev/null 2>&1])
|
|
|
|
dnl pthread?
|
|
AC_CHECK_HEADER([pthread.h],
|
|
[AC_CHECK_LIB([pthread],[pthread_join],[
|
|
AC_DEFINE([HAVE_LIBPTHREAD],[],[Define if pthread (-lpthread)])
|
|
AC_DEFINE([HAVE_PTHREAD_H],[],[Define if <pthread.h>])
|
|
])])
|
|
|
|
dnl Miscellaneous external programs.
|
|
AC_PATH_PROG([RM], [rm], [/bin/rm])
|
|
AC_PATH_PROG([MV], [mv], [/bin/mv])
|
|
AC_PATH_PROG([TAR], [tar], [/bin/tar])
|
|
AC_PATH_PROG([XMLLINT], [xmllint], [/usr/bin/xmllint])
|
|
AC_PATH_PROG([XSLTPROC], [xsltproc], [/usr/bin/xsltproc])
|
|
|
|
AC_PROG_MKDIR_P
|
|
|
|
dnl External programs that we can use if they are available.
|
|
dnl We will hard-code paths to these programs unless we cannot
|
|
dnl detect them, in which case we'll search for the program
|
|
dnl along the $PATH at runtime and fail if it's not there.
|
|
AC_PATH_PROG([DNSMASQ], [dnsmasq], [dnsmasq],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([BRCTL], [brctl], [brctl],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
|
|
AC_DEFINE_UNQUOTED([DNSMASQ],["$DNSMASQ"],
|
|
[Location or name of the dnsmasq program])
|
|
AC_DEFINE_UNQUOTED([BRCTL],["$BRCTL"],
|
|
[Location or name of the brctl program (see bridge-utils)])
|
|
|
|
dnl Specific dir for HTML output ?
|
|
AC_ARG_WITH([html-dir], [AC_HELP_STRING([--with-html-dir=path],
|
|
[path to base html directory, default $datadir/doc/html])],
|
|
[HTML_DIR=$withval], [HTML_DIR='$(datadir)/doc'])
|
|
|
|
AC_ARG_WITH([html-subdir], [AC_HELP_STRING([--with-html-subdir=path],
|
|
[directory used under html-dir, default $PACKAGE-$VERSION/html])],
|
|
[test "x$withval" != "x" && HTML_DIR="$HTML_DIR/$withval"],
|
|
[HTML_DIR="$HTML_DIR/\$(PACKAGE)-\$(VERSION)/html"])
|
|
AC_SUBST([HTML_DIR])
|
|
|
|
dnl if --prefix is /usr, don't use /usr/var for localstatedir
|
|
dnl or /usr/etc for sysconfdir
|
|
dnl as this makes a lot of things break in testing situations
|
|
|
|
if test "$prefix" = "/usr" -a "$localstatedir" = '${prefix}/var' ; then
|
|
localstatedir='/var'
|
|
fi
|
|
if test "$prefix" = "/usr" -a "$sysconfdir" = '${prefix}/etc' ; then
|
|
sysconfdir='/etc'
|
|
fi
|
|
|
|
|
|
dnl Allow to build without Xen, QEMU/KVM, test or remote driver
|
|
AC_ARG_WITH([xen],
|
|
[ --with-xen add XEN support (on)],[],[with_xen=yes])
|
|
AC_ARG_WITH([qemu],
|
|
[ --with-qemu add QEMU/KVM support (on)],[],[with_qemu=yes])
|
|
AC_ARG_WITH([openvz],
|
|
[ --with-openvz add OpenVZ support (on)],[],[with_openvz=yes])
|
|
AC_ARG_WITH([lxc],
|
|
[ --with-lxc add Linux Container support (on)],[],[with_lxc=yes])
|
|
AC_ARG_WITH([test],
|
|
[ --with-test add test driver support (on)],[],[with_test=yes])
|
|
AC_ARG_WITH([remote],
|
|
[ --with-remote add remote driver support (on)],[],[with_remote=yes])
|
|
AC_ARG_WITH([libvirtd],
|
|
[ --with-libvirtd add libvirtd support (on)],[],[with_libvirtd=yes])
|
|
|
|
dnl
|
|
dnl specific tests to setup DV devel environments with debug etc ...
|
|
dnl
|
|
if [[ "${LOGNAME}" = "veillard" -a "`pwd`" = "/u/veillard/libvirt" ]] ; then
|
|
STATIC_BINARIES="-static"
|
|
else
|
|
STATIC_BINARIES=
|
|
fi
|
|
AC_SUBST([STATIC_BINARIES])
|
|
|
|
dnl --enable-debug=(yes|no)
|
|
AC_ARG_ENABLE([debug],
|
|
[AC_HELP_STRING([--enable-debug=no/yes],
|
|
[enable debugging output])],[],[enable_debug=yes])
|
|
if test x"$enable_debug" = x"yes"; then
|
|
AC_DEFINE([ENABLE_DEBUG], [], [whether debugging is enabled])
|
|
fi
|
|
|
|
|
|
AC_MSG_CHECKING([where to write libvirtd PID file])
|
|
AC_ARG_WITH([remote-pid-file], [AC_HELP_STRING([--with-remote-pid-file=[pidfile|none]], [PID file for libvirtd])])
|
|
if test "x$with_remote_pid_file" == "x" ; then
|
|
REMOTE_PID_FILE="$localstatedir/run/libvirtd.pid"
|
|
elif test "x$with_remote_pid_file" == "xnone" ; then
|
|
REMOTE_PID_FILE=""
|
|
else
|
|
REMOTE_PID_FILE="$with_remote_pid_file"
|
|
fi
|
|
AC_SUBST([REMOTE_PID_FILE])
|
|
AC_MSG_RESULT($REMOTE_PID_FILE)
|
|
|
|
dnl
|
|
dnl init script flavor
|
|
dnl
|
|
AC_MSG_CHECKING([for init script flavor])
|
|
AC_ARG_WITH([init-script],
|
|
[AC_HELP_STRING([--with-init-scripts=[redhat|auto|none]],
|
|
[Style of init scripts to install (defaults to auto)])])
|
|
if test "x$with_init_scripts" = "x" -o "x$with_init_scripts" = "xauto"; then
|
|
if test -f /etc/redhat-release ; then
|
|
with_init_scripts=redhat
|
|
else
|
|
with_init_scripts=none
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([LIBVIRT_INIT_SCRIPTS_RED_HAT], test x$with_init_scripts = xredhat)
|
|
AC_MSG_RESULT($with_init_scripts)
|
|
|
|
dnl
|
|
dnl ensure that Fedora's system-config-firewall knows
|
|
dnl about libvirt's iptables rules
|
|
dnl
|
|
AC_ARG_ENABLE([iptables-lokkit],
|
|
[AC_HELP_STRING([--enable-iptables-lokkit=no/yes/check],
|
|
[enable registering libvirt's iptables rules with Fedora's lokkit])],
|
|
[],[enable_iptables_lokkit=check])
|
|
if test x"$enable_iptables_lokkit" != x"no"; then
|
|
AC_PATH_PROG([LOKKIT_PATH],[lokkit], [], [/usr/sbin:$PATH])
|
|
fi
|
|
|
|
if test x"$enable_iptables_lokkit" = x"yes" -a x"$LOKKIT_PATH" = x; then
|
|
AC_MSG_ERROR([Cannot find lokkit and --enable-iptables-lokkit specified])
|
|
fi
|
|
|
|
if test x"$LOKKIT_PATH" != x; then
|
|
AC_DEFINE([ENABLE_IPTABLES_LOKKIT], [], [whether support for Fedora's lokkit is enabled])
|
|
AC_DEFINE_UNQUOTED([LOKKIT_PATH], "$LOKKIT_PATH", [path to lokkit binary])
|
|
fi
|
|
|
|
AC_PATH_PROG([IPTABLES_PATH], [iptables], /sbin/iptables, [/usr/sbin:$PATH])
|
|
AC_DEFINE_UNQUOTED([IPTABLES_PATH], "$IPTABLES_PATH", [path to iptables binary])
|
|
|
|
dnl
|
|
dnl Specify the xen-distribution directory to be able to compile on a
|
|
dnl non-xenified host
|
|
dnl
|
|
AC_ARG_WITH([xen-distdir], [AC_HELP_STRING([--with-xen-distdir=path],
|
|
[distribution directory of Xen, default /usr])])
|
|
if test "x$with_xen_distdir" != "x"
|
|
then
|
|
CPPFLAGS="$CPPFLAGS -I$withval/install/usr/include"
|
|
LDFLAGS="$LDFLAGS -L$withval/install/usr/lib -L$withval/install/usr/lib64"
|
|
fi
|
|
|
|
LIBVIRT_FEATURES=
|
|
WITH_XEN=0
|
|
|
|
if test "$with_openvz" = "yes" ; then
|
|
LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_OPENVZ"
|
|
fi
|
|
if test "$with_lxc" = "yes" ; then
|
|
LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_LXC"
|
|
fi
|
|
if test "$with_qemu" = "yes" ; then
|
|
LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_QEMU"
|
|
fi
|
|
|
|
if test "$with_test" = "yes" ; then
|
|
LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_TEST"
|
|
fi
|
|
|
|
if test "$with_remote" = "yes" ; then
|
|
LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_REMOTE"
|
|
fi
|
|
|
|
if test "$with_libvirtd" = "yes" ; then
|
|
LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_LIBVIRTD"
|
|
fi
|
|
|
|
if test "$with_xen" = "yes" ; then
|
|
dnl search for the Xen store library
|
|
AC_SEARCH_LIBS(xs_read, [xenstore],
|
|
[WITH_XEN=1],
|
|
[AC_MSG_RESULT([Xen store library not found])])
|
|
if test "$WITH_XEN" != "0" ; then
|
|
LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_XEN"
|
|
fi
|
|
|
|
AC_CHECK_HEADERS([xen/xen.h xen/version.h xen/dom0_ops.h],,[
|
|
AC_MSG_ERROR([Cannot find standard Xen headers. Is xen-devel installed?])
|
|
],
|
|
[#include <stdio.h>
|
|
#include <stdint.h>
|
|
])
|
|
|
|
dnl Search for the location of <xen/{linux,sys}/privcmd.h>.
|
|
AC_CHECK_HEADERS([xen/sys/privcmd.h],,[
|
|
AC_CHECK_HEADERS([xen/linux/privcmd.h],,[
|
|
AC_MSG_ERROR([Cannot find header file <xen/linux/privcmd.h> or <xen/sys/privcmd.h>. Is xen-devel installed?])
|
|
],
|
|
[#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <xen/xen.h>
|
|
])
|
|
],
|
|
[#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <xen/xen.h>
|
|
])
|
|
fi
|
|
|
|
dnl
|
|
dnl check for kernel headers required by qemud/bridge.c
|
|
dnl
|
|
if test "$with_qemu" = "yes" ; then
|
|
AC_CHECK_HEADERS([linux/param.h linux/sockios.h linux/if_bridge.h linux/if_tun.h],,
|
|
AC_MSG_ERROR([You must install kernel-headers in order to compile libvirt]))
|
|
fi
|
|
|
|
dnl Need to test if pkg-config exists
|
|
PKG_PROG_PKG_CONFIG
|
|
|
|
dnl ==========================================================================
|
|
dnl find libxml2 library, borrowed from xmlsec
|
|
dnl ==========================================================================
|
|
LIBXML_CONFIG="xml2-config"
|
|
LIBXML_CFLAGS=""
|
|
LIBXML_LIBS=""
|
|
LIBXML_FOUND="no"
|
|
|
|
AC_ARG_WITH([libxml], [ --with-libxml=[PFX] libxml2 location])
|
|
if test "x$with_libxml" = "xno" ; then
|
|
AC_MSG_CHECKING(for libxml2 libraries >= $LIBXML_REQUIRED)
|
|
AC_MSG_ERROR([libxml2 >= $LIBXML_REQUIRED is required for libvirt])
|
|
elif test "x$with_libxml" = "x" -a "x$PKG_CONFIG" != "x" ; then
|
|
PKG_CHECK_MODULES(LIBXML, libxml-2.0 >= $LIBXML_REQUIRED, [LIBXML_FOUND=yes], [LIBXML_FOUND=no])
|
|
fi
|
|
if test "$LIBXML_FOUND" = "no" ; then
|
|
if test "x$with_libxml" != "x" ; then
|
|
LIBXML_CONFIG=$with_libxml/bin/$LIBXML_CONFIG
|
|
fi
|
|
AC_MSG_CHECKING(libxml2 $LIBXML_CONFIG >= $LIBXML_REQUIRED )
|
|
if ! $LIBXML_CONFIG --version > /dev/null 2>&1 ; then
|
|
AC_MSG_ERROR([Could not find libxml2 anywhere (see config.log for details).])
|
|
fi
|
|
vers=`$LIBXML_CONFIG --version | awk -F. '{ printf "%d", ($1 * 1000 + $2) * 1000 + $3;}'`
|
|
minvers=`echo $LIBXML_REQUIRED | awk -F. '{ printf "%d", ($1 * 1000 + $2) * 1000 + $3;}'`
|
|
if test "$vers" -ge "$minvers" ; then
|
|
LIBXML_LIBS="`$LIBXML_CONFIG --libs`"
|
|
LIBXML_CFLAGS="`$LIBXML_CONFIG --cflags`"
|
|
LIBXML_FOUND="yes"
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_ERROR(
|
|
[You need at least libxml2 $LIBXML_REQUIRED for this version of libvirt])
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST([LIBXML_CFLAGS])
|
|
AC_SUBST([LIBXML_LIBS])
|
|
|
|
dnl xmlURI structure has query_raw?
|
|
old_cflags="$CFLAGS"
|
|
old_ldflags="$LDFLAGS"
|
|
CFLAGS="$CFLAGS $LIBXML_CFLAGS"
|
|
LDFLAGS="$LDFLAGS $LIBXML_LIBS"
|
|
AC_CHECK_MEMBER([struct _xmlURI.query_raw],
|
|
[AC_DEFINE([HAVE_XMLURI_QUERY_RAW], [], [Have query_raw field in libxml2 xmlURI structure])],,
|
|
[#include <libxml/uri.h>])
|
|
CFLAGS="$old_cflags"
|
|
LDFLAGS="$old_ldflags"
|
|
|
|
dnl GnuTLS library
|
|
GNUTLS_CFLAGS=
|
|
GNUTLS_LIBS=
|
|
GNUTLS_FOUND=no
|
|
if test -z "$PKG_CONFIG" ; then
|
|
PKG_CHECK_MODULES(GNUTLS, gnutls >= $GNUTLS_REQUIRED,
|
|
[GNUTLS_FOUND=yes], [GNUTLS_FOUND=no])
|
|
fi
|
|
if test "$GNUTLS_FOUND" = "no"; then
|
|
fail=0
|
|
old_libs="$LIBS"
|
|
AC_CHECK_HEADER([gnutls/gnutls.h], [], [fail=1])
|
|
AC_CHECK_LIB([gnutls], [gnutls_handshake],[], [fail=1], [-lgcrypt])
|
|
|
|
test $fail = 1 &&
|
|
AC_MSG_ERROR([You must install the GnuTLS library in order to compile and run libvirt])
|
|
|
|
GNUTLS_LIBS=$LIBS
|
|
LIBS="$old_libs"
|
|
fi
|
|
|
|
AC_SUBST([GNUTLS_CFLAGS])
|
|
AC_SUBST([GNUTLS_LIBS])
|
|
|
|
dnl Old versions of GnuTLS uses types like 'gnutls_session' instead
|
|
dnl of 'gnutls_session_t'. Try to detect this type if defined so
|
|
dnl that we can offer backwards compatibility.
|
|
old_cflags="$CFLAGS"
|
|
old_ldflags="$LDFLAGS"
|
|
CFLAGS="$CFLAGS $GNUTLS_CFLAGS"
|
|
LDFLAGS="$LDFLAGS $GNUTLS_LIBS"
|
|
AC_CHECK_TYPE([gnutls_session],
|
|
AC_DEFINE([GNUTLS_1_0_COMPAT],[],
|
|
[enable GnuTLS 1.0 compatibility macros]),,
|
|
[#include <gnutls/gnutls.h>])
|
|
CFLAGS="$old_cflags"
|
|
LDFLAGS="$old_ldflags"
|
|
|
|
|
|
dnl Cyrus SASL
|
|
AC_ARG_WITH([sasl],
|
|
[ --with-sasl use cyrus SASL for authentication],
|
|
[],
|
|
[with_sasl=check])
|
|
|
|
SASL_CFLAGS=
|
|
SASL_LIBS=
|
|
if test "x$with_sasl" != "xno"; then
|
|
if test "x$with_sasl" != "xyes" -a "x$with_sasl" != "xcheck"; then
|
|
SASL_CFLAGS="-I$with_sasl"
|
|
SASL_LIBS="-L$with_sasl"
|
|
fi
|
|
fail=0
|
|
old_cflags="$CFLAGS"
|
|
old_libs="$LIBS"
|
|
CFLAGS="$CFLAGS $SASL_CFLAGS"
|
|
LIBS="$LIBS $SASL_LIBS"
|
|
AC_CHECK_HEADER([sasl/sasl.h],[],[
|
|
if test "x$with_sasl" != "xcheck" ; then
|
|
with_sasl=no
|
|
else
|
|
fail=1
|
|
fi])
|
|
if test "x$with_sasl" != "xno" ; then
|
|
AC_CHECK_LIB([sasl2], [sasl_client_init],[with_sasl=yes],[
|
|
if test "x$with_sasl" = "xcheck" ; then
|
|
with_sasl=no
|
|
else
|
|
fail=1
|
|
fi])
|
|
fi
|
|
test $fail = 1 &&
|
|
AC_MSG_ERROR([You must install the Cyrus SASL development package in order to compile libvirt])
|
|
CFLAGS="$old_cflags"
|
|
LIBS="$old_libs"
|
|
SASL_LIBS="$SASL_LIBS -lsasl2"
|
|
if test "x$with_sasl" = "xyes" ; then
|
|
AC_DEFINE_UNQUOTED([HAVE_SASL], 1,
|
|
[whether Cyrus SASL is available for authentication])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([HAVE_SASL], [test "x$with_sasl" = "xyes"])
|
|
AC_SUBST([SASL_CFLAGS])
|
|
AC_SUBST([SASL_LIBS])
|
|
|
|
|
|
dnl PolicyKit library
|
|
POLKIT_CFLAGS=
|
|
POLKIT_LIBS=
|
|
AC_ARG_WITH([polkit],
|
|
[ --with-polkit use PolicyKit for UNIX socket access checks],
|
|
[],
|
|
[with_polkit=check])
|
|
|
|
if test "x$with_polkit" = "xyes" -o "x$with_polkit" = "xcheck"; then
|
|
PKG_CHECK_MODULES(POLKIT, polkit-dbus >= $POLKIT_REQUIRED,
|
|
[with_polkit=yes], [
|
|
if test "x$with_polkit" = "xcheck" ; then
|
|
with_polkit=no
|
|
else
|
|
AC_MSG_ERROR(
|
|
[You must install PolicyKit >= $POLKIT_REQUIRED to compile libvirt])
|
|
fi
|
|
])
|
|
if test "x$with_polkit" = "xyes" ; then
|
|
AC_DEFINE_UNQUOTED([HAVE_POLKIT], 1,
|
|
[use PolicyKit for UNIX socket access checks])
|
|
|
|
old_CFLAGS=$CFLAGS
|
|
old_LDFLAGS=$LDFLAGS
|
|
CFLAGS="$CFLAGS $POLKIT_CFLAGS"
|
|
LDFLAGS="$LDFLAGS $POLKIT_LIBS"
|
|
AC_CHECK_FUNCS([polkit_context_is_caller_authorized])
|
|
CFLAGS="$old_CFLAGS"
|
|
LDFLAGS="$old_LDFLAGS"
|
|
|
|
AC_PATH_PROG([POLKIT_AUTH], [polkit-auth])
|
|
if test "x$POLKIT_AUTH" != "x"; then
|
|
AC_DEFINE_UNQUOTED([POLKIT_AUTH],["$POLKIT_AUTH"],[Location of polkit-auth program])
|
|
fi
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([HAVE_POLKIT], [test "x$with_polkit" = "xyes"])
|
|
AC_SUBST([POLKIT_CFLAGS])
|
|
AC_SUBST([POLKIT_LIBS])
|
|
|
|
dnl Avahi library
|
|
AC_ARG_WITH([avahi],
|
|
[ --with-avahi use avahi to advertise remote daemon],
|
|
[],
|
|
[with_avahi=check])
|
|
|
|
AVAHI_CFLAGS=
|
|
AVAHI_LIBS=
|
|
if test "x$with_avahi" = "xyes" -o "x$with_avahi" = "xcheck"; then
|
|
PKG_CHECK_MODULES(AVAHI, avahi-client >= $AVAHI_REQUIRED,
|
|
[with_avahi=yes], [
|
|
if test "x$with_avahi" = "xcheck" ; then
|
|
with_avahi=no
|
|
else
|
|
AC_MSG_ERROR(
|
|
[You must install Avahi >= $AVAHI_REQUIRED to compile libvirt])
|
|
fi
|
|
])
|
|
if test "x$with_avahi" = "xyes" ; then
|
|
AC_DEFINE_UNQUOTED([HAVE_AVAHI], 1,
|
|
[whether Avahi is used to broadcast server presense])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([HAVE_AVAHI], [test "x$with_avahi" = "xyes"])
|
|
AC_SUBST([AVAHI_CFLAGS])
|
|
AC_SUBST([AVAHI_LIBS])
|
|
|
|
dnl SELinux
|
|
AC_ARG_WITH([selinux],
|
|
[ --with-selinux use SELinux to manage security],
|
|
[],
|
|
[with_selinux=check])
|
|
|
|
SELINUX_CFLAGS=
|
|
SELINUX_LIBS=
|
|
if test "$with_selinux" != "no"; then
|
|
old_cflags="$CFLAGS"
|
|
old_libs="$LIBS"
|
|
if test "$with_selinux" = "check"; then
|
|
AC_CHECK_HEADER([selinux/selinux.h],[],[with_selinux=no])
|
|
AC_CHECK_LIB([selinux], [fgetfilecon],[],[with_selinux=no])
|
|
if test "$with_selinux" != "no"; then
|
|
with_selinux="yes"
|
|
fi
|
|
else
|
|
fail=0
|
|
AC_CHECK_HEADER([selinux/selinux.h],[],[fail=1])
|
|
AC_CHECK_LIB([selinux], [fgetfilecon],[],[fail=1])
|
|
test $fail = 1 &&
|
|
AC_MSG_ERROR([You must install the SELinux development package in order to compile libvirt])
|
|
fi
|
|
CFLAGS="$old_cflags"
|
|
LIBS="$old_libs"
|
|
fi
|
|
if test "$with_selinux" = "yes"; then
|
|
SELINUX_LIBS="-lselinux"
|
|
AC_DEFINE_UNQUOTED([HAVE_SELINUX], 1, [whether SELinux is available for security])
|
|
fi
|
|
AM_CONDITIONAL([HAVE_SELINUX], [test "$with_selinux" != "no"])
|
|
AC_SUBST([SELINUX_CFLAGS])
|
|
AC_SUBST([SELINUX_LIBS])
|
|
|
|
dnl NUMA lib
|
|
AC_ARG_WITH([numactl],
|
|
[ --with-numactl use numactl for host topology info],
|
|
[],
|
|
[with_numactl=check])
|
|
|
|
NUMACTL_CFLAGS=
|
|
NUMACTL_LIBS=
|
|
if test "$with_qemu" = "yes" -a "$with_numactl" != "no"; then
|
|
old_cflags="$CFLAGS"
|
|
old_libs="$LIBS"
|
|
if test "$with_numactl" = "check"; then
|
|
AC_CHECK_HEADER([numa.h],[],[with_numactl=no])
|
|
AC_CHECK_LIB([numa], [numa_available],[],[with_numactl=no])
|
|
if test "$with_numactl" != "no"; then
|
|
with_numactl="yes"
|
|
fi
|
|
else
|
|
fail=0
|
|
AC_CHECK_HEADER([numa.h],[],[fail=1])
|
|
AC_CHECK_LIB([numa], [numa_available],[],[fail=1])
|
|
test $fail = 1 &&
|
|
AC_MSG_ERROR([You must install the numactl development package in order to compile and run libvirt])
|
|
fi
|
|
CFLAGS="$old_cflags"
|
|
LIBS="$old_libs"
|
|
fi
|
|
if test "$with_numactl" = "yes"; then
|
|
NUMACTL_LIBS="-lnuma"
|
|
AC_DEFINE_UNQUOTED([HAVE_NUMACTL], 1, [whether numactl is available for topology info])
|
|
fi
|
|
AM_CONDITIONAL([HAVE_NUMACTL], [test "$with_numactl" != "no"])
|
|
AC_SUBST([NUMACTL_CFLAGS])
|
|
AC_SUBST([NUMACTL_LIBS])
|
|
|
|
dnl virsh libraries
|
|
AC_CHECK_HEADERS([readline/readline.h])
|
|
|
|
# Check for readline.
|
|
AC_CHECK_LIB([readline], [readline],
|
|
[lv_use_readline=yes; VIRSH_LIBS="$VIRSH_LIBS -lreadline"],
|
|
[lv_use_readline=no])
|
|
|
|
# If the above test failed, it may simply be that -lreadline requires
|
|
# some termcap-related code, e.g., from one of the following libraries.
|
|
# See if adding one of them to LIBS helps.
|
|
if test $lv_use_readline = no; then
|
|
lv_saved_libs=$LIBS
|
|
LIBS=
|
|
AC_SEARCH_LIBS([tgetent], [ncurses curses termcap termlib])
|
|
case $LIBS in
|
|
no*) ;; # handle "no" and "none required"
|
|
*) # anything else is a -lLIBRARY
|
|
# Now, check for -lreadline again, also using $LIBS.
|
|
# Note: this time we use a different function, so that
|
|
# we don't get a cached "no" result.
|
|
AC_CHECK_LIB([readline], [rl_initialize],
|
|
[lv_use_readline=yes
|
|
VIRSH_LIBS="$VIRSH_LIBS -lreadline $LIBS"],,
|
|
[$LIBS])
|
|
;;
|
|
esac
|
|
test $lv_use_readline = no &&
|
|
AC_MSG_WARN([readline library not found])
|
|
LIBS=$lv_saved_libs
|
|
fi
|
|
|
|
if test $lv_use_readline = yes; then
|
|
AC_DEFINE_UNQUOTED([USE_READLINE], 1,
|
|
[whether virsh can use readline])
|
|
READLINE_CFLAGS=-DUSE_READLINE
|
|
else
|
|
READLINE_CFLAGS=
|
|
fi
|
|
AC_SUBST([READLINE_CFLAGS])
|
|
AC_SUBST([VIRSH_LIBS])
|
|
|
|
AC_SUBST([WITH_XEN])
|
|
AC_SUBST([LIBVIRT_FEATURES])
|
|
|
|
|
|
dnl
|
|
dnl Storage driver checks
|
|
dnl
|
|
|
|
AC_ARG_WITH([storage-fs],
|
|
[ --with-storage-fs with FileSystem backend for the storage driver (on)],[],[with_storage_fs=check])
|
|
AC_ARG_WITH([storage-lvm],
|
|
[ --with-storage-lvm with LVM backend for the storage driver (on)],[],[with_storage_lvm=check])
|
|
AC_ARG_WITH([storage-iscsi],
|
|
[ --with-storage-iscsi with iSCSI backend for the storage driver (on)],[],[with_storage_iscsi=check])
|
|
AC_ARG_WITH([storage-disk],
|
|
[ --with-storage-disk with GPartd Disk backend for the storage driver (on)],[],[with_storage_disk=check])
|
|
|
|
if test "$with_storage_fs" = "yes" -o "$with_storage_fs" = "check"; then
|
|
AC_PATH_PROG([MOUNT], [mount], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([UMOUNT], [umount], [], [$PATH:/sbin:/usr/sbin])
|
|
if test "$with_storage_fs" = "yes" ; then
|
|
if test -z "$MOUNT" ; then AC_MSG_ERROR([We need mount for FS storage driver]) ; fi
|
|
if test -z "$UMOUNT" ; then AC_MSG_ERROR([We need umount for FS storage driver]) ; fi
|
|
else
|
|
if test -z "$MOUNT" ; then with_storage_fs=no ; fi
|
|
if test -z "$UMOUNT" ; then with_storage_fs=no ; fi
|
|
|
|
if test "$with_storage_fs" = "check" ; then with_storage_fs=yes ; fi
|
|
fi
|
|
|
|
if test "$with_storage_fs" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_FS], 1, [whether FS backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([MOUNT],["$MOUNT"],
|
|
[Location or name of the mount program])
|
|
AC_DEFINE_UNQUOTED([UMOUNT],["$UMOUNT"],
|
|
[Location or name of the mount program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_FS], [test "$with_storage_fs" = "yes"])
|
|
|
|
AC_PATH_PROG([QEMU_IMG], [qemu-img], [], [$PATH:/sbin:/usr/sbin:/bin:/usr/bin])
|
|
if test -n "$QEMU_IMG" ; then
|
|
AC_DEFINE_UNQUOTED([HAVE_QEMU_IMG], 1, [whether qemu-img is available for non-raw files])
|
|
AC_DEFINE_UNQUOTED([QEMU_IMG],["$QEMU_IMG"],
|
|
[Location or name of the qemu-img program])
|
|
fi
|
|
|
|
AC_PATH_PROG([QCOW_CREATE], [qcow-create], [], [$PATH:/sbin:/usr/sbin:/bin:/usr/bin])
|
|
if test -n "$QCOW_CREATE" ; then
|
|
AC_DEFINE_UNQUOTED([HAVE_QCOW_CREATE], 1, [whether qcow-create is available for non-raw files])
|
|
AC_DEFINE_UNQUOTED([QCOW_CREATE],["$QCOW_CREATE"],
|
|
[Location or name of the qcow-create program])
|
|
fi
|
|
|
|
|
|
if test "$with_storage_lvm" = "yes" -o "$with_storage_lvm" = "check"; then
|
|
AC_PATH_PROG([PVCREATE], [pvcreate], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGCREATE], [vgcreate], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([LVCREATE], [lvcreate], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([PVREMOVE], [pvremove], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGREMOVE], [vgremove], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([LVREMOVE], [lvremove], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGCHANGE], [vgchange], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([PVS], [pvs], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGS], [vgs], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([LVS], [lvs], [], [$PATH:/sbin:/usr/sbin])
|
|
|
|
if test "$with_storage_lvm" = "yes" ; then
|
|
if test -z "$PVCREATE" ; then AC_MSG_ERROR([We need pvcreate for LVM storage driver]) ; fi
|
|
if test -z "$VGCREATE" ; then AC_MSG_ERROR([We need vgcreate for LVM storage driver]) ; fi
|
|
if test -z "$LVCREATE" ; then AC_MSG_ERROR([We need lvcreate for LVM storage driver]) ; fi
|
|
if test -z "$PVREMOVE" ; then AC_MSG_ERROR([We need pvremove for LVM storage driver]) ; fi
|
|
if test -z "$VGREMOVE" ; then AC_MSG_ERROR([We need vgremove for LVM storage driver]) ; fi
|
|
if test -z "$LVREMOVE" ; then AC_MSG_ERROR([We need lvremove for LVM storage driver]) ; fi
|
|
if test -z "$VGCHANGE" ; then AC_MSG_ERROR([We need vgchange for LVM storage driver]) ; fi
|
|
if test -z "$PVS" ; then AC_MSG_ERROR([We need pvs for LVM storage driver]) ; fi
|
|
if test -z "$VGS" ; then AC_MSG_ERROR([We need vgs for LVM storage driver]) ; fi
|
|
if test -z "$LVS" ; then AC_MSG_ERROR([We need lvs for LVM storage driver]) ; fi
|
|
else
|
|
if test -z "$PVCREATE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGCREATE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$LVCREATE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$PVREMOVE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGREMOVE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$LVREMOVE" ; then with_storage_lvm=no ; fi
|
|
if test -z "VGCHANGE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$PVS" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGS" ; then with_storage_lvm=no ; fi
|
|
if test -z "$LVS" ; then with_storage_lvm=no ; fi
|
|
|
|
if test "$with_storage_lvm" = "check" ; then with_storage_lvm=yes ; fi
|
|
fi
|
|
|
|
if test "$with_storage_lvm" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_LVM], 1, [whether LVM backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([PVCREATE],["$PVCREATE"],[Location of pvcreate program])
|
|
AC_DEFINE_UNQUOTED([VGCREATE],["$VGCREATE"],[Location of vgcreate program])
|
|
AC_DEFINE_UNQUOTED([LVCREATE],["$LVCREATE"],[Location of lvcreate program])
|
|
AC_DEFINE_UNQUOTED([PVREMOVE],["$PVREMOVE"],[Location of pvcreate program])
|
|
AC_DEFINE_UNQUOTED([VGREMOVE],["$VGREMOVE"],[Location of vgcreate program])
|
|
AC_DEFINE_UNQUOTED([LVREMOVE],["$LVREMOVE"],[Location of lvcreate program])
|
|
AC_DEFINE_UNQUOTED([VGCHANGE],["$VGCHANGE"],[Location of vgchange program])
|
|
AC_DEFINE_UNQUOTED([PVS],["$PVS"],[Location of pvs program])
|
|
AC_DEFINE_UNQUOTED([VGS],["$VGS"],[Location of vgs program])
|
|
AC_DEFINE_UNQUOTED([LVS],["$LVS"],[Location of lvs program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_LVM], [test "$with_storage_lvm" = "yes"])
|
|
|
|
|
|
|
|
if test "$with_storage_iscsi" = "yes" -o "$with_storage_iscsi" = "check"; then
|
|
AC_PATH_PROG([ISCSIADM], [iscsiadm], [], [$PATH:/sbin:/usr/sbin])
|
|
if test "$with_storage_iscsi" = "yes" ; then
|
|
if test -z "$ISCSIADM" ; then AC_MSG_ERROR([We need iscsiadm for iSCSI storage driver]) ; fi
|
|
else
|
|
if test -z "$ISCSIADM" ; then with_storage_iscsi=no ; fi
|
|
|
|
if test "$with_storage_iscsi" = "check" ; then with_storage_iscsi=yes ; fi
|
|
fi
|
|
|
|
if test "$with_storage_iscsi" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_ISCSI], 1, [whether iSCSI backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([ISCSIADM],["$ISCSIADM"],[Location of iscsiadm program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_ISCSI], [test "$with_storage_iscsi" = "yes"])
|
|
|
|
|
|
|
|
LIBPARTED_CFLAGS=
|
|
LIBPARTED_LIBS=
|
|
if test "$with_storage_disk" = "yes" -o "$with_storage_disk" = "check"; then
|
|
AC_PATH_PROG([PARTED], [parted], [], [$PATH:/sbin:/usr/sbin])
|
|
if test -z "$PARTED" ; then
|
|
with_storage_disk=no
|
|
PARTED_FOUND=no
|
|
else
|
|
PARTED_FOUND=yes
|
|
fi
|
|
|
|
if test "$with_storage_disk" != "no" -a "x$PKG_CONFIG" != "x" ; then
|
|
PKG_CHECK_MODULES(LIBPARTED, libparted >= $PARTED_REQUIRED, [], [PARTED_FOUND=no])
|
|
fi
|
|
if test "$PARTED_FOUND" = "no"; then
|
|
# RHEL-5 vintage parted is missing pkg-config files
|
|
save_LIBS="$LIBS"
|
|
save_CFLAGS="$CFLAGS"
|
|
PARTED_FOUND=yes
|
|
AC_CHECK_HEADER([parted/parted.h],,[PARTED_FOUND=no])
|
|
AC_CHECK_LIB([uuid], [uuid_generate],,[PARTED_FOUND=no])
|
|
AC_CHECK_LIB([parted], [ped_device_read],,[PARTED_FOUND=no])
|
|
LIBPARTED_LIBS="-luuid -lparted"
|
|
LIBS="$save_LIBS"
|
|
CFLAGS="$save_CFLAGS"
|
|
fi
|
|
|
|
if test "$PARTED_FOUND" = "no" ; then
|
|
if test "$with_storage_disk" = "yes" ; then
|
|
AC_MSG_ERROR([We need parted for disk storage driver])
|
|
else
|
|
with_storage_disk=no
|
|
fi
|
|
else
|
|
with_storage_disk=yes
|
|
fi
|
|
|
|
if test "$with_storage_disk" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_DISK], 1, [whether Disk backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([PARTED],["$PARTED"], [Location or name of the parted program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_DISK], [test "$with_storage_disk" = "yes"])
|
|
AC_SUBST([LIBPARTED_CFLAGS])
|
|
AC_SUBST([LIBPARTED_LIBS])
|
|
|
|
|
|
dnl
|
|
dnl check for python
|
|
dnl
|
|
|
|
PYTHON_VERSION=
|
|
PYTHON_INCLUDES=
|
|
PYTHON_SITE_PACKAGES=
|
|
PYTHON_TESTS=
|
|
pythondir=
|
|
if test "$with_python" != "no" ; then
|
|
if test -x "$with_python/bin/python"
|
|
then
|
|
echo Found python in $with_python/bin/python
|
|
PYTHON="$with_python/bin/python"
|
|
else
|
|
if test -x "$with_python"
|
|
then
|
|
echo Found python in $with_python
|
|
PYTHON="$with_python"
|
|
else
|
|
if test -x "$PYTHON"
|
|
then
|
|
echo Found python in environment PYTHON=$PYTHON
|
|
with_python=`$PYTHON -c "import sys; print sys.exec_prefix"`
|
|
else
|
|
AC_PATH_PROG([PYTHON], [python python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5])
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$PYTHON" != ""
|
|
then
|
|
PYTHON_VERSION=`$PYTHON -c "import sys; print sys.version[[0:3]]"`
|
|
echo Found Python version $PYTHON_VERSION
|
|
fi
|
|
if test "$PYTHON_VERSION" != ""
|
|
then
|
|
if test -r $with_python/include/python$PYTHON_VERSION/Python.h -a \
|
|
-d $with_python/lib/python$PYTHON_VERSION/site-packages
|
|
then
|
|
PYTHON_INCLUDES=$with_python/include/python$PYTHON_VERSION
|
|
PYTHON_SITE_PACKAGES=$libdir/python$PYTHON_VERSION/site-packages
|
|
else
|
|
if test -r $prefix/include/python$PYTHON_VERSION/Python.h
|
|
then
|
|
PYTHON_INCLUDES=$prefix/include/python$PYTHON_VERSION
|
|
PYTHON_SITE_PACKAGES=$libdir/python$PYTHON_VERSION/site-packages
|
|
else
|
|
if test -r /usr/include/python$PYTHON_VERSION/Python.h
|
|
then
|
|
PYTHON_INCLUDES=/usr/include/python$PYTHON_VERSION
|
|
PYTHON_SITE_PACKAGES=$libdir/python$PYTHON_VERSION/site-packages
|
|
else
|
|
echo could not find python$PYTHON_VERSION/Python.h
|
|
fi
|
|
fi
|
|
if test ! -d "$PYTHON_SITE_PACKAGES"
|
|
then
|
|
PYTHON_SITE_PACKAGES=`$PYTHON -c "from distutils import sysconfig; print sysconfig.get_python_lib()"`
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$with_python" != ""
|
|
then
|
|
pythondir='$(PYTHON_SITE_PACKAGES)'
|
|
else
|
|
pythondir='$(libdir)/python$(PYTHON_VERSION)/site-packages'
|
|
fi
|
|
else
|
|
PYTHON=
|
|
fi
|
|
AM_CONDITIONAL([WITH_PYTHON], test "$PYTHON_INCLUDES" != "")
|
|
AC_SUBST([pythondir])
|
|
AC_SUBST([PYTHON_VERSION])
|
|
AC_SUBST([PYTHON_INCLUDES])
|
|
AC_SUBST([PYTHON_SITE_PACKAGES])
|
|
|
|
AC_MSG_CHECKING([whether this host is running a Xen kernel])
|
|
RUNNING_XEN=
|
|
if test -d /proc/sys/xen
|
|
then
|
|
RUNNING_XEN=yes
|
|
else
|
|
RUNNING_XEN=no
|
|
fi
|
|
AC_MSG_RESULT($RUNNING_XEN)
|
|
|
|
AC_MSG_CHECKING([If XenD UNIX socket /var/run/xend/xmlrpc.sock is accessible])
|
|
RUNNING_XEND=
|
|
if test -S /var/run/xend/xmlrpc.sock
|
|
then
|
|
RUNNING_XEND=yes
|
|
else
|
|
RUNNING_XEND=no
|
|
fi
|
|
AC_MSG_RESULT($RUNNING_XEND)
|
|
|
|
AM_CONDITIONAL([ENABLE_XEN_TESTS], [test "$RUNNING_XEN" != "no" -a "$RUNNING_XEND" != "no"])
|
|
|
|
AC_ARG_ENABLE([test-coverage],
|
|
[ --enable-test-coverage turn on code coverage instrumentation],
|
|
[case "${enableval}" in
|
|
yes|no) ;;
|
|
*) AC_MSG_ERROR([bad value ${enableval} for test-coverage option]) ;;
|
|
esac],
|
|
[enableval=no])
|
|
enable_coverage=$enableval
|
|
|
|
if test "${enable_coverage}" = yes; then
|
|
gl_COMPILER_FLAGS(-fprofile-arcs)
|
|
gl_COMPILER_FLAGS(-ftest-coverage)
|
|
AC_SUBST([COVERAGE_CFLAGS], [$COMPILER_FLAGS])
|
|
AC_SUBST([COVERAGE_LDFLAGS], [$COMPILER_FLAGS])
|
|
COMPILER_FLAGS=
|
|
fi
|
|
|
|
AC_ARG_ENABLE([test-oom],
|
|
[ --enable-test-oom memory allocation failure checking],
|
|
[case "${enableval}" in
|
|
yes|no) ;;
|
|
*) AC_MSG_ERROR([bad value ${enableval} for test-oom option]) ;;
|
|
esac],
|
|
[enableval=no])
|
|
enable_oom=$enableval
|
|
|
|
if test "${enable_oom}" = yes; then
|
|
have_trace=yes
|
|
AC_CHECK_HEADER([execinfo.h],[],[have_trace=no])
|
|
AC_CHECK_FUNC([backtrace],[],[have_trace=no])
|
|
if test "$have_trace" = "yes"; then
|
|
AC_DEFINE([TEST_OOM_TRACE], 1, [Whether backtrace() is available])
|
|
fi
|
|
AC_DEFINE([TEST_OOM], 1, [Whether malloc OOM checking is enabled])
|
|
fi
|
|
|
|
dnl Enable building the proxy?
|
|
|
|
AC_ARG_WITH([xen-proxy],
|
|
[ --with-xen-proxy add XEN setuid proxy support (on)],[],[with_xen_proxy=auto])
|
|
|
|
AC_MSG_CHECKING([if Xen setuid proxy is needed])
|
|
if test "$with_xen_proxy" = "auto"; then
|
|
if test "$with_polkit" = "yes"; then
|
|
with_xen_proxy="no"
|
|
else
|
|
with_xen_proxy="yes"
|
|
fi
|
|
fi
|
|
if test "$with_xen" != "yes"; then
|
|
with_xen_proxy="no"
|
|
fi
|
|
AC_MSG_RESULT([$with_xen_proxy])
|
|
|
|
AM_CONDITIONAL([WITH_PROXY],[test "$with_xen_proxy" = "yes"])
|
|
if test "$with_xen_proxy" = "yes"; then
|
|
AC_DEFINE([WITH_PROXY], 1, [Whether Xen proxy is enabled])
|
|
fi
|
|
|
|
dnl Enable building libvirtd?
|
|
AM_CONDITIONAL([WITH_LIBVIRTD],[test "x$with_libvirtd" = "xyes"])
|
|
|
|
dnl Check for gettext
|
|
AM_GNU_GETTEXT_VERSION([0.14.1])
|
|
AM_GNU_GETTEXT([external])
|
|
if test -d po
|
|
then
|
|
ALL_LINGUAS=`(cd po > /dev/null && ls *.po) | sed 's+\.po$++'`
|
|
else
|
|
ALL_LINGUAS="af am ar as be bg bn_IN bn ca cs cy da de el en_GB es et eu_ES fa fi fr gl gu he hi hr hu hy id is it ja ka kn ko ku lo lt lv mk ml mr ms my nb nl nn no nso or pa pl pt_BR pt ro ru si sk sl sq sr@latin sr sv ta te th tr uk ur vi zh_CN zh_TW zu"
|
|
fi
|
|
|
|
dnl Extra link-time flags for Cygwin.
|
|
dnl Copied from libxml2 configure.in, but I removed mingw changes
|
|
dnl for now since I'm not supporting mingw at present. - RWMJ
|
|
CYGWIN_EXTRA_LDFLAGS=
|
|
CYGWIN_EXTRA_LIBADD=
|
|
CYGWIN_EXTRA_PYTHON_LIBADD=
|
|
MINGW_EXTRA_LDFLAGS=
|
|
case "$host" in
|
|
*-*-cygwin*)
|
|
CYGWIN_EXTRA_LDFLAGS="-no-undefined"
|
|
CYGWIN_EXTRA_LIBADD="${INTLLIBS}"
|
|
if test "x$PYTHON_VERSION" != "x"; then
|
|
CYGWIN_EXTRA_PYTHON_LIBADD="-L/usr/lib/python${PYTHON_VERSION}/config -lpython${PYTHON_VERSION}"
|
|
fi
|
|
;;
|
|
*-*-mingw*)
|
|
MINGW_EXTRA_LDFLAGS="-no-undefined"
|
|
;;
|
|
esac
|
|
AC_SUBST([CYGWIN_EXTRA_LDFLAGS])
|
|
AC_SUBST([CYGWIN_EXTRA_LIBADD])
|
|
AC_SUBST([CYGWIN_EXTRA_PYTHON_LIBADD])
|
|
AC_SUBST([MINGW_EXTRA_LDFLAGS])
|
|
|
|
# Set LV_LIBTOOL_OBJDIR to "." or $lt_cv_objdir, depending on whether
|
|
# we're building shared libraries. This is the name of the directory
|
|
# in which .o files will be created.
|
|
test "$enable_shared" = no && lt_cv_objdir=.
|
|
LV_LIBTOOL_OBJDIR=${lt_cv_objdir-.}
|
|
AC_SUBST([LV_LIBTOOL_OBJDIR])
|
|
|
|
# very annoying
|
|
rm -f COPYING
|
|
cp COPYING.LIB COPYING
|
|
|
|
AC_OUTPUT(Makefile src/Makefile include/Makefile docs/Makefile \
|
|
docs/examples/Makefile docs/devhelp/Makefile \
|
|
docs/examples/python/Makefile \
|
|
gnulib/lib/Makefile \
|
|
gnulib/tests/Makefile \
|
|
libvirt.pc libvirt.spec \
|
|
po/Makefile.in \
|
|
include/libvirt/Makefile include/libvirt/libvirt.h \
|
|
python/Makefile python/tests/Makefile \
|
|
qemud/Makefile \
|
|
tests/Makefile proxy/Makefile \
|
|
tests/xml2sexprdata/Makefile \
|
|
tests/sexpr2xmldata/Makefile \
|
|
tests/xmconfigdata/Makefile \
|
|
tests/xencapsdata/Makefile \
|
|
tests/virshdata/Makefile tests/confdata/Makefile)
|
|
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Configuration summary])
|
|
AC_MSG_NOTICE([=====================])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Drivers])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Xen: $with_xen])
|
|
AC_MSG_NOTICE([ Proxy: $with_xen_proxy])
|
|
AC_MSG_NOTICE([ QEMU: $with_qemu])
|
|
AC_MSG_NOTICE([ OpenVZ: $with_openvz])
|
|
AC_MSG_NOTICE([ LXC: $with_lxc])
|
|
AC_MSG_NOTICE([ Test: $with_test])
|
|
AC_MSG_NOTICE([ Remote: $with_remote])
|
|
AC_MSG_NOTICE([Libvirtd: $with_libvirtd])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Storage Drivers])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Dir: yes])
|
|
AC_MSG_NOTICE([ FS: $with_storage_fs])
|
|
AC_MSG_NOTICE([ NetFS: $with_storage_fs])
|
|
AC_MSG_NOTICE([ LVM: $with_storage_lvm])
|
|
AC_MSG_NOTICE([ iSCSI: $with_storage_iscsi])
|
|
AC_MSG_NOTICE([ Disk: $with_storage_disk])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Libraries])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ libxml: $LIBXML_CFLAGS $LIBXML_LIBS])
|
|
AC_MSG_NOTICE([ gnutls: $GNUTLS_CFLAGS $GNUTLS_LIBS])
|
|
if test "$with_sasl" != "no" ; then
|
|
AC_MSG_NOTICE([ sasl: $SASL_CFLAGS $SASL_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ sasl: no])
|
|
fi
|
|
if test "$with_avahi" = "yes" ; then
|
|
AC_MSG_NOTICE([ avahi: $AVAHI_CFLAGS $AVAHI_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ avahi: no])
|
|
fi
|
|
if test "$with_polkit" = "yes" ; then
|
|
AC_MSG_NOTICE([ polkit: $POLKIT_CFLAGS $POLKIT_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ polkit: no])
|
|
fi
|
|
if test "$with_selinux" = "yes" ; then
|
|
AC_MSG_NOTICE([ selinux: $SELINUX_CFLAGS $SELINUX_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ selinux: no])
|
|
fi
|
|
if test "$with_numactl" = "yes" ; then
|
|
AC_MSG_NOTICE([ numactl: $NUMACTL_CFLAGS $NUMACTL_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ numactl: no])
|
|
fi
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Test suite])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Coverage: $enable_coverage])
|
|
AC_MSG_NOTICE([ Alloc OOM: $enable_oom])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Miscellaneous])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Debug: $enable_debug])
|
|
AC_MSG_NOTICE([ Warnings: $enable_compile_warnings])
|
|
AC_MSG_NOTICE([ Readline: $lv_use_readline])
|
|
AC_MSG_NOTICE([])
|