AC_PREREQ(2.63)

AC_COPYRIGHT([Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009

Massachusetts Institute of Technology.

])

dnl

define([K5_TOPDIR],[.])dnl

dnl

AC_DEFUN(V5_SET_TOPDIR,[dnl

ac_reltopdir="K5_TOPDIR"

if test ! -r "$srcdir/K5_TOPDIR/aclocal.m4"; then

  AC_MSG_ERROR([Configure could not determine the relative topdir])

fi

ac_topdir=$srcdir/$ac_reltopdir

ac_config_fragdir=$ac_reltopdir/config

# echo "Looking for $srcdir/$ac_config_fragdir"

if test -d "$srcdir/$ac_config_fragdir"; then

  AC_CONFIG_AUX_DIR(K5_TOPDIR/config)

else

  AC_MSG_ERROR([can not find config/ directory in $ac_reltopdir])

fi

])dnl

dnl

dnl Version info.

dnl

pushdef([x],esyscmd([sed -n 's/#define \([A-Z0-9_]*\)[ \t]*\(.*\)/\1=\2/p' < ]K5_TOPDIR/patchlevel.h))

define([PL_KRB5_MAJOR_RELEASE],regexp(x,[KRB5_MAJOR_RELEASE=\(.*\)],[\1]))

ifelse(PL_KRB5_MAJOR_RELEASE,,[errprint([Can't determine KRB5_MAJOR_RELEASE value from patchlevel.h.

]) m4exit(1) dnl sometimes that does not work?

builtin(m4exit,1)])

define([PL_KRB5_MINOR_RELEASE],regexp(x,[KRB5_MINOR_RELEASE=\(.*\)],[\1]))

ifelse(PL_KRB5_MINOR_RELEASE,,[errprint([Can't determine KRB5_MINOR_RELEASE value from patchlevel.h.

]) m4exit(1) dnl sometimes that does not work?

builtin(m4exit,1)])

define([PL_KRB5_PATCHLEVEL],regexp(x,[KRB5_PATCHLEVEL=\(.*\)],[\1]))

ifelse(PL_KRB5_PATCHLEVEL,,[errprint([Can't determine KRB5_PATCHLEVEL value from patchlevel.h.

]) m4exit(1) dnl sometimes that does not work?

builtin(m4exit,1)])

define([PL_KRB5_RELTAIL],regexp(x,[KRB5_RELTAIL="\(.*\)"],[\1]))

dnl RELTAIL is allowed to not be defined.

popdef([x])

define([K5_VERSION],PL_KRB5_MAJOR_RELEASE.PL_KRB5_MINOR_RELEASE[]ifelse(PL_KRB5_PATCHLEVEL,0,,.PL_KRB5_PATCHLEVEL)ifelse(PL_KRB5_RELTAIL,,,-PL_KRB5_RELTAIL))

define([K5_BUGADDR],krb5-bugs@mit.edu)

define([K5_AC_INIT],[AC_INIT(Kerberos 5, K5_VERSION, K5_BUGADDR, krb5)

AC_CONFIG_SRCDIR($1)

build_dynobj=no])

dnl

dnl drop in standard rules for all configure files -- CONFIG_RULES

dnl

AC_DEFUN(CONFIG_RULES,[dnl

AC_REQUIRE([V5_SET_TOPDIR]) dnl

EXTRA_FILES=""

AC_SUBST(EXTRA_FILES)

dnl Consider using AC_USE_SYSTEM_EXTENSIONS when we require autoconf

dnl 2.59c or later, but be sure to test on Solaris first.

AC_DEFINE([_GNU_SOURCE], 1, [Define to enable extensions in glibc])

AC_DEFINE([__STDC_WANT_LIB_EXT1__], 1, [Define to enable C11 extensions])

WITH_CC dnl

AC_REQUIRE_CPP

if test -z "$LD" ; then LD=$CC; fi

AC_ARG_VAR(LD,[linker command [CC]])

AC_SUBST(LDFLAGS) dnl

KRB5_AC_CHOOSE_ET dnl

KRB5_AC_CHOOSE_SS dnl

KRB5_AC_CHOOSE_DB dnl

dnl allow stuff in tree to access deprecated stuff for now

dnl AC_DEFINE([KRB5_DEPRECATED], 1, [Define only if building in-tree])

AC_C_CONST dnl

WITH_NETLIB dnl

WITH_HESIOD dnl

KRB5_AC_MAINTAINER_MODE dnl

AC_ARG_PROGRAM dnl

dnl

dnl This identifies the top of the source tree relative to the directory 

dnl in which the configure file lives.

dnl

CONFIG_RELTOPDIR=$ac_reltopdir

AC_SUBST(CONFIG_RELTOPDIR)

lib_frag=$srcdir/$ac_config_fragdir/lib.in

AC_SUBST_FILE(lib_frag)

libobj_frag=$srcdir/$ac_config_fragdir/libobj.in

AC_SUBST_FILE(libobj_frag)

libnover_frag=$srcdir/$ac_config_fragdir/libnover.in

AC_SUBST_FILE(libnover_frag)

libpriv_frag=$srcdir/$ac_config_fragdir/libpriv.in

AC_SUBST_FILE(libpriv_frag)

libnodeps_frag=$srcdir/$ac_config_fragdir/libnodeps.in

AC_SUBST_FILE(libnodeps_frag)

dnl

KRB5_AC_PRAGMA_WEAK_REF

WITH_LDAP

KRB5_LIB_PARAMS

KRB5_AC_INITFINI

KRB5_AC_ENABLE_THREADS

KRB5_AC_FIND_DLOPEN

])dnl

