Edit

kc3-lang/libevent/configure.in

Branch :

  • Show log

    Commit

  • Author : Nick Mathewson
    Date : 2009-11-04 20:17:32
    Hash : 47bad8ab
    Message : Implement size limits on HTTP header length and body length. Patch from Constantine Verutin, simplified a little. svn:r1500

  • configure.in
  • dnl configure.in for libevent
    dnl Dug Song <dugsong@monkey.org>
    AC_PREREQ(2.59c)
    AC_INIT(event.c)
    
    AC_CONFIG_MACRO_DIR([m4])
    
    AM_INIT_AUTOMAKE(libevent,2.0.2-alpha)
    AM_CONFIG_HEADER(config.h)
    AC_DEFINE(NUMERIC_VERSION, 0x02000201, [Numeric representation of the version])
    
    dnl Initialize prefix.
    if test "$prefix" = "NONE"; then
       prefix="/usr/local"
    fi
    
    dnl Checks for programs.
    AC_PROG_CC
    AC_PROG_INSTALL
    AC_PROG_LN_S
    
    AC_PROG_GCC_TRADITIONAL
    if test "$GCC" = yes ; then
            # Enable many gcc warnings by default...
            CFLAGS="$CFLAGS -Wall"
    	# And disable the strict-aliasing optimization, since it breaks
    	# our sockaddr-handling code in strange ways.
    	CFLAGS="$CFLAGS -fno-strict-aliasing"
    fi
    
    AC_ARG_ENABLE(gcc-warnings,
         AS_HELP_STRING(--enable-gcc-warnings, enable verbose warnings with GCC))
    AC_ARG_ENABLE(thread-support,
         AS_HELP_STRING(--enable-thread-support, enable support for threading),
    	[], [enable_thread_support=yes])
    AC_ARG_ENABLE(malloc-replacement,
         AS_HELP_STRING(--disable-malloc-replacement, disable support for replacing the memory mgt functions),
            [], [enable_malloc_replacement=yes])
    AC_ARG_ENABLE(openssl,
         AS_HELP_STRING(--disable-openssl, disable support for openssl encryption),
            [], [enable_openssl=yes])
    
    AC_PROG_LIBTOOL
    
    dnl   Uncomment "AC_DISABLE_SHARED" to make shared librraries not get
    dnl   built by default.  You can also turn shared libs on and off from 
    dnl   the command line with --enable-shared and --disable-shared.
    dnl AC_DISABLE_SHARED
    AC_SUBST(LIBTOOL_DEPS)
    
    dnl Checks for libraries.
    AC_SEARCH_LIBS([inet_ntoa], [nsl])
    AC_SEARCH_LIBS([socket], [socket])
    AC_SEARCH_LIBS([inet_aton], [resolv])
    AC_SEARCH_LIBS([clock_gettime], [rt])
    AC_SEARCH_LIBS([sendfile], [sendfile])
    
    dnl Determine if we have zlib for regression tests
    dnl Don't put this one in LIBS
    save_LIBS="$LIBS"
    LIBS=""
    ZLIB_LIBS=""
    have_zlib=no
    AC_SEARCH_LIBS([inflateEnd], [z],
    	[have_zlib=yes
    	ZLIB_LIBS="$LIBS"
    	AC_DEFINE(HAVE_LIBZ, 1, [Define if the system has zlib])])
    LIBS="$save_LIBS"
    AC_SUBST(ZLIB_LIBS)
    AM_CONDITIONAL(ZLIB_REGRESS, [test "$have_zlib" = "yes"])
    
    dnl See if we have openssl.  This doesn't go in LIBS either.
    save_LIBS="$LIBS"
    LIBS=""
    OPENSSL_LIBS=""
    have_openssl=no
    AC_SEARCH_LIBS([SSL_new], [ssl],
    		[have_openssl=yes
    	        OPENSSL_LIBS="$LIBS"
    		AC_DEFINE(HAVE_OPENSSL, 1, [Define if the system has openssl])])
    LIBS="$save_LIBS"
    AC_SUBST(OPENSSL_LIBS)
    
    dnl Checks for header files.
    AC_HEADER_STDC
    AC_CHECK_HEADERS(fcntl.h stdarg.h inttypes.h stdint.h stddef.h poll.h unistd.h sys/epoll.h sys/time.h sys/queue.h sys/event.h sys/param.h sys/ioctl.h sys/select.h sys/devpoll.h port.h netinet/in.h netinet/in6.h sys/socket.h sys/uio.h arpa/inet.h sys/eventfd.h sys/mman.h sys/sendfile.h netdb.h)
    if test "x$ac_cv_header_sys_queue_h" = "xyes"; then
    	AC_MSG_CHECKING(for TAILQ_FOREACH in sys/queue.h)
    	AC_EGREP_CPP(yes,
    [
    #include <sys/queue.h>
    #ifdef TAILQ_FOREACH
     yes
    #endif
    ],	[AC_MSG_RESULT(yes)
    	 AC_DEFINE(HAVE_TAILQFOREACH, 1,
    		[Define if TAILQ_FOREACH is defined in <sys/queue.h>])],
    	AC_MSG_RESULT(no)
    	)
    fi
    
    if test "x$ac_cv_header_sys_time_h" = "xyes"; then
    	AC_MSG_CHECKING(for timeradd in sys/time.h)
    	AC_EGREP_CPP(yes,
    [
    #include <sys/time.h>
    #ifdef timeradd
     yes
    #endif
    ],	[ AC_DEFINE(HAVE_TIMERADD, 1,
    		[Define if timeradd is defined in <sys/time.h>])
    	  AC_MSG_RESULT(yes)] ,AC_MSG_RESULT(no)
    )
    fi
    
    if test "x$ac_cv_header_sys_time_h" = "xyes"; then
    	AC_MSG_CHECKING(for timercmp in sys/time.h)
    	AC_EGREP_CPP(yes,
    [
    #include <sys/time.h>
    #ifdef timercmp
     yes
    #endif
    ],	[ AC_DEFINE(HAVE_TIMERCMP, 1,
    		[Define if timercmp is defined in <sys/time.h>])
    	  AC_MSG_RESULT(yes)] ,AC_MSG_RESULT(no)
    )
    fi
    
    if test "x$ac_cv_header_sys_time_h" = "xyes"; then
    	AC_MSG_CHECKING(for timerclear in sys/time.h)
    	AC_EGREP_CPP(yes,
    [
    #include <sys/time.h>
    #ifdef timerclear
     yes
    #endif
    ],	[ AC_DEFINE(HAVE_TIMERCLEAR, 1,
    		[Define if timerclear is defined in <sys/time.h>])
    	  AC_MSG_RESULT(yes)] ,AC_MSG_RESULT(no)
    )
    fi
    
    if test "x$ac_cv_header_sys_time_h" = "xyes"; then
    	AC_MSG_CHECKING(for timerisset in sys/time.h)
    	AC_EGREP_CPP(yes,
    [
    #include <sys/time.h>
    #ifdef timerisset
     yes
    #endif
    ],	[ AC_DEFINE(HAVE_TIMERISSET, 1,
    		[Define if timerisset is defined in <sys/time.h>])
    	  AC_MSG_RESULT(yes)] ,AC_MSG_RESULT(no)
    )
    fi
    
    dnl - check if the macro WIN32 is defined on this compiler.
    dnl - (this is how we check for a windows version of GCC)
    AC_MSG_CHECKING(for WIN32)
    AC_TRY_COMPILE(,
    	[
    #ifndef WIN32
    die horribly
    #endif
    	],
    	bwin32=true; AC_MSG_RESULT(yes),
    	bwin32=false; AC_MSG_RESULT(no),
    )
    
    AM_CONDITIONAL(BUILD_WIN32, test x$bwin32 = xtrue)
    
    dnl Checks for typedefs, structures, and compiler characteristics.
    AC_C_CONST
    AC_C_INLINE
    AC_HEADER_TIME
    
    dnl Checks for library functions.
    AC_CHECK_FUNCS(gettimeofday vasprintf fcntl clock_gettime strtok_r strsep getaddrinfo getnameinfo strlcpy inet_ntop inet_pton signal sigaction strtoll inet_aton pipe eventfd sendfile mmap splice)
    
    AC_CHECK_SIZEOF(long)
    
    if test "x$ac_cv_func_clock_gettime" = "xyes"; then
       AC_DEFINE(DNS_USE_CPU_CLOCK_FOR_ID, 1, [Define if clock_gettime is available in libc])
    else
       AC_DEFINE(DNS_USE_GETTIMEOFDAY_FOR_ID, 1, [Define is no secure id variant is available])
    fi
    
    AC_MSG_CHECKING(for F_SETFD in fcntl.h)
    AC_EGREP_CPP(yes,
    [
    #define _GNU_SOURCE
    #include <fcntl.h>
    #ifdef F_SETFD
    yes
    #endif
    ],	[ AC_DEFINE(HAVE_SETFD, 1,
    	      [Define if F_SETFD is defined in <fcntl.h>])
    	  AC_MSG_RESULT(yes) ], AC_MSG_RESULT(no))
    
    needsignal=no
    haveselect=no
    AC_CHECK_FUNCS(select, [haveselect=yes], )
    if test "x$haveselect" = "xyes" ; then
    	AC_LIBOBJ(select)
    	needsignal=yes
    fi
    
    havepoll=no
    AC_CHECK_FUNCS(poll, [havepoll=yes], )
    if test "x$havepoll" = "xyes" ; then
    	AC_LIBOBJ(poll)
    	needsignal=yes
    fi
    
    haveepoll=no
    AC_CHECK_FUNCS(epoll_ctl, [haveepoll=yes], )
    if test "x$haveepoll" = "xyes" ; then
    	AC_DEFINE(HAVE_EPOLL, 1,
    		[Define if your system supports the epoll system calls])
    	AC_LIBOBJ(epoll)
    	needsignal=yes
    fi
    
    havedevpoll=no
    if test "x$ac_cv_header_sys_devpoll_h" = "xyes"; then
    	AC_DEFINE(HAVE_DEVPOLL, 1,
    		    [Define if /dev/poll is available])
            AC_LIBOBJ(devpoll)
    fi
    
    havekqueue=no
    if test "x$ac_cv_header_sys_event_h" = "xyes"; then
    	AC_CHECK_FUNCS(kqueue, [havekqueue=yes], )
    	if test "x$havekqueue" = "xyes" ; then
    		AC_MSG_CHECKING(for working kqueue)
    		AC_TRY_RUN(
    #include <sys/types.h>
    #include <sys/time.h>
    #include <sys/event.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <fcntl.h>
    
    int
    main(int argc, char **argv)
    {
    	int kq;
    	int n;
    	int fd[[2]];
    	struct kevent ev;
    	struct timespec ts;
    	char buf[[8000]];
    
    	if (pipe(fd) == -1)
    		exit(1);
    	if (fcntl(fd[[1]], F_SETFL, O_NONBLOCK) == -1)
    		exit(1);
    
    	while ((n = write(fd[[1]], buf, sizeof(buf))) == sizeof(buf))
    		;
    
            if ((kq = kqueue()) == -1)
    		exit(1);
    
    	ev.ident = fd[[1]];
    	ev.filter = EVFILT_WRITE;
    	ev.flags = EV_ADD | EV_ENABLE;
    	n = kevent(kq, &ev, 1, NULL, 0, NULL);
    	if (n == -1)
    		exit(1);
    	
    	read(fd[[0]], buf, sizeof(buf));
    
    	ts.tv_sec = 0;
    	ts.tv_nsec = 0;
    	n = kevent(kq, NULL, 0, &ev, 1, &ts);
    	if (n == -1 || n == 0)
    		exit(1);
    
    	exit(0);
    }, [AC_MSG_RESULT(yes)
        AC_DEFINE(HAVE_WORKING_KQUEUE, 1,
    		[Define if kqueue works correctly with pipes])
        AC_LIBOBJ(kqueue)], AC_MSG_RESULT(no), AC_MSG_RESULT(no))
    	fi
    fi
    
    haveepollsyscall=no
    if test "x$ac_cv_header_sys_epoll_h" = "xyes"; then
    	if test "x$haveepoll" = "xno" ; then
    		AC_MSG_CHECKING(for epoll system call)
    		AC_TRY_RUN(
    #include <stdint.h>
    #include <sys/param.h>
    #include <sys/types.h>
    #include <sys/syscall.h>
    #include <sys/epoll.h>
    #include <unistd.h>
    
    int
    epoll_create(int size)
    {
    	return (syscall(__NR_epoll_create, size));
    }
    
    int
    main(int argc, char **argv)
    {
    	int epfd;
    
    	epfd = epoll_create(256);
    	exit (epfd == -1 ? 1 : 0);
    }, [AC_MSG_RESULT(yes)
        AC_DEFINE(HAVE_EPOLL, 1,
    	[Define if your system supports the epoll system calls])
        needsignal=yes
        AC_LIBOBJ(epoll_sub)
        AC_LIBOBJ(epoll)], AC_MSG_RESULT(no), AC_MSG_RESULT(no))
    	fi
    fi
    
    haveeventports=no
    AC_CHECK_FUNCS(port_create, [haveeventports=yes], )
    if test "x$haveeventports" = "xyes" ; then
    	AC_DEFINE(HAVE_EVENT_PORTS, 1,
    		[Define if your system supports event ports])
    	AC_LIBOBJ(evport)
    	needsignal=yes
    fi
    if test "x$bwin32" = "xtrue"; then
    	needsignal=yes
    fi
    if test "x$bwin32" = "xtrue"; then
    	needsignal=yes
    fi
    if test "x$needsignal" = "xyes" ; then
    	AC_LIBOBJ(signal)
    fi
    
    AC_TYPE_PID_T
    AC_TYPE_SIZE_T
    AC_TYPE_SSIZE_T
    
    AC_CHECK_TYPES([uint64_t, uint32_t, uint16_t, uint8_t], , ,
    [#ifdef HAVE_STDINT_H
    #include <stdint.h>
    #elif defined(HAVE_INTTYPES_H)
    #include <inttypes.h>
    #endif
    #ifdef HAVE_SYS_TYPES_H
    #include <sys/types.h>
    #endif])
    
    AC_CHECK_TYPES([fd_mask], , ,
    [#ifdef HAVE_SYS_TYPES_H
    #include <sys/types.h>
    #endif
    #ifdef HAVE_SELECT_H
    #include <select.h>
    #endif])
    
    AC_CHECK_SIZEOF(long long)
    AC_CHECK_SIZEOF(long)
    AC_CHECK_SIZEOF(int)
    AC_CHECK_SIZEOF(short)
    AC_CHECK_SIZEOF(size_t)
    
    AC_CHECK_TYPES([struct in6_addr, struct sockaddr_in6, sa_family_t], , ,
    [#include <sys/types.h>
    #ifdef HAVE_NETINET_IN_H
    #include <netinet/in.h>
    #endif
    #ifdef HAVE_NETINET_IN6_H
    #include <netinet/in6.h>
    #endif
    #ifdef HAVE_SYS_SOCKET_H
    #include <sys/socket.h>
    #endif
    #ifdef WIN32
    #define WIN32_WINNT 0x400
    #define _WIN32_WINNT 0x400
    #define WIN32_LEAN_AND_MEAN
    #if defined(_MSC_VER) && (_MSC_VER < 1300)
    #include <winsock.h>
    #else
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #endif
    #endif
    ])
    AC_CHECK_MEMBERS([struct in6_addr.s6_addr32, struct in6_addr.s6_addr16, struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len], , ,
    [#include <sys/types.h>
    #ifdef HAVE_NETINET_IN_H
    #include <netinet/in.h>
    #endif
    #ifdef HAVE_NETINET_IN6_H
    #include <netinet/in6.h>
    #endif
    #ifdef HAVE_SYS_SOCKET_H
    #include <sys/socket.h>
    #endif
    #ifdef WIN32
    #define WIN32_WINNT 0x400
    #define _WIN32_WINNT 0x400
    #define WIN32_LEAN_AND_MEAN
    #if defined(_MSC_VER) && (_MSC_VER < 1300)
    #include <winsock.h>
    #else
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #endif
    #endif
    ])
    
    AC_MSG_CHECKING([for socklen_t])
    AC_TRY_COMPILE([
     #include <sys/types.h>
     #include <sys/socket.h>],
      [socklen_t x;],
      AC_MSG_RESULT([yes]),
      [AC_MSG_RESULT([no])
      AC_DEFINE(socklen_t, unsigned int,
    	[Define to unsigned int if you dont have it])]
    )
    
    AC_MSG_CHECKING([whether our compiler supports __func__])
    AC_TRY_COMPILE([],
     [ const char *cp = __func__; ],
     AC_MSG_RESULT([yes]),
     AC_MSG_RESULT([no])
     AC_MSG_CHECKING([whether our compiler supports __FUNCTION__])
     AC_TRY_COMPILE([],
       [ const char *cp = __FUNCTION__; ],
       AC_MSG_RESULT([yes])
       AC_DEFINE(__func__, __FUNCTION__,
             [Define to appropriate substitue if compiler doesnt have __func__]),
       AC_MSG_RESULT([no])
       AC_DEFINE(__func__, __FILE__,
             [Define to appropriate substitue if compiler doesnt have __func__])))
    
    
    # check if we can compile with pthreads
    have_pthreads=no
    ACX_PTHREAD([
    	AC_DEFINE(HAVE_PTHREADS, 1,
    		[Define if we have pthreads on this system])
    	have_pthreads=yes])
    AM_CONDITIONAL(PTHREADS, [test "$have_pthreads" != "no" && test "$enable_thread_support" != "no"])
    
    # check if we should compile locking into the library
    if test x$enable_thread_support = xno; then
       AC_DEFINE(DISABLE_THREAD_SUPPORT, 1,
    	[Define if libevent should not be compiled with thread support])
    fi
    
    # check if we should hard-code the mm functions.
    if test x$enable_malloc_replacement = xno; then
      AC_DEFINE(DISABLE_MM_REPLACEMENT, 1,
            [Define if libevent should not allow replacing the mm functions])
    fi
    
    # check if we have and should use openssl
    AM_CONDITIONAL(OPENSSL, [test "$enable_openssl" != "no" && test "$have_openssl" = "yes"])
    
    # Add some more warnings which we use in development but not in the
    # released versions.  (Some relevant gcc versions can't handle these.)
    if test x$enable_gcc_warnings = xyes; then
    
      AC_COMPILE_IFELSE(AC_LANG_PROGRAM([], [
    #if !defined(__GNUC__) || (__GNUC__ < 4)
    #error
    #endif]), have_gcc4=yes, have_gcc4=no)
    
      AC_COMPILE_IFELSE(AC_LANG_PROGRAM([], [
    #if !defined(__GNUC__) || (__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
    #error
    #endif]), have_gcc42=yes, have_gcc42=no)
    
      CFLAGS="$CFLAGS -W -Wfloat-equal -Wundef -Wpointer-arith -Wstrict-prototypes -Wmissing-prototypes -Wwrite-strings -Wredundant-decls -Wchar-subscripts -Wcomment -Wformat -Wwrite-strings -Wmissing-declarations -Wredundant-decls -Wnested-externs -Wbad-function-cast -Wswitch-enum -Werror"
      CFLAGS="$CFLAGS -Wno-unused-parameter -Wno-sign-compare -Wstrict-aliasing"
    
      if test x$have_gcc4 = xyes ; then
        # These warnings break gcc 3.3.5 and work on gcc 4.0.2
        CFLAGS="$CFLAGS -Winit-self -Wmissing-field-initializers -Wdeclaration-after-statement"
        #CFLAGS="$CFLAGS -Wold-style-definition"
      fi
    
      if test x$have_gcc42 = xyes ; then
        # These warnings break gcc 4.0.2 and work on gcc 4.2
        CFLAGS="$CFLAGS -Waddress -Wnormalized=id -Woverride-init"
      fi
    
    ##This will break the world on some 64-bit architectures
    # CFLAGS="$CFLAGS -Winline"
    
    fi
    
    AC_CONFIG_FILES( [libevent.pc] )
    AC_OUTPUT(Makefile include/Makefile test/Makefile sample/Makefile)