configure.in

dnl configure.in for libd
dnl awiebe, april 2009

AC_INIT

AC_CONFIG_HEADER(include/setup.h)

AC_DEFINE(PACKAGE_NAME, "libd")
AC_DEFINE(PACKAGE_BUGREPORT, "coders@dal.net")
AC_DEFINE(PACKAGE_STRING, "Daemon library")
AC_DEFINE(PACKAGE_VERSION, "0.1")

# autoheader templates

AH_TEMPLATE([BROKEN_FD_SETSIZE],[If on a system with a broken FD_SETSIZE])
AH_TEMPLATE([HAVE_ENCRYPTION_ON],[If we support encryption])
AH_TEMPLATE([HAVE_COMPRESSION_ON],[If we support compression])
AH_TEMPLATE([SYS_ERRLIST_DECLARED],[If the sys_errlist array is defined])
AH_TEMPLATE([MAXCONNECTIONS],[Maximum Connections we allow])
AH_TEMPLATE([WRITEV_IOV],[Maxmimum number of iovecs supported by writev()])
AH_TEMPLATE([USE_SSL],[Defined if we want to compile in SSL support])

dnl Put our options of here for ease of reading.

AC_ARG_ENABLE(openssl,
[  --enable-openssl[=DIR]       Enable OpenSSL support (DIR optional).
  --disable-openssl            Disable OpenSSL support. ],
[ cf_enable_openssl=$enableval ],
[ cf_enable_openssl="auto" ])

AC_ARG_WITH(socketengine,
[  --with-socketengine=TYPE       Set the socketengine type.  Choices are:
                                kqueue epoll devpoll poll select ],
[ check_sengine=$withval ],
[ check_sengine="yes" ])

AC_ARG_WITH(maxconnections,
[  --with-maxconnections=NUMBER   Set the maximum number of sockets.],
[ check_maxconnections=$withval ],
[ check_maxconnections="auto" ])

DEBUG=yes

dnl
dnl load custom checks

builtin(include, ./m4/ax_gcc_x86_cpuid.m4)
builtin(include, ./m4/ax_gcc_archflag.m4)
builtin(include, ./m4/ax_compiler_vendor.m4)
builtin(include, ./m4/ax_check_compiler_flags.m4)
builtin(include, ./m4/ax_cflags_warn_all_ansi.m4)
builtin(include, ./m4/ax_cflags_strict_prototypes.m4)
builtin(include, ./m4/ax_cc_maxopt.m4)

dnl end custom checks load
dnl

dnl Checks!
AC_PROG_CC_C99
AX_CC_MAXOPT
AX_CFLAGS_STRICT_PROTOTYPES
AC_CANONICAL_SYSTEM
AX_CFLAGS_WARN_ALL_ANSI
AC_ISC_POSIX
AC_PROG_MAKE_SET
AC_PATH_PROG(RM, rm)
AC_PATH_PROG(CP, cp)
AC_PATH_PROG(MV, mv)
AC_PATH_PROG(SED, sed)
AC_PROG_INSTALL