dnl Maintainer mode, akin to what automake provides, 'cept we don't

dnl want to use automake right now.

AC_DEFUN([KRB5_AC_MAINTAINER_MODE],

[AC_ARG_ENABLE([maintainer-mode],

AC_HELP_STRING([--enable-maintainer-mode],[enable rebuilding of source files, Makefiles, etc]),

USE_MAINTAINER_MODE=$enableval,

USE_MAINTAINER_MODE=no)

if test "$USE_MAINTAINER_MODE" = yes; then

  MAINTAINER_MODE_TRUE=

  MAINTAINER_MODE_FALSE='#'

  AC_MSG_NOTICE(enabling maintainer mode)

else

  MAINTAINER_MODE_TRUE='#'

  MAINTAINER_MODE_FALSE=

fi

MAINT=$MAINTAINER_MODE_TRUE

AC_SUBST(MAINTAINER_MODE_TRUE)

AC_SUBST(MAINTAINER_MODE_FALSE)

AC_SUBST(MAINT)

])

dnl

AC_DEFUN([KRB5_AC_INITFINI],[

dnl Do we want initialization at load time?

AC_ARG_ENABLE([delayed-initialization],

AC_HELP_STRING([--disable-delayed-initialization],initialize library code when loaded @<:@delay until first use@:>@), , enable_delayed_initialization=yes)

case "$enable_delayed_initialization" in

  yes)

    AC_DEFINE(DELAY_INITIALIZER,1,[Define if library initialization should be delayed until first use]) ;;

  no) ;;

  *)  AC_MSG_ERROR(invalid option $enable_delayed_initialization for delayed-initialization) ;;

esac

dnl We always want finalization at unload time.

dnl

dnl Can we do things through gcc?

KRB5_AC_GCC_ATTRS

dnl How about with the linker?

if test -z "$use_linker_init_option" ; then

  AC_MSG_ERROR(ran INITFINI before checking shlib.conf?)

fi

if test "$use_linker_init_option" = yes; then

  AC_DEFINE(USE_LINKER_INIT_OPTION,1,[Define if link-time options for library initialization will be used])

fi

if test "$use_linker_fini_option" = yes; then

  AC_DEFINE(USE_LINKER_FINI_OPTION,1,[Define if link-time options for library finalization will be used])

fi

])

dnl find dlopen

AC_DEFUN([KRB5_AC_FIND_DLOPEN],[

old_LIBS="$LIBS"

DL_LIB=

AC_SEARCH_LIBS(dlopen, dl, [

if test "$ac_cv_search_dlopen" != "none required"; then

  DL_LIB=$ac_cv_search_dlopen

fi

LIBS="$old_LIBS"

AC_DEFINE(USE_DLOPEN,1,[Define if dlopen should be used])])

AC_SUBST(DL_LIB)

])

dnl Hack for now.

AC_DEFUN([KRB5_AC_ENABLE_THREADS],[

AC_ARG_ENABLE([thread-support],

AC_HELP_STRING([--disable-thread-support],don't enable thread support @<:@enabled@:>@), , enable_thread_support=yes)

if test "$enable_thread_support" = yes ; then

  AC_MSG_NOTICE(enabling thread support)

  AC_DEFINE(ENABLE_THREADS,1,[Define if thread support enabled])

fi

dnl Maybe this should be inside the conditional above?  Doesn't cache....

if test "$enable_thread_support" = yes; then

  AX_PTHREAD(,[AC_MSG_ERROR([cannot determine options for enabling thread support; try --disable-thread-support])])

  AC_MSG_NOTICE(PTHREAD_CC = $PTHREAD_CC)

  AC_MSG_NOTICE(PTHREAD_CFLAGS = $PTHREAD_CFLAGS)

  AC_MSG_NOTICE(PTHREAD_LIBS = $PTHREAD_LIBS)

  dnl Not really needed -- if pthread.h isn't found, ACX_PTHREAD will fail.

  dnl AC_CHECK_HEADERS(pthread.h)

  # AIX and Tru64 don't support weak references, and don't have

  # stub versions of the pthread code in libc.

  case "${host_os}" in

    aix* | osf*)

      # On these platforms, we'll always pull in the thread support.

      LIBS="$LIBS $PTHREAD_LIBS"

      CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

      # We don't need to sometimes add the flags we've just folded in...

      PTHREAD_LIBS=

      PTHREAD_CFLAGS=

      ;;

    hpux*)

      # These are the flags that "gcc -pthread" adds.  But we don't

      # want "-pthread" because that has link-time effects, and we

      # don't exclude CFLAGS when linking.  *sigh*

      PTHREAD_CFLAGS="-D_REENTRANT -D_THREAD_SAFE -D_POSIX_C_SOURCE=199506L"

      ;;

    solaris2.[[1-9]])

      # On Solaris 10 with gcc 3.4.3, the autoconf archive macro doesn't

      # get the right result.   XXX What about Solaris 9 and earlier?

      if test "$GCC" = yes ; then

        PTHREAD_CFLAGS="-D_REENTRANT -pthreads"

      fi

      ;;

    solaris*)

      # On Solaris 10 with gcc 3.4.3, the autoconf archive macro doesn't

      # get the right result.

      if test "$GCC" = yes ; then

        PTHREAD_CFLAGS="-D_REENTRANT -pthreads"

      fi

      # On Solaris 10, the thread support is always available in libc.

      AC_DEFINE(NO_WEAK_PTHREADS,1,[Define if references to pthread routines should be non-weak.])

      ;;

  esac

  THREAD_SUPPORT=1

