AC_CONFIG_HEADERS([config.h])

PKG_PROG_PKG_CONFIG

AC_LANG_C

# Upstream's pkg.m4 (since 0.27) offers this now, but define our own

# compatible version in case the local version of pkgconfig isn't new enough.

# https://bugs.freedesktop.org/show_bug.cgi?id=48743

m4_ifdef([PKG_INSTALLDIR], [PKG_INSTALLDIR],

[AC_ARG_WITH([pkgconfigdir],

[AS_HELP_STRING([--with-pkgconfigdir],

[install directory for openconnect.pc pkg-config file])],

[],[with_pkgconfigdir='$(libdir)/pkgconfig'])

AC_SUBST([pkgconfigdir], [${with_pkgconfigdir}])])

symver_time=

symver_getline=

symver_asprintf=

symver_vasprintf=

;;

*netbsd*)

AC_MSG_NOTICE([Applying feature macros for NetBSD build])

AC_DEFINE(_POSIX_C_SOURCE, 200112L, [_POSIX_C_SOURCE])

AC_DEFINE(_NETBSD_SOURCE, 1, [_NETBSD_SOURCE])

*openbsd*)

AC_MSG_NOTICE([Applying feature macros for OpenBSD build])

use_openbsd_libtool=true

;;

*solaris*|*sunos*)

AC_MSG_NOTICE([Applying workaround for broken SunOS time() function])

symver_time="openconnect__time;"

;;

# For asprintf()

AC_DEFINE(_GNU_SOURCE, 1, [_GNU_SOURCE])

system_pcsc_libs="-lwinscard"

system_pcsc_cflags=

system_pcsc_libs="-Wl,-framework -Wl,PCSC"

system_pcsc_cflags=

*)

# On FreeBSD the only way to get vsyslog() visible is to define

# *nothing*, which makes absolutely everything visible.

# On Darwin enabling _POSIX_C_SOURCE breaks <sys/mount.h> because

# u_long and other types don't get defined. OpenBSD is similar.

;;

esac

AC_ARG_WITH([vpnc-script],

[AS_HELP_STRING([--with-vpnc-script],

[default location of vpnc-script helper])])

if test "$with_vpnc_script" = "yes" || test "$with_vpnc_script" = ""; then

if test "$have_win" = "yes"; then

with_vpnc_script=vpnc-script-win.js

else

with_vpnc_script=/etc/vpnc/vpnc-script

if ! test -x "$with_vpnc_script"; then

AC_MSG_ERROR([${with_vpnc_script} does not seem to be executable.]

[OpenConnect will not function correctly without a vpnc-script.]

[See http://www.infradead.org/openconnect/vpnc-script.html for more details.]

[]

[If you are building a distribution package, please ensure that your]

[packaging is correct, and that a vpnc-script will be installed when the]

[user installs your package. You should provide a --with-vpnc-script=]

[argument to this configure script, giving the full path where the script]

[will be installed.]

[]

[The standard location is ${with_vpnc_script}. To bypass this error and]

[build OpenConnect to use the script from this location, even though it is]

[not present at the time you are building OpenConnect, pass the argument]

["--with-vpnc-script=${with_vpnc_script}"])

fi

fi

elif test "$with_vpnc_script" = "no"; then

AC_ERROR([You cannot disable vpnc-script.]

[OpenConnect will not function correctly without it.]

[See http://www.infradead.org/openconnect/vpnc-script.html])

elif test "$have_win" = "yes"; then

# Oh Windows how we hate thee. If user specifies a vpnc-script and it contains

# backslashes, double them all up to survive escaping.

with_vpnc_script="$(echo "${with_vpnc_script}" | sed s/\\\\/\\\\\\\\/g)"

fi

AC_SUBST(DEFAULT_VPNCSCRIPT, "${with_vpnc_script}")

AC_CHECK_FUNC(getline, [AC_DEFINE(HAVE_GETLINE, 1, [Have getline() function])],

[symver_getline="openconnect__getline;"])

AC_CHECK_FUNC(strcasestr, [AC_DEFINE(HAVE_STRCASESTR, 1, [Have strcasestr() function])], [])

AC_CHECK_FUNC(asprintf, [AC_DEFINE(HAVE_ASPRINTF, 1, [Have asprintf() function])],

[symver_asprintf="openconnect__asprintf;"])

AC_CHECK_FUNC(vasprintf, [AC_DEFINE(HAVE_VASPRINTF, 1, [Have vasprintf() function])],

[symver_vasprintf="openconnect__vasprintf;"])

if test -n "$symver_vasprintf"; then

AC_MSG_CHECKING([for va_copy])

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <stdarg.h>

va_list a;],[

va_list b;

va_copy(b,a);

va_end(b);])],