dnl Replace `main' with a function in -lnsl:
AC_CHECK_LIB(socket, socket, zlib)
AC_CHECK_FUNC(crypt,, AC_CHECK_LIB(descrypt, crypt,,AC_CHECK_LIB(crypt, crypt,,)))

AC_HEADER_STDC
AC_CHECK_HEADERS([fcntl.h netinet/in.h stdlib.h string.h sys/socket.h sys/time.h unistd.h])
AC_C_CONST
AC_HEADER_TIME
AC_FUNC_ERROR_AT_LINE
AC_PROG_GCC_TRADITIONAL
AC_FUNC_MALLOC
AC_FUNC_SELECT_ARGTYPES
AC_CHECK_FUNCS([memset socket strerror])
AC_PROG_GCC_TRADITIONAL

dnl check for various OSes

case "$target" in
    *-solaris2*)
        solaris2="yes"
        AC_DEFINE_UNQUOTED(WRITEV_IOV, 16)
        ;;
    *-freebsd*)
        freebsd="yes"
        AC_DEFINE_UNQUOTED(WRITEV_IOV, 32)
        ;;
    *-netbsd*)
        AC_DEFINE_UNQUOTED(WRITEV_IOV, 32)
        ;;
    *-openbsd*)
        AC_DEFINE_UNQUOTED(WRITEV_IOV, 32)
        ;;
    *-linux*)
        linux="yes"
        AC_DEFINE_UNQUOTED(WRITEV_IOV, 32)
        ;;
    *-darwin*)
        AC_DEFINE_UNQUOTED(WRITEV_IOV, 32)
        ;;
esac

dnl Checks for loadable hook module support

dnl Check for sys_errlist
dnl Stolen from BitchX
AC_MSG_CHECKING(for sys_errlist declaration)
AC_TRY_RUN([
#include <sys/types.h>
#include <stdio.h>
#include <errno.h>
main()
{
  char *s = sys_errlist[0];
	  exit(0);
}
],
  AC_MSG_RESULT(yes)
  AC_DEFINE(SYS_ERRLIST_DECLARED),
  AC_MSG_RESULT(no), AC_MSG_RESULT(cross compiling))

dnl Openssl checks - combination of our old way and the hybrid7 method

save_LIBS="$LIBS"

AC_MSG_CHECKING(for OpenSSL)

if test "X$cf_enable_openssl" != "Xno" ; then
  cf_openssl_basedir=""
  if test "X$cf_enable_openssl" != "Xauto" &&
     test "X$cf_enable_openssl" != "Xyes"; then
     dnl Support for --enable-openssl=/some/place
     cf_openssl_basedir="${cf_enable_openssl}"
  else
    dnl Do the auto-probe here.  Check some common directory paths.
    for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
                /opt /opt/openssl /usr/local/openssl ; do
      if test -f "${dirs}/include/openssl/opensslv.h" ; then
        cf_openssl_basedir="${dirs}"
        break
      fi
    done
    unset dirs
  fi
  dnl Now check cf_openssl_found to see if we found anything.
  if test "X$cf_openssl_basedir" != "X" ; then
    if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h" ; then
      SSL_INCLUDES="-I${cf_openssl_basedir}/include"
      SSL_LIBS="-L${cf_openssl_basedir}/lib"
    else
      dnl OpenSSL wasn't found in the directory specified.  Naughty
      dnl administrator...
      cf_openssl_basedir=""
    fi
  else
    dnl Check for stock FreeBSD 4.x and 5.x systems, since their files
    dnl are in /usr/include and /usr/lib.  In this case, we don't want to
    dnl change INCLUDES or LIBS, but still want to enable OpenSSL.
    dnl We can't do this check above, because some people want two versions
    dnl of OpenSSL installed (stock FreeBSD 4.x/5.x and /usr/local/ssl)
    dnl and they want /usr/local/ssl to have preference.
    if test -f "/usr/include/openssl/opensslv.h" ; then
      cf_openssl_basedir="/usr"
    fi
  fi
  dnl If we have a basedir defined, then everything is okay.  Otherwise,
  dnl we have a problem.
  if test "X$cf_openssl_basedir" != "X" ; then
    LIBS="$save_LIBS $SSL_LIBS -lssl"
    AC_MSG_RESULT($cf_openssl_basedir)
    cf_enable_openssl="yes"
    encryption="enabled"
    AC_DEFINE(USE_SSL)
  else
    AC_MSG_RESULT(not found.  Please check your path.)
    cf_enable_openssl="no"
    encryption="disabled"
  fi
  unset cf_openssl_basedir
else
  dnl If --disable-openssl was specified
  encryption="disabled"
  AC_MSG_RESULT(disabled)
fi

unset save_LIBS

dnl end of openssl library test

dnl once we add epoll and /dev/poll support, these will be
dnl updated with the appropriate checks

if test "$check_sengine" = "yes"; then
    engine="select"
    if test "$freebsd" = "yes"; then
        AC_CHECK_FUNC(kevent, [ engine="kqueue" ], )
    elif test "$solaris2" = "yes"; then
        engine="poll"
        AC_CHECK_HEADER(sys/devpoll.h, engine="devpoll", )
    elif test "$linux" = "yes"; then
        AC_CHECK_FUNC(poll, [ engine="poll" ], )
        AC_CHECK_HEADER(sys/epoll.h, HAVE_EPOLL_H=yes, HAVE_EPOLL_H=no)
        AC_CHECK_LIB(epoll, epoll_create, 
            [LIBS="$LIBS -lepoll"; have_epoll_lib="yes"; engine="epoll"], 
            have_epoll_lib="no")
        if test "$HAVE_EPOLL_H $have_epoll_lib" = "yes no"; then
            AC_MSG_CHECKING(for epoll_create [without -lepoll])
            AC_TRY_RUN([
                    #include <stdint.h>
                    #include <sys/epoll.h>
                    #include <errno.h>
                    
                    #include <asm/unistd.h>
                    
                    int main(int argc, char **argv) { return epoll_create(5) < 1; }
                    ], 
                    have_epoll_lib="yes", have_epoll_lib="no")
            AC_MSG_RESULT($have_epoll_lib)
        fi
        if test "$HAVE_EPOLL_H $have_epoll_lib" = "yes yes"; then
            engine="epoll";
        fi
    else
        AC_CHECK_FUNC(poll, [ engine="poll"], )
    fi
elif test "$check_sengine" = "kqueue"; then
    AC_CHECK_FUNC(kevent, [ engine="kqueue" ], )
    if test "X$engine" = "X"; then
        AC_MSG_NOTICE()
        AC_MSG_NOTICE(kqueue not supported on this platform!)
        AC_MSG_ERROR()
    fi
    AC_MSG_NOTICE(setting socketengine type to kqueue)
elif test "$check_sengine" = "poll"; then
    AC_CHECK_FUNC(poll, [ engine="poll" ], )
    if test "X$engine" = "X"; then
        AC_MSG_NOTICE()
        AC_MSG_NOTICE(poll not supported on this platform!)
        AC_MSG_ERROR()
    fi
    AC_MSG_NOTICE(setting socketengine type to poll)
elif test "$check_sengine" = "devpoll"; then
    AC_CHECK_HEADER(sys/devpoll.h, engine="devpoll", )
    if test "X$engine" = "X"; then
        AC_MSG_NOTICE()
        AC_MSG_NOTICE(/dev/poll not supported on this system)
        AC_MSG_ERROR()
    fi
    AC_MSG_NOTICE(setting socketengine to devpoll)
elif test "$check_sengine" = "epoll"; then
    AC_CHECK_HEADER(sys/epoll.h, HAVE_EPOLL_H=yes, HAVE_EPOLL_H=no)
    AC_CHECK_LIB(epoll, epoll_create, 
        [LIBS="$LIBS -lepoll"; have_epoll_lib="yes"; engine="epoll"], 
        have_epoll_lib="no")
    if test "$HAVE_EPOLL_H $have_epoll_lib" = "yes no"; then
        AC_MSG_CHECKING(for epoll_create [without -lepoll])
        AC_TRY_RUN([
                #include <stdint.h>
                #include <sys/epoll.h>
                #include <errno.h>
                 
                #include <asm/unistd.h>
                 
                int main(int argc, char **argv) { return epoll_create(5) < 1; }
                ], 
                have_epoll_lib="yes", have_epoll_lib="no")
        AC_MSG_RESULT($have_epoll_lib)
    fi
    if test "$HAVE_EPOLL_H $have_epoll_lib" != "yes yes"; then
        AC_MSG_NOTICE()
        AC_MSG_ERROR(epoll is not supported on this machine)
        AC_MSG_ERROR()
    fi
    AC_MSG_NOTICE(setting socketengine type to epoll)
    engine="epoll";
elif test "$check_sengine" = "select"; then
    AC_MSG_NOTICE(setting socketengine type to select.. for some stupid reason)
    engine="select"
else
    AC_MSG_NOTICE()
    AC_MSG_NOTICE(socket engine type incorrect!)
    AC_MSG_ERROR()
fi

SENGINE="socketengine_$engine.c"

dnl Check to see if we have a broken FD_SETSIZE
if test $engine = "select"; then
    AC_MSG_CHECKING(to see if FD_SETSIZE is broken)
    AC_TRY_RUN([
    #define FD_SETSIZE 666
    #include <sys/types.h>
    #include <sys/time.h>

    int main()
    {
        if(FD_SETSIZE != 666)
            exit(1);
        exit(0);
    }
    ],
    AC_MSG_RESULT(no),
    [
    AC_MSG_RESULT(YES)
    AC_MSG_WARN(FD_SETSIZE is hard set by your operating system)
    AC_MSG_WARN(MAXCONNECTIONS must be no higher than the hardwired FD_SETSIZE)
    AC_DEFINE(BROKEN_FD_SETSIZE)
    broken_fd_setsize="yes"
    ],
    AC_MSG_RESULT(can't tell))
fi

if test "$check_maxconnections" = "auto"; then

    AC_MSG_CHECKING(Maximum file descriptors);
    AC_CACHE_VAL(maxconnections,
[

AC_LANG_CONFTEST(
   [AC_LANG_SOURCE([[
    #include <sys/types.h>
    #include <sys/time.h>
    #include <sys/resource.h>
    #include <stdio.h>
    #ifdef RLIMIT_FDMAX
    #define RLIMIT_FD_MAX   RLIMIT_FDMAX
    #else
    #ifdef RLIMIT_NOFILE
    #define RLIMIT_FD_MAX RLIMIT_NOFILE
    #else
    #ifdef RLIMIT_OPEN_MAX
    #define RLIMIT_FD_MAX RLIMIT_OPEN_MAX
    #else
    #undef RLIMIT_FD_MAX
    #endif
    #endif
    #endif


    int main()
    {
    #ifndef BROKEN_FD_SETSIZE

    #ifdef RLIMIT_FD_MAX
        struct rlimit limit;
        
        if(!getrlimit(RLIMIT_FD_MAX, &limit))
        {
            if(limit.rlim_max > 32768)
                printf("32768");
            else
                printf("%ld", (long) limit.rlim_max);
        }
        else
    #endif
            printf("256");

    #else
        printf("%d", FD_SETSIZE);
    #endif
        return 0;
    }
   ]])
])

    $CC -o conftest conftest.c >/dev/null 2>&1
    maxconnections=`./conftest`
    AC_MSG_RESULT($maxconnections)
    $RM -f conftest conftest.c
])
    AC_DEFINE_UNQUOTED(MAXCONNECTIONS, ${maxconnections})

else
    maxconnections=$check_maxconnections
    AC_DEFINE_UNQUOTED(MAXCONNECTIONS, ${maxconnections})
fi

# zlib test
# ripped from http://autoconf-archive.cryp.to/check_zlib.html
#
ZLIB_HOME=/usr/local
if test ! -f "${ZLIB_HOME}/include/zlib.h"
then
        ZLIB_HOME=/usr
fi
if test -n "${ZLIB_HOME}"
then
        ZLIB_OLD_LDFLAGS=$LDFLAGS
        ZLIB_OLD_CPPFLAGS=$LDFLAGS
        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
        AC_LANG_SAVE
        AC_LANG_C
        AC_CHECK_LIB(z, inflateEnd, [zlib_cv_libz=yes], [zlib_cv_libz=no])
        AC_CHECK_HEADER(zlib.h, [zlib_cv_zlib_h=yes], [zlib_cv_zlib_h=no])
        AC_LANG_RESTORE
        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
        then
                #
                # If both library and header were found, use them
                #
                AC_CHECK_LIB(z, inflateEnd)
                AC_MSG_CHECKING(zlib in ${ZLIB_HOME})
                AC_MSG_RESULT(ok)
        else
                #
                # If either header or library was not found, revert and bomb
                #
                AC_MSG_CHECKING(zlib in ${ZLIB_HOME})
                LDFLAGS="$ZLIB_OLD_LDFLAGS"
                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
                AC_MSG_RESULT(failed)
                AC_MSG_ERROR(either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib)
        fi
fi

if test "$engine" = "select" && test "$broken_fd_setsize" != "yes"; then
	CFLAGS="$CFLAGS -DUSE_SELECT -DFD_SETSIZE=$maxconnections"
elif test "$engine" = "select"; then
	CFLAGS="$CFLAGS -DUSE_SELECT"
elif test "$engine" = "poll"; then
	CFLAGS="$CFLAGS -DUSE_POLL"
elif test "$engine" = "epoll"; then
	CFLAGS="$CFLAGS -DUSE_EPOLL"
elif test "$engine" = "kqueue"; then
	CFLAGS="$CFLAGS -DUSE_KQUEUE"
elif test "$engine" = "devpoll"; then
	CFLAGS="$CFLAGS -DUSE_DEVPOLL"
fi

INSTALL_DIR="${prefix}"

AC_SUBST(SSL_INCLUDES)
AC_SUBST(SSL_LIBS)
AC_SUBST(LIBS)
AC_SUBST(SENGINE)
AC_SUBST(INSTALL_DIR)

AC_OUTPUT(src/Makefile)

echo ""
echo "      *********** libd configuration **********"
echo "      System Build Type:              $target"
echo "      Socket Engine Type:             $engine"
echo "      Encryption:                     $encryption"
echo "      Maximum Connections:            $maxconnections"
echo "      Install Directory:              $prefix"
echo "      CFLAGS:                         $CFLAGS"
echo "      CPPFLAGS:                       $CPPFLAGS"
echo "      LDFLAGS:                        $LDFLAGS"
echo ""