else

  PTHREAD_CC="$CC"

  PTHREAD_CFLAGS=""

  PTHREAD_LIBS=""

  THREAD_SUPPORT=0

fi

AC_SUBST(THREAD_SUPPORT)

dnl We want to know where these routines live, so on systems with weak

dnl reference support we can figure out whether or not the pthread library

dnl has been linked in.

dnl If we don't add any libraries for thread support, don't bother.

AC_CHECK_FUNCS(pthread_once pthread_rwlock_init)

old_CC="$CC"

test "$PTHREAD_CC" != "" && test "$ac_cv_c_compiler_gnu" = no && CC=$PTHREAD_CC

old_CFLAGS="$CFLAGS"

# On Solaris, -pthreads is added to CFLAGS, no extra explicit libraries.

CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

AC_SUBST(PTHREAD_CFLAGS)

old_LIBS="$LIBS"

LIBS="$PTHREAD_LIBS $LIBS"

AC_MSG_NOTICE(rechecking with PTHREAD_... options)

AC_CHECK_LIB(c, pthread_rwlock_init,

  [AC_DEFINE(HAVE_PTHREAD_RWLOCK_INIT_IN_THREAD_LIB,1,[Define if pthread_rwlock_init is provided in the thread library.])])

LIBS="$old_LIBS"

CC="$old_CC"

CFLAGS="$old_CFLAGS"

])

dnl This is somewhat gross and should go away when the build system

dnl is revamped. -- tlyu

dnl DECLARE_SYS_ERRLIST - check for sys_errlist in libc

dnl