AC_MSG_RESULT(va_copy)],

[AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <stdarg.h>

va_list a;],[

va_list b;

__va_copy(b,a);

va_end(b);])],

AC_MSG_RESULT(__va_copy)],

[AC_MSG_RESULT(no)

])

fi

AC_SUBST(SYMVER_TIME, $symver_time)

AC_SUBST(SYMVER_GETLINE, $symver_getline)

AC_SUBST(SYMVER_ASPRINTF, $symver_asprintf)

AC_SUBST(SYMVER_VASPRINTF, $symver_vasprintf)

"-Wall

-Wextra

-Wno-missing-field-initializers

-Wno-sign-compare

-Wno-unused-parameter

-Werror=pointer-to-int-cast

-Wdeclaration-after-statement

-Werror-implicit-function-declaration

-Wformat-nonliteral

-Wformat-security

-Winit-self

-Wmissing-declarations

-Wmissing-include-dirs

-Wnested-externs

-Wpointer-arith

-Wwrite-strings")

if test "$have_win" = yes; then

# Checking "properly" for __attribute__((dllimport,stdcall)) functions is non-trivial

else

AC_CHECK_FUNC(socket, [], AC_CHECK_LIB(socket, socket, [], AC_ERROR(Cannot find socket() function)))

fi

have_inet_aton=yes

AC_CHECK_FUNC(inet_aton, [], AC_CHECK_LIB(nsl, inet_aton, [], have_inet_aton=no))

if test "$have_inet_aton" = "yes"; then

fi

AC_MSG_CHECKING([for IPV6_PATHMTU socket option])

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([

#include <netinet/in.h>

#include <sys/socket.h>

#include <sys/types.h>],[

int foo = IPV6_PATHMTU; (void)foo;])],

[AC_DEFINE(HAVE_IPV6_PATHMTU, 1, [Have IPV6_PATHMTU socket option])

AC_MSG_RESULT([yes])],

[AC_MSG_RESULT([no])])

AC_ENABLE_SHARED

AC_DISABLE_STATIC

AC_CHECK_FUNC(nl_langinfo, [AC_DEFINE(HAVE_NL_LANGINFO, 1, [Have nl_langinfo() function])], [])

if test "$ac_cv_func_nl_langinfo" = "yes"; then

AM_ICONV

if test "$am_cv_func_iconv" = "yes"; then

AC_SUBST(ICONV_LIBS, [$LTLIBICONV])

AC_SUBST(ICONV_CFLAGS, [$INCICONV])

AC_DEFINE(HAVE_ICONV, 1, [Have iconv() function])

[USE_NLS=$enableval], [USE_NLS=yes])

LIBINTL=

if test "$USE_NLS" = "yes"; then

AC_PATH_PROG(MSGFMT, msgfmt)

if test "$MSGFMT" = ""; then

AC_ERROR([msgfmt could not be found. Try configuring with --disable-nls])

fi

fi

LIBINTL=

if test "$USE_NLS" = "yes"; then

AC_MSG_CHECKING([for functional NLS support])

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <locale.h>

#include <libintl.h>],[

setlocale(LC_ALL, "");

bindtextdomain("openconnect", "/tmp");

(void)dgettext("openconnect", "foo");])],

[AC_MSG_RESULT(yes)],