AC_DEFUN([DECLARE_SYS_ERRLIST],

[AC_CACHE_CHECK([for sys_errlist declaration], krb5_cv_decl_sys_errlist,

[AC_TRY_COMPILE([#include <stdio.h>

#include <errno.h>], [1+sys_nerr;],

krb5_cv_decl_sys_errlist=yes, krb5_cv_decl_sys_errlist=no)])

# assume sys_nerr won't be declared w/o being in libc

if test $krb5_cv_decl_sys_errlist = yes; then

  AC_DEFINE(SYS_ERRLIST_DECLARED,1,[Define if sys_errlist is defined in errno.h])

  AC_DEFINE(HAVE_SYS_ERRLIST,1,[Define if sys_errlist in libc])

else

  # This means that sys_errlist is not declared in errno.h, but may still

  # be in libc.

  AC_CACHE_CHECK([for sys_errlist in libc], krb5_cv_var_sys_errlist,

  [AC_TRY_LINK([extern int sys_nerr;], [if (1+sys_nerr < 0) return 1;],

  krb5_cv_var_sys_errlist=yes, krb5_cv_var_sys_errlist=no;)])

  if test $krb5_cv_var_sys_errlist = yes; then

    AC_DEFINE(HAVE_SYS_ERRLIST,1,[Define if sys_errlist in libc])

    # Do this cruft for backwards compatibility for now.

    AC_DEFINE(NEED_SYS_ERRLIST,1,[Define if need to declare sys_errlist])

  else

    AC_MSG_WARN([sys_errlist is neither in errno.h nor in libc])

  fi

fi])

dnl

dnl check for sigmask/sigprocmask -- CHECK_SIGPROCMASK

dnl

AC_DEFUN(CHECK_SIGPROCMASK,[

AC_MSG_CHECKING([for use of sigprocmask])

AC_CACHE_VAL(krb5_cv_func_sigprocmask_use,

[AC_TRY_LINK([#include <signal.h>], [sigprocmask(SIG_SETMASK,0,0);],

 krb5_cv_func_sigprocmask_use=yes,

AC_TRY_LINK([#include <signal.h>], [sigmask(1);], 

 krb5_cv_func_sigprocmask_use=no, krb5_cv_func_sigprocmask_use=yes))])

AC_MSG_RESULT($krb5_cv_func_sigprocmask_use)

if test $krb5_cv_func_sigprocmask_use = yes; then

 AC_DEFINE(USE_SIGPROCMASK,1,[Define if sigprocmask should be used])

fi

])dnl

dnl

AC_DEFUN(AC_PROG_ARCHIVE, [AC_CHECK_PROG(ARCHIVE, ar, ar cqv, false)])dnl

AC_DEFUN(AC_PROG_ARCHIVE_ADD, [AC_CHECK_PROG(ARADD, ar, ar cruv, false)])dnl

dnl

dnl check for <dirent.h> -- CHECK_DIRENT

dnl (may need to be more complex later)

dnl

AC_DEFUN(CHECK_DIRENT,[

AC_CHECK_HEADER(dirent.h,AC_DEFINE(USE_DIRENT_H,1,[Define if you have dirent.h functionality]))])dnl

dnl

dnl check if union wait is defined, or if WAIT_USES_INT -- CHECK_WAIT_TYPE

dnl

AC_DEFUN(CHECK_WAIT_TYPE,[

AC_MSG_CHECKING([if argument to wait is int *])

AC_CACHE_VAL(krb5_cv_struct_wait,

dnl Test for prototype clash - if there is none - then assume int * works

[AC_TRY_COMPILE([#include <sys/types.h>

#include <sys/wait.h>

extern pid_t wait(int *);],[], krb5_cv_struct_wait=no,dnl

dnl Else fallback on old stuff

[AC_TRY_COMPILE(

[#include <sys/wait.h>], [union wait i;

#ifdef WEXITSTATUS

  WEXITSTATUS (i);

#endif

], 

	krb5_cv_struct_wait=yes, krb5_cv_struct_wait=no)])])

AC_MSG_RESULT($krb5_cv_struct_wait)

if test $krb5_cv_struct_wait = no; then

	AC_DEFINE(WAIT_USES_INT,1,[Define if wait takes int as a argument])

fi

])dnl

dnl

dnl check for POSIX signal handling -- CHECK_SIGNALS

dnl

AC_DEFUN(CHECK_SIGNALS,[

AC_CHECK_FUNC(sigprocmask,

AC_MSG_CHECKING(for sigset_t and POSIX_SIGNALS)

AC_CACHE_VAL(krb5_cv_type_sigset_t,

[AC_TRY_COMPILE(

[#include <signal.h>],

[sigset_t x],

krb5_cv_type_sigset_t=yes, krb5_cv_type_sigset_t=no)])

AC_MSG_RESULT($krb5_cv_type_sigset_t)

if test $krb5_cv_type_sigset_t = yes; then

  AC_DEFINE(POSIX_SIGNALS,1,[Define if POSIX signal handling is used])

fi

)])dnl

dnl

dnl check for signal type

dnl

dnl AC_RETSIGTYPE isn't quite right, but almost.

AC_DEFUN(KRB5_SIGTYPE,[

AC_MSG_CHECKING([POSIX signal handlers])

AC_CACHE_VAL(krb5_cv_has_posix_signals,

[AC_TRY_COMPILE(

[#include <sys/types.h>

#include <signal.h>

#ifdef signal

#undef signal

#endif

extern void (*signal ()) ();], [],

krb5_cv_has_posix_signals=yes, krb5_cv_has_posix_signals=no)])

AC_MSG_RESULT($krb5_cv_has_posix_signals)

if test $krb5_cv_has_posix_signals = yes; then

   stype=void

   AC_DEFINE(POSIX_SIGTYPE, 1, [Define if POSIX signal handlers are used])

else

  if test $ac_cv_type_signal = void; then

     stype=void

  else

     stype=int

  fi

fi

AC_DEFINE_UNQUOTED(krb5_sigtype, $stype, [Define krb5_sigtype to type of signal handler])dnl

])dnl

dnl

dnl check for POSIX setjmp/longjmp -- CHECK_SETJMP

dnl

AC_DEFUN(CHECK_SETJMP,[

AC_CHECK_FUNC(sigsetjmp,

AC_MSG_CHECKING(for sigjmp_buf)

AC_CACHE_VAL(krb5_cv_struct_sigjmp_buf,

[AC_TRY_COMPILE(

[#include <setjmp.h>],[sigjmp_buf x],

krb5_cv_struct_sigjmp_buf=yes,krb5_cv_struct_sigjmp_buf=no)])

AC_MSG_RESULT($krb5_cv_struct_sigjmp_buf)

if test $krb5_cv_struct_sigjmp_buf = yes; then

  AC_DEFINE(POSIX_SETJMP,1,[Define if setjmp indicates POSIX interface])

fi

)])dnl

dnl

dnl Check for IPv6 compile-time support.

dnl

AC_DEFUN(KRB5_AC_INET6,[

AC_CHECK_HEADERS(sys/types.h sys/socket.h netinet/in.h netdb.h)

AC_CHECK_FUNCS(inet_ntop inet_pton getnameinfo)

dnl getaddrinfo test needs netdb.h, for proper compilation on alpha

dnl under OSF/1^H^H^H^H^HDigital^H^H^H^H^H^H^HTru64 UNIX, where it's

dnl a macro

AC_MSG_CHECKING(for getaddrinfo)

AC_CACHE_VAL(ac_cv_func_getaddrinfo,

[AC_TRY_LINK([#ifdef HAVE_NETDB_H

#include <netdb.h>

#endif],[

struct addrinfo *ai;

getaddrinfo("kerberos.mit.edu", "echo", 0, &ai;;

], ac_cv_func_getaddrinfo=yes, ac_cv_func_getaddrinfo=no)])

AC_MSG_RESULT($ac_cv_func_getaddrinfo)

if test $ac_cv_func_getaddrinfo = yes; then

  AC_DEFINE(HAVE_GETADDRINFO,1,[Define if you have the getaddrinfo function])

fi

dnl

AC_REQUIRE([KRB5_SOCKADDR_SA_LEN])dnl

AC_MSG_CHECKING(for IPv6 compile-time support without -DINET6)

AC_CACHE_VAL(krb5_cv_inet6,[

if test "$ac_cv_func_inet_ntop" != "yes" ; then

  krb5_cv_inet6=no

else

AC_TRY_COMPILE([

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

],[

  struct sockaddr_in6 in;

  AF_INET6;

  IN6_IS_ADDR_LINKLOCAL (&in.sin6_addr);

],krb5_cv_inet6=yes,krb5_cv_inet6=no)])

fi

AC_MSG_RESULT($krb5_cv_inet6)

if test "$krb5_cv_inet6" = no && test "$ac_cv_func_inet_ntop" = yes; then

AC_MSG_CHECKING(for IPv6 compile-time support with -DINET6)

AC_CACHE_VAL(krb5_cv_inet6_with_dinet6,[

old_CC="$CC"

CC="$CC -DINET6"

AC_TRY_COMPILE([

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

],[

  struct sockaddr_in6 in;

  AF_INET6;

  IN6_IS_ADDR_LINKLOCAL (&in.sin6_addr);

],krb5_cv_inet6_with_dinet6=yes,krb5_cv_inet6_with_dinet6=no)

CC="$old_CC"])

AC_MSG_RESULT($krb5_cv_inet6_with_dinet6)

fi

if test $krb5_cv_inet6 = yes || test "$krb5_cv_inet6_with_dinet6" = yes; then

  if test "$krb5_cv_inet6_with_dinet6" = yes; then

    AC_DEFINE(INET6,1,[May need to be defined to enable IPv6 support, for example on IRIX])

  fi

fi

])dnl

dnl

AC_DEFUN(KRB5_AC_CHECK_FOR_CFLAGS,[

AC_BEFORE([$0],[AC_PROG_CC])

AC_BEFORE([$0],[AC_PROG_CXX])

krb5_ac_cflags_set=${CFLAGS+set}

krb5_ac_cxxflags_set=${CXXFLAGS+set}

krb5_ac_warn_cflags_set=${WARN_CFLAGS+set}

krb5_ac_warn_cxxflags_set=${WARN_CXXFLAGS+set}

])

dnl

AC_DEFUN(TRY_WARN_CC_FLAG_1,[dnl

  cachevar=`echo "krb5_cv_cc_flag_$1" | sed -e s/=/_eq_/g -e s/-/_dash_/g -e s/[[^a-zA-Z0-9_]]/_/g`

  AC_CACHE_CHECK([if C compiler supports $1], [$cachevar],

  [# first try without, then with

  AC_TRY_COMPILE([], 1;,

    [old_cflags="$CFLAGS"

     CFLAGS="$CFLAGS $cflags_warning_test_flags $1"

     AC_TRY_COMPILE([], 1;, eval $cachevar=yes, eval $cachevar=no)

     CFLAGS="$old_cflags"],

    [AC_MSG_ERROR(compiling simple test program with $CFLAGS failed)])])

  if eval test '"${'$cachevar'}"' = yes; then

    WARN_CFLAGS="$WARN_CFLAGS $1"

  fi

  eval flag_supported='${'$cachevar'}'

])dnl

dnl

dnl Are additional flags needed to make unsupported warning options

dnl get reported as errors?

AC_DEFUN(CHECK_CC_WARNING_TEST_FLAGS,[dnl

  cflags_warning_test_flags=

  TRY_WARN_CC_FLAG_1(-Werror=unknown-warning-option)

  if test $flag_supported = yes; then

    cflags_warning_test_flags=-Werror=unknown-warning-option

  fi

])dnl

dnl

AC_DEFUN(TRY_WARN_CC_FLAG,[dnl

AC_REQUIRE([CHECK_CC_WARNING_TEST_FLAGS])dnl

TRY_WARN_CC_FLAG_1($1)dnl

])dnl

dnl

AC_DEFUN(WITH_CC,[dnl

AC_REQUIRE([KRB5_AC_CHECK_FOR_CFLAGS])dnl

AC_REQUIRE([AC_PROG_CC])dnl

AC_REQUIRE([AC_PROG_CXX])dnl

if test $ac_cv_c_compiler_gnu = yes ; then

     HAVE_GCC=yes

     else HAVE_GCC=

fi

AC_SUBST(HAVE_GCC)

AC_CACHE_CHECK([for GNU linker], krb5_cv_prog_gnu_ld,

[krb5_cv_prog_gnu_ld=no

if test "$GCC" = yes; then

  if AC_TRY_COMMAND([$CC -Wl,-v 2>&1 dnl

			| grep "GNU ld" > /dev/null]); then

    krb5_cv_prog_gnu_ld=yes

  fi

fi])

AC_ARG_WITH([size-optimizations],

[  --with-size-optimizations enable a few optimizations to reduce code size

                          possibly at some run-time cost],

,

withval=no)

if test "$withval" = yes; then

  AC_DEFINE(CONFIG_SMALL,1,[Define to reduce code size even if it means more cpu usage])

fi

# -Wno-long-long, if needed, for k5-platform.h without inttypes.h etc.

extra_gcc_warn_opts="-Wall -Wcast-align -Wshadow"

# -Wmissing-prototypes

if test "$GCC" = yes ; then

  # Putting this here means we get -Os after -O2, which works.

  if test "$with_size_optimizations" = yes && test "x$krb5_ac_cflags_set" != xset; then

    AC_MSG_NOTICE(adding -Os optimization option)

    case "$CFLAGS" in

      "-g -O2") CFLAGS="-g -Os" ;;

      "-O2")    CFLAGS="-Os" ;;

      *)        CFLAGS="$CFLAGS -Os" ;;

    esac

  fi

  if test "x$krb5_ac_warn_cflags_set" = xset ; then

    AC_MSG_NOTICE(not adding extra gcc warning flags because WARN_CFLAGS was set)

  else

    AC_MSG_NOTICE(adding extra warning flags for gcc)

    WARN_CFLAGS="$WARN_CFLAGS $extra_gcc_warn_opts -Wmissing-prototypes"

    if test "`uname -s`" = Darwin ; then

      AC_MSG_NOTICE(skipping pedantic warnings on Darwin)

    elif test "`uname -s`" = Linux ; then

      AC_MSG_NOTICE(skipping pedantic warnings on Linux)

    else

      WARN_CFLAGS="$WARN_CFLAGS -pedantic"

    fi

    if test "$ac_cv_cxx_compiler_gnu" = yes; then

      if test "x$krb5_ac_warn_cxxflags_set" = xset ; then

        AC_MSG_NOTICE(not adding extra g++ warnings because WARN_CXXFLAGS was set)

      else

        AC_MSG_NOTICE(adding extra warning flags for g++)

        WARN_CXXFLAGS="$WARN_CXXFLAGS $extra_gcc_warn_opts"

      fi

    fi

    # Currently, G++ does not support -Wno-format-zero-length.

    TRY_WARN_CC_FLAG(-Wno-format-zero-length)

    # Other flags here may not be supported on some versions of

    # gcc that people want to use.

    for flag in overflow strict-overflow missing-format-attribute missing-prototypes return-type missing-braces parentheses switch unused-function unused-label unused-variable unused-value unknown-pragmas sign-compare newline-eof error=uninitialized no-maybe-uninitialized error=pointer-arith error=int-conversion error=incompatible-pointer-types error=discarded-qualifiers error=implicit-int ; do

      TRY_WARN_CC_FLAG(-W$flag)

    done

    #  old-style-definition? generates many, many warnings

    #

    # Warnings that we'd like to turn into errors on versions of gcc

    # that support promoting only specific warnings to errors, but

    # we'll take as warnings on older compilers.  (If such a warning

    # is added after the -Werror=foo feature, you can just put

    # error=foo in the above list, and skip the test for the

    # warning-only form.)  At least in some versions, -Werror= doesn't

    # seem to make the conditions actual errors, but still issues

    # warnings; I guess we'll take what we can get.

    #

    # We're currently targeting C89+, not C99, so disallow some

    # constructs.

    for flag in declaration-after-statement ; do

      TRY_WARN_CC_FLAG(-Werror=$flag)

      if test "$flag_supported" = no; then

        TRY_WARN_CC_FLAG(-W$flag)

      fi

    done

    # We require function declarations now.

    #

    # In some compiler versions -- e.g., "gcc version 4.2.1 (Apple

    # Inc. build 5664)" -- the -Werror- option works, but the -Werror=

    # version doesn't cause implicitly declared functions to be

    # flagged as errors.  If neither works, -Wall implies

    # -Wimplicit-function-declaration so don't bother.

    TRY_WARN_CC_FLAG(-Werror-implicit-function-declaration)

    if test "implicit-function-declaration_supported" = no; then

      TRY_WARN_CC_FLAG(-Werror=implicit-function-declaration)

    fi

    #

  fi

  if test "`uname -s`" = Darwin ; then

    # Someday this should be a feature test.

    # One current (Jaguar = OS 10.2) problem:

    # Archive library with foo.o undef sym X and bar.o common sym X,

    # if foo.o is pulled in at link time, bar.o may not be, causing

    # the linker to complain.

    # Dynamic library problems too?

    case "$CC $CFLAGS" in

    *-fcommon*) ;; # why someone would do this, I don't know

    *-fno-common*) ;; # okay, they're already doing the right thing

    *)

      AC_MSG_NOTICE(disabling the use of common storage on Darwin)

      CFLAGS="$CFLAGS -fno-common"

      ;;

    esac

    case "$LD $LDFLAGS" in

    *-Wl,-search_paths_first*) ;;

    *) LDFLAGS="${LDFLAGS} -Wl,-search_paths_first" ;;

    esac

  fi

else

  if test "`uname -s`" = AIX ; then

    # Using AIX but not GCC, assume native compiler.

    # The native compiler appears not to give a nonzero exit

    # status for certain classes of errors, like missing arguments

    # in function calls.  Let's try to fix that with -qhalt=e.

    case "$CC $CFLAGS" in

      *-qhalt=*) ;;

      *)

	CFLAGS="$CFLAGS -qhalt=e"

	AC_MSG_NOTICE(adding -qhalt=e for better error reporting)

	;;

    esac

    # Also, the optimizer isn't turned on by default, which means

    # the static inline functions get left in random object files,

    # leading to references to pthread_mutex_lock from anything that

    # includes k5-int.h whether it uses threads or not.

    case "$CC $CFLAGS" in

      *-O*) ;;

      *)

	CFLAGS="$CFLAGS -O"

	AC_MSG_NOTICE(adding -O for inline thread-support function elimination)

	;;

    esac

  fi

  if test "`uname -s`" = SunOS ; then

    # Using Solaris but not GCC, assume Sunsoft compiler.

    # We have some error-out-on-warning options available.

    # Sunsoft 12 compiler defaults to -xc99=all, it appears, so "inline"

    # works, but it also means that declaration-in-code warnings won't

    # be issued.

    # -v -fd -errwarn=E_DECLARATION_IN_CODE ...

    if test "x$krb5_ac_warn_cflags_set" = xset ; then

      AC_MSG_NOTICE(not adding extra warning flags because WARN_CFLAGS was set)

    else

      WARN_CFLAGS="-errtags=yes -errwarn=E_BAD_PTR_INT_COMBINATION,E_BAD_PTR_INT_COMB_ARG,E_PTR_TO_VOID_IN_ARITHMETIC,E_NO_IMPLICIT_DECL_ALLOWED,E_ATTRIBUTE_PARAM_UNDEFINED"

    fi

    if test "x$krb5_ac_warn_cxxflags_set" = xset ; then

      AC_MSG_NOTICE(not adding extra warning flags because WARN_CXXFLAGS was set)

    else

      WARN_CXXFLAGS="-errtags=yes +w +w2 -xport64"

    fi

  fi