[AC_LIB_LINKFLAGS_BODY([intl])

oldLIBS="$LIBS"

LIBS="$LIBS $LIBINTL"

oldCFLAGS="$LIBS"

CFLAGS="$CFLAGS $INCINTL"

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <locale.h>

#include <libintl.h>],[

setlocale(LC_ALL, "");

bindtextdomain("openconnect", "/tmp");

(void)dgettext("openconnect", "foo");])],

[AC_MSG_RESULT(yes (with $INCINTL $LIBINTL))],

[AC_MSG_RESULT(no)

USE_NLS=no])

LIBS="$oldLIBS"])

fi

if test "$USE_NLS" = "yes"; then

AC_SUBST(INTL_LIBS, [$LTLIBINTL])

AC_SUBST(INTL_CFLAGS, [$INCINTL])

fi

AM_CONDITIONAL(USE_NLS, [test "$USE_NLS" = "yes"])

AC_ARG_WITH([system-cafile],

AS_HELP_STRING([--with-system-cafile],

[Location of the default system CA certificate file for old (<3.0.20) GnuTLS versions]))

# We will use GnuTLS by default if it's present. We used to suppport

# using GnuTLS for the TLS connections and OpenSSL for DTLS, but none

# of the reasons for that make sense any more.

AS_HELP_STRING([--with-openssl], [Location of OpenSSL build dir]))

if test "$with_openssl" != "" -a "$with_openssl" != "no"; then

if test "$with_gnutls" = ""; then

with_gnutls=no

elif test "$with_gnutls" = "yes"; then

AC_MSG_ERROR([You cannot choose both GnuTLS and OpenSSL.])

fi

fi

# First, check if GnuTLS exists and is usable

PKG_CHECK_MODULES(GNUTLS, gnutls,

[if ! $PKG_CONFIG --atleast-version=3.2.10 gnutls; then

AC_MSG_WARN([Your GnuTLS is too old. At least v3.2.10 is required])

ssl_library=GnuTLS

fi], [:])

elif test "$with_gnutls" != "no"; then

AC_ERROR([Values other than 'yes' or 'no' for --with-gnutls are not supported])

fi

# Do we need to look for OpenSSL?

if test "$ssl_library" = ""; then

if test "$with_gnutls" = "yes" -o "$with_openssl" = "no"; then

AC_MSG_ERROR([Suitable GnuTLS required but not found])

elif test "$with_openssl" = "yes" -o "$with_openssl" = ""; then

[oldLIBS="$LIBS"

LIBS="$LIBS -lssl -lcrypto"

AC_MSG_CHECKING([for OpenSSL without pkg-config])

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <openssl/ssl.h>

#include <openssl/err.h>],[

SSL_library_init();

ERR_clear_error();

SSL_load_error_strings();

OpenSSL_add_all_algorithms();])],

[AC_MSG_RESULT(yes)

AC_SUBST([OPENSSL_LIBS], ["-lssl -lcrypto"])

AC_SUBST([OPENSSL_CFLAGS], [])]

AC_SUBST([openssl_pc_libs], [$OPENSSL_LIBS]),

AC_ERROR([Could not build against OpenSSL])])

LIBS="$oldLIBS"])

ssl_library=OpenSSL

PKG_CHECK_MODULES(P11KIT, p11-kit-1,

[PKG_CHECK_MODULES(LIBP11, libp11,

[AC_DEFINE(HAVE_LIBP11, 1, [Have libp11 and p11-kit for OpenSSL])

AC_SUBST(P11KIT_PC, ["libp11 p11-kit-1"])

proxy_module="`$PKG_CONFIG --variable=proxy_module p11-kit-1`"

pkcs11_support="libp11"

AC_DEFINE_UNQUOTED([DEFAULT_PKCS11_MODULE], "${proxy_module}", [p11-kit proxy])],

[:])], [:])

OPENSSL_CFLAGS="-I${with_openssl}/include ${OPENSSL_CFLAGS}"

if test -r "${with_openssl}/libssl.a" -a -r "${with_openssl}/libcrypto.a"; then

OPENSSL_LIBS="${with_openssl}/libssl.a ${with_openssl}/libcrypto.a -ldl -lz"