fi

AC_SUBST(WARN_CFLAGS)

AC_SUBST(WARN_CXXFLAGS)

])dnl

dnl

dnl

dnl check for yylineno -- HAVE_YYLINENO

dnl

AC_DEFUN(HAVE_YYLINENO,[dnl

AC_REQUIRE_CPP()AC_REQUIRE([AC_PROG_LEX])dnl

AC_MSG_CHECKING([for yylineno declaration])

AC_CACHE_VAL(krb5_cv_type_yylineno,

# some systems have yylineno, others don't...

  echo '%%

%%' | ${LEX} -t > conftest.out

  if egrep yylineno conftest.out >/dev/null 2>&1; then

	krb5_cv_type_yylineno=yes

  else

	krb5_cv_type_yylineno=no

  fi

  rm -f conftest.out)

  AC_MSG_RESULT($krb5_cv_type_yylineno)

  if test $krb5_cv_type_yylineno = no; then

	AC_DEFINE(NO_YYLINENO, 1, [Define if lex produes code with yylineno])

  fi

])dnl

dnl

dnl K5_GEN_MAKEFILE([dir, [frags]])

dnl

AC_DEFUN(K5_GEN_MAKEFILE,[dnl

ifelse($1, ,[_K5_GEN_MAKEFILE(.,$2)],[_K5_GEN_MAKEFILE($1,$2)])

])