elif test -r "${with_openssl}/crypto/.libs/libcrypto.a" -a \

-r "${with_openssl}/ssl/.libs/libssl.a"; then

OPENSSL_LIBS="${with_openssl}/ssl/.libs/libssl.a ${with_openssl}/crypto/.libs/libcrypto.a -ldl -lz"

else

AC_ERROR([Could not found OpenSSL libraries]);

fi

AC_SUBST(OPENSSL_CFLAGS)

AC_SUBST(OPENSSL_LIBS)

enable_static=yes

enable_shared=no

ssl_library=OpenSSL

AC_ARG_WITH([openssl-version-check],

AS_HELP_STRING([--without-openssl-version-check], [Do not check for known-broken OpenSSL versions]))

AC_ARG_WITH([default-gnutls-priority],

AS_HELP_STRING([--with-default-gnutls-priority=STRING],

[Provide a default string as GnuTLS priority string]),

default_gnutls_priority=$withval)

if test -n "$default_gnutls_priority"; then

AC_DEFINE_UNQUOTED([DEFAULT_PRIO], ["$default_gnutls_priority"], [The GnuTLS priority string])

fi

OpenSSL)

oldLIBS="${LIBS}"

oldCFLAGS="${CFLAGS}"

LIBS="${LIBS} ${OPENSSL_LIBS}"

CFLAGS="${CFLAGS} ${OPENSSL_CFLAGS}"

# Check for the various known-broken versions of OpenSSL, which includes LibreSSL.

if test "$with_openssl_version_check" != "no"; then

AC_MSG_CHECKING([for known-broken versions of OpenSSL])

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <openssl/opensslv.h>],

[#if defined(LIBRESSL_VERSION_NUMBER)

#error Bad OpenSSL

#endif

])],

[],

[AC_MSG_RESULT(yes)

AC_MSG_ERROR([LibreSSL does not support Cisco DTLS.]

[Build with OpenSSL or GnuTLS instead.])])

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <openssl/opensslv.h>],[#if \

(OPENSSL_VERSION_NUMBER == 0x10002000L || \

(OPENSSL_VERSION_NUMBER >= 0x100000b0L && OPENSSL_VERSION_NUMBER <= 0x100000c0L) || \

(OPENSSL_VERSION_NUMBER >= 0x10001040L && OPENSSL_VERSION_NUMBER <= 0x10001060L))

#error Bad OpenSSL

#endif

])],

[],

[AC_MSG_RESULT(yes)

AC_ERROR([This version of OpenSSL is known to be broken with Cisco DTLS.]

[See http://rt.openssl.org/Ticket/Display.html?id=2984&user=guest&pass=guest]

[Add --without-openssl-version-check to configure args to avoid this check, or]

[perhaps consider building with GnuTLS instead.])])

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <openssl/opensslv.h>],[#if \

(OPENSSL_VERSION_NUMBER == 0x1000200fL)

#error Bad OpenSSL

#endif

])],

[],

[AC_MSG_RESULT(yes)

AC_ERROR([This version of OpenSSL is known to be broken with Cisco DTLS.]

[See http://rt.openssl.org/Ticket/Display.html?id=3703&user=guest&pass=guest]

[and http://rt.openssl.org/Ticket/Display.html?id=3711&user=guest&pass=guest]

[Add --without-openssl-version-check to configure args to avoid this check, or]

[perhaps consider building with GnuTLS instead.])])

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <openssl/opensslv.h>],[#if \

((OPENSSL_VERSION_NUMBER >= 0x10001110L && OPENSSL_VERSION_NUMBER <= 0x10001150L) || \

(OPENSSL_VERSION_NUMBER >= 0x10002050L && OPENSSL_VERSION_NUMBER <= 0x10002090L))

#error Bad OpenSSL

#endif

])],

[],

[AC_MSG_RESULT(yes)

AC_ERROR([This version of OpenSSL is known to be broken with Cisco DTLS.]

[See http://rt.openssl.org/Ticket/Display.html?id=4631&user=guest&pass=guest]

[Add --without-openssl-version-check to configure args to avoid this check, or]

[perhaps consider building with GnuTLS instead.])])