dnl

dnl _K5_GEN_MAKEFILE(dir, [frags])

dnl  dir must be present in this case

dnl  Note: Be careful in quoting. 

dnl        The ac_foreach generates the list of fragments to include

dnl        or "" if $2 is empty

AC_DEFUN(_K5_GEN_MAKEFILE,[dnl

AC_CONFIG_FILES([$1/Makefile:$srcdir/]K5_TOPDIR[/config/pre.in:$1/Makefile.in:$1/deps:$srcdir/]K5_TOPDIR[/config/post.in])

])

dnl

dnl K5_GEN_FILE( <ac_output arguments> )

dnl

AC_DEFUN(K5_GEN_FILE,[AC_CONFIG_FILES($1)])dnl

dnl

dnl K5_AC_OUTPUT

dnl    Note: Adds the variables to config.status for individual 

dnl          Makefile generation from config.status

AC_DEFUN(K5_AC_OUTPUT,[AC_OUTPUT])dnl

dnl

dnl V5_AC_OUTPUT_MAKEFILE

dnl

AC_DEFUN(V5_AC_OUTPUT_MAKEFILE,

[ifelse($1, , [_V5_AC_OUTPUT_MAKEFILE(.,$2)],[_V5_AC_OUTPUT_MAKEFILE($1,$2)])])

dnl

define(_V5_AC_OUTPUT_MAKEFILE,

[ifelse($2, , ,AC_CONFIG_FILES($2))

AC_FOREACH([DIR], [$1],dnl

 [AC_CONFIG_FILES(DIR[/Makefile:$srcdir/]K5_TOPDIR[/config/pre.in:]DIR[/Makefile.in:]DIR[/deps:$srcdir/]K5_TOPDIR[/config/post.in])])

K5_AC_OUTPUT])dnl

dnl

dnl

dnl KRB5_SOCKADDR_SA_LEN: define HAVE_SA_LEN if sockaddr contains the sa_len

dnl component

dnl