AC_MSG_RESULT(no)

AC_MSG_CHECKING([for ENGINE_by_id() in OpenSSL])

AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <openssl/engine.h>],

[ENGINE_by_id("foo");])],

[AC_MSG_RESULT(yes)

AC_DEFINE(HAVE_ENGINE, [1], [OpenSSL has ENGINE support])],

[AC_MSG_RESULT(no)

AC_MSG_NOTICE([Building without OpenSSL TPM ENGINE support])])

AC_MSG_CHECKING([for dtls1_stop_timer() in OpenSSL])

AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <openssl/ssl.h>

#include <stdlib.h>

extern void dtls1_stop_timer(SSL *);],

[dtls1_stop_timer(NULL);])],

[AC_MSG_RESULT(yes)

AC_DEFINE(HAVE_DTLS1_STOP_TIMER, [1], [OpenSSL has dtls1_stop_timer() function])],

[AC_MSG_RESULT(no)])

AC_MSG_CHECKING([for DTLSv1_2_client_method() in OpenSSL])

AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <openssl/ssl.h>],

[DTLSv1_2_client_method();])],

[AC_MSG_RESULT(yes)

AC_DEFINE(HAVE_DTLS12, [1], [OpenSSL has DTLSv1_2_client_method() function])],

[AC_MSG_RESULT(no)])

AC_CHECK_FUNC(HMAC_CTX_copy,

[esp=yes],

[AC_MSG_WARN([ESP support will be disabled])])

LIBS="${oldLIBS}"

CFLAGS="${oldCFLAGS}"

AC_SUBST(SSL_LIBS, ['$(OPENSSL_LIBS)'])

AC_SUBST(SSL_CFLAGS, ['$(OPENSSL_CFLAGS)'])

;;

GnuTLS)

oldlibs="$LIBS"

oldcflags="$CFLAGS"

LIBS="$LIBS $GNUTLS_LIBS"

CFLAGS="$CFLAGS $GNUTLS_CFLAGS"

esp=yes

dtls=yes

AC_CHECK_FUNC(gnutls_certificate_set_key,

[AC_DEFINE(HAVE_GNUTLS_CERTIFICATE_SET_KEY, 1, [From GnuTLS 3.0.4])], [])

AC_CHECK_FUNC(gnutls_pk_to_sign,

[AC_DEFINE(HAVE_GNUTLS_PK_TO_SIGN, 1, [From GnuTLS 3.1.0])], [])

AC_CHECK_FUNC(gnutls_pubkey_export2,

[AC_DEFINE(HAVE_GNUTLS_PUBKEY_EXPORT2, 1, [From GnuTLS 3.1.3])], [])

AC_CHECK_FUNC(gnutls_x509_crt_set_pin_function,

[AC_DEFINE(HAVE_GNUTLS_X509_CRT_SET_PIN_FUNCTION, 1, [From GnuTLS 3.1.0])], [])

AC_CHECK_FUNC(gnutls_url_is_supported,

[AC_DEFINE(HAVE_GNUTLS_URL_IS_SUPPORTED, 1, [From GnuTLS 3.1.0])], [])

AC_CHECK_FUNC(gnutls_system_key_add_x509,

[AC_DEFINE(HAVE_GNUTLS_SYSTEM_KEYS, 1, [From GnuTLS 3.4.0])], [])

AC_CHECK_FUNC(gnutls_pkcs11_add_provider,

[PKG_CHECK_MODULES(P11KIT, p11-kit-1,

[AC_DEFINE(HAVE_P11KIT, 1, [Have. P11. Kit.])

pkcs11_support=GnuTLS

AC_SUBST(P11KIT_PC, p11-kit-1)],

[:])], [])

LIBS="$oldlibs -ltspi"

AC_MSG_CHECKING([for tss library])

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <trousers/tss.h>

#include <trousers/trousers.h>],[

int err = Tspi_Context_Create((void *)0);

Trspi_Error_String(err);])],

[AC_MSG_RESULT(yes)

AC_SUBST([TSS_LIBS], [-ltspi])

AC_SUBST([TSS_CFLAGS], [])

AC_DEFINE(HAVE_TROUSERS, 1, [Have Trousers TSS library])],

[AC_MSG_RESULT(no)])

LIBS="$oldlibs"

CFLAGS="$oldcflags"

AC_SUBST(SSL_LIBS, ['$(GNUTLS_LIBS)'])

AC_SUBST(SSL_CFLAGS, ['$(GNUTLS_CFLAGS)'])

# This should never happen

AC_MSG_ERROR([No SSL library selected])

;;

esac

if test "$pkcs11_support" != ""; then

AC_CHECK_PROG(test_pkcs11, softhsm2-util, yes)

fi

AC_ARG_ENABLE([dtls-xfail],

AS_HELP_STRING([--enable-dtls-xfail], [Only for gitlab CI. Do not use]))

AM_CONDITIONAL(DTLS_XFAIL, [test "$enable_dtls_xfail" = "yes" ])

AC_ARG_ENABLE([dsa-tests],

AS_HELP_STRING([--disable-dsa-tests], [Disable DSA keys in self-test]),

[], [enable_dsa_tests=yes])

AM_CONDITIONAL(TEST_DSA, [test "$enable_dsa_tests" = "yes"])

AM_CONDITIONAL(OPENCONNECT_GNUTLS, [ test "$ssl_library" = "GnuTLS" ])

AM_CONDITIONAL(OPENCONNECT_OPENSSL, [ test "$ssl_library" = "OpenSSL" ])

if test "$esp" != ""; then

AC_DEFINE(HAVE_ESP, 1, [Build with ESP support])

if test "$dtls" != ""; then

AC_DEFINE(HAVE_DTLS, 1, [Build with DTLS support])

fi

AC_ARG_WITH(lz4,

AS_HELP_STRING([--without-lz4], [disable support for LZ4 compression]),

test_for_lz4=$withval,

test_for_lz4=yes)

AC_SUBST(LIBLZ4_PC, liblz4)

AC_DEFINE([HAVE_LZ4], [], [LZ4 was found])

oldLIBS="$LIBS"

LIBS="$LIBS $LIBLZ4_LIBS"

oldCFLAGS="$CFLAGS"

CFLAGS="$CFLAGS $LIBLZ4_CFLAGS"

AC_MSG_CHECKING([for LZ4_compress_default()])

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <lz4.h>],[

LZ4_compress_default("", (char *)0, 0, 0);])],

[AC_MSG_RESULT(yes)

AC_DEFINE([HAVE_LZ4_COMPRESS_DEFAULT], [], [From LZ4 r129])

],

[AC_MSG_RESULT(no)])

LIBS="$oldLIBS"

CFLAGS="$oldCFLAGS"

],

[

AC_MSG_WARN([[

***

*** lz4 not found.

*** ]])

])

fi

# For some bizarre reason now that we use AM_ICONV, the mingw32 build doesn't

# manage to set EGREP properly in the created ./libtool script. Make sure it's

# found.

AC_PROG_EGREP

# Needs to happen after we default to static/shared libraries based on OpenSSL

AC_PROG_LIBTOOL

if test "$use_openbsd_libtool" = "true" && test -x /usr/bin/libtool; then

echo using OpenBSD libtool

LIBTOOL=/usr/bin/libtool

fi

AM_CONDITIONAL(OPENBSD_LIBTOOL, [ test "$use_openbsd_libtool" = "true" ])

[oldLIBS="$LIBS"

LIBS="$LIBS -lz"

AC_MSG_CHECKING([for zlib without pkg-config])

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include <zlib.h>],[

z_stream zs;

deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,

-12, 9, Z_DEFAULT_STRATEGY);])],

[AC_MSG_RESULT(yes)

AC_SUBST([ZLIB_LIBS], [-lz])

AC_SUBST([ZLIB_CFLAGS], [])],

[AC_MSG_RESULT(no)

AC_ERROR([Could not build against zlib])])