AC_DEFUN([KRB5_SOCKADDR_SA_LEN],[ dnl

AC_CHECK_MEMBER(struct sockaddr.sa_len,

  AC_DEFINE(HAVE_SA_LEN,1,[Define if struct sockaddr contains sa_len])

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

#include <sys/socket.h>])])

dnl

dnl WITH_NETLIB

dnl 

dnl

AC_DEFUN(WITH_NETLIB,[

AC_ARG_WITH([netlib],

AC_HELP_STRING([--with-netlib=LIBS], use user defined resolver library),

[  if test "$withval" = yes -o "$withval" = no ; then

	AC_MSG_RESULT("netlib will link with C library resolver only")

  else

	LIBS="$LIBS $withval"

	AC_MSG_RESULT("netlib will use \'$withval\'")

  fi

],dnl

[AC_LIBRARY_NET]

)])dnl

dnl

dnl

AC_DEFUN(KRB5_AC_NEED_DAEMON, [

KRB5_NEED_PROTO([#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif],daemon,1)])dnl

dnl

dnl KRB5_AC_NEED_LIBGEN --- check if libgen needs to be linked in for

dnl 				compile/step	

dnl

dnl

AC_DEFUN(KRB5_AC_NEED_LIBGEN,[

AC_REQUIRE([AC_PROG_CC])dnl

dnl

dnl regcomp is present but non-functional on Solaris 2.4

dnl

AC_MSG_CHECKING(for working regcomp)

AC_CACHE_VAL(ac_cv_func_regcomp,[

AC_TRY_RUN([

#include <sys/types.h>

#include <regex.h>

regex_t x; regmatch_t m;

int main() { return regcomp(&x,"pat.*",0) || regexec(&x,"pattern",1,&m,0); }

], ac_cv_func_regcomp=yes, ac_cv_func_regcomp=no, AC_MSG_ERROR([Cannot test regcomp when cross compiling]))])

AC_MSG_RESULT($ac_cv_func_regcomp)

test $ac_cv_func_regcomp = yes && AC_DEFINE(HAVE_REGCOMP,1,[Define if regcomp exists and functions])

dnl

dnl Check for the compile and step functions - only if regcomp is not available

dnl

if test $ac_cv_func_regcomp = no; then

 save_LIBS="$LIBS"

 LIBS=-lgen

dnl this will fail if there's no compile/step in -lgen, or if there's

dnl no -lgen.  This is fine.

 AC_CHECK_FUNCS(compile step)

 LIBS="$save_LIBS"

dnl

dnl Set GEN_LIB if necessary 

dnl

 AC_CHECK_LIB(gen, compile, GEN_LIB=-lgen, GEN_LIB=)

 AC_SUBST(GEN_LIB)

fi

])

dnl

dnl KRB5_AC_REGEX_FUNCS --- check for different regular expression 

dnl				support functions

dnl

AC_DEFUN(KRB5_AC_REGEX_FUNCS,[

AC_CHECK_FUNCS(re_comp re_exec regexec)

AC_REQUIRE([KRB5_AC_NEED_LIBGEN])dnl

])dnl

dnl

dnl AC_KRB5_TCL_FIND_CONFIG (uses tcl_dir)

dnl

AC_DEFUN(AC_KRB5_TCL_FIND_CONFIG,[

AC_REQUIRE([KRB5_LIB_AUX])dnl

AC_MSG_CHECKING(for tclConfig.sh)

dnl On Debian, we might be given --with-tcl=/usr, or tclsh might

dnl point us to /usr/lib/tcl8.4; either way, we need to find

dnl /usr/lib/tcl8.4/tclConfig.sh.

dnl On NetBSD, we might be given --with-tcl=/usr/pkg, or tclsh

dnl might point us to /usr/pkg/lib/tcl8.4; we need to find

dnl /usr/pkg/lib/tclConfig.sh.

if test -r "$tcl_dir/lib/tclConfig.sh" ; then

  tcl_conf="$tcl_dir/lib/tclConfig.sh"

elif test -r "$tcl_dir/tclConfig.sh" ; then

  tcl_conf="$tcl_dir/tclConfig.sh"

elif test -r "$tcl_dir/../tclConfig.sh" ; then

  tcl_conf="$tcl_dir/../tclConfig.sh"

else

  tcl_conf=

  lib="$tcl_dir/lib"

  changequote(<<,>>)dnl

  for d in "$lib" "$lib"/tcl7.[0-9] "$lib"/tcl8.[0-9] ; do

    if test -r "$d/tclConfig.sh" ; then

      tcl_conf="$tcl_conf $d/tclConfig.sh"

    fi

  done

  changequote([,])dnl

fi

if test -n "$tcl_conf" ; then

  AC_MSG_RESULT($tcl_conf)

else

  AC_MSG_RESULT(not found)

fi

tcl_ok_conf=

tcl_vers_maj=

tcl_vers_min=

old_CPPFLAGS=$CPPFLAGS

old_LIBS=$LIBS

old_LDFLAGS=$LDFLAGS

if test -n "$tcl_conf" ; then

  for file in $tcl_conf ; do

    TCL_MAJOR_VERSION=x ; TCL_MINOR_VERSION=x

    AC_MSG_CHECKING(Tcl info in $file)

    . $file

    v=$TCL_MAJOR_VERSION.$TCL_MINOR_VERSION

    if test -z "$tcl_vers_maj" \

	|| test "$tcl_vers_maj" -lt "$TCL_MAJOR_VERSION" \

	|| test "$tcl_vers_maj" = "$TCL_MAJOR_VERSION" -a "$tcl_vers_min" -lt "$TCL_MINOR_VERSION" ; then

      for incdir in "$TCL_PREFIX/include/tcl$v" "$TCL_PREFIX/include" ; do

	if test -r "$incdir/tcl.h" -o -r "$incdir/tcl/tcl.h" ; then

	  CPPFLAGS="$old_CPPFLAGS -I$incdir"

	  break

	fi

      done

      LIBS="$old_LIBS `eval echo x $TCL_LIB_SPEC $TCL_LIBS | sed 's/^x//'`"

      LDFLAGS="$old_LDFLAGS $TCL_LD_FLAGS"

      AC_TRY_LINK( , [Tcl_CreateInterp ();],

	tcl_ok_conf=$file

	tcl_vers_maj=$TCL_MAJOR_VERSION

	tcl_vers_min=$TCL_MINOR_VERSION

	AC_MSG_RESULT($v - working),

	AC_MSG_RESULT($v - compilation failed)

      )

    else

      AC_MSG_RESULT(older version $v)

    fi

  done

fi

CPPFLAGS=$old_CPPFLAGS

LIBS=$old_LIBS

LDFLAGS=$old_LDFLAGS

tcl_header=no

tcl_lib=no

if test -n "$tcl_ok_conf" ; then

  . $tcl_ok_conf

  TCL_INCLUDES=

  for incdir in "$TCL_PREFIX/include/tcl$v" "$TCL_PREFIX/include" ; do

    if test -r "$incdir/tcl.h" -o -r "$incdir/tcl/tcl.h" ; then

      if test "$incdir" != "/usr/include" ; then

        TCL_INCLUDES=-I$incdir

      fi

      break

    fi

  done

  # Need eval because the first-level expansion could reference

  # variables like ${TCL_DBGX}.

  eval TCL_LIBS='"'$TCL_LIB_SPEC $TCL_LIBS $TCL_DL_LIBS'"'

  TCL_LIBPATH="-L$TCL_EXEC_PREFIX/lib"

  TCL_RPATH=":$TCL_EXEC_PREFIX/lib"

  if test "$DEPLIBEXT" != "$SHLIBEXT" && test -n "$RPATH_FLAG"; then

    TCL_MAYBE_RPATH='$(RPATH_FLAG)'"$TCL_EXEC_PREFIX/lib$RPATH_TAIL"

  else

    TCL_MAYBE_RPATH=

  fi

  CPPFLAGS="$old_CPPFLAGS $TCL_INCLUDES"

  AC_CHECK_HEADER(tcl.h,AC_DEFINE(HAVE_TCL_H,1,[Define if tcl.h is available]) tcl_header=yes)

  if test $tcl_header=no; then

     AC_CHECK_HEADER(tcl/tcl.h,AC_DEFINE(HAVE_TCL_TCL_H,1,[Define if tcl/tcl.h is available]) tcl_header=yes)

  fi