LIBS="$oldLIBS"])

AC_ARG_WITH([libproxy],

AS_HELP_STRING([--without-libproxy],

[Build without libproxy library [default=auto]]))

AS_IF([test "x$with_libproxy" != "xno"], [

PKG_CHECK_MODULES(LIBPROXY, libproxy-1.0,

[AC_SUBST(LIBPROXY_PC, libproxy-1.0)

libproxy_pkg=yes],

libproxy_pkg=no)

], [libproxy_pkg=disabled])

dnl Libproxy *can* exist without a .pc file, and its header may be called

dnl libproxy.h in that case.

if (test "$libproxy_pkg" = "no"); then

AC_MSG_CHECKING([for libproxy])

oldLIBS="$LIBS"

LIBS="$LIBS -lproxy"

AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <libproxy.h>],

[(void)px_proxy_factory_new();])],

[AC_MSG_RESULT(yes (with libproxy.h))

AC_DEFINE([LIBPROXY_HDR], ["libproxy.h"])

AC_SUBST([LIBPROXY_LIBS], [-lproxy])

libproxy_pkg=yes],

[AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <proxy.h>],

[(void)px_proxy_factory_new();])],

[AC_MSG_RESULT(yes (with proxy.h))

AC_DEFINE([LIBPROXY_HDR], ["proxy.h"])

AC_SUBST([LIBPROXY_LIBS], [-lproxy])

libproxy_pkg=yes],

[AC_MSG_RESULT(no)])])

LIBS="$oldLIBS"

fi

AC_ARG_WITH([stoken],

AS_HELP_STRING([--without-stoken],

[Build without libstoken library [default=auto]]))

AS_IF([test "x$with_stoken" != "xno"], [

PKG_CHECK_MODULES(LIBSTOKEN, stoken,

[AC_SUBST(LIBSTOKEN_PC, stoken)

libstoken_pkg=yes],

libstoken_pkg=no)

], [libstoken_pkg=disabled])

AC_ARG_WITH([libpcsclite],

AS_HELP_STRING([--without-libpcsclite],

[Build without libpcsclite library (for Yubikey support) [default=auto]]))

AS_IF([test "x$with_libpcsclite" != "xno"], [

if test "$system_pcsc_libs" != ""; then

AC_SUBST(LIBPCSCLITE_LIBS, "$system_pcsc_libs")

AC_SUBST(LIBPCSCLITE_CFLAGS, "$system_pcsc_cflags")

AC_SUBST(system_pcsc_libs)

libpcsclite_pkg=yes

else

PKG_CHECK_MODULES(LIBPCSCLITE, libpcsclite,

[AC_SUBST(LIBPCSCLITE_PC, libpcsclite)

libpcsclite_pkg=yes],

libpcsclite_pkg=no)

fi

if test "$libpcsclite_pkg" = "yes"; then

AC_DEFINE([HAVE_LIBPCSCLITE], 1, [Have libpcsclite])

fi

AM_CONDITIONAL(OPENCONNECT_LIBPCSCLITE, [test "$libpcsclite_pkg" = "yes"])

AC_ARG_WITH([libpskc],

AS_HELP_STRING([--without-libpskc],

[Build without libpskc library [default=auto]]))

AS_IF([test "x$with_libpskc" != "xno"], [

PKG_CHECK_MODULES(LIBPSKC, [libpskc >= 2.2.0],

[AC_SUBST(LIBPSKC_PC, libpskc)

AC_DEFINE([HAVE_LIBPSKC], 1, [Have libpskc])

libpskc_pkg=yes],

AC_ARG_WITH([gssapi],

AS_HELP_STRING([--without-gssapi],

[Build without GSSAPI support [default=auto]]))

AC_DEFUN([GSSAPI_CHECK_BUILD],[

gss_old_libs="$LIBS"

LIBS="$LIBS ${GSSAPI_LIBS}"

AC_MSG_CHECKING([GSSAPI compilation with "${GSSAPI_LIBS}"])

AC_LINK_IFELSE([AC_LANG_PROGRAM([

#include GSSAPI_HDR